任务调度引擎quartz集群化部署能力总结

迈不过友情╰ 2023-05-31 15:19 11阅读 0赞

公司产品中使用了quartz任务调度器，在分布式部署中，需要对quartz的集群化能力进行基础性的测试，需要测试以下内容：

1.节点失效转移：节点发生故障时，能否转移到其他节点。

2.任务失效转移：当某一个任务发生异常时，能否被重复调度执行。

3.任务单实例执行：是否支持任务仅单实例运行，不被多实例同时调度。

4.misfire后是否立即执行：当一个任务调度时间已到，但是上一次还未执行完成时，任务调度行为如何。

5.性能容量：并发执行任务的最大能力是多少。

6.一次执行任务：是否支持某任务仅执行一次。

7.立即执行某个任务：是否支持立即出发某个任务的执行。

**测试方法：**

测试所用程序下载地址：

[https://github.com/jiangbb868/alltest-spring-boot.git][https_github.com_jiangbb868_alltest-spring-boot.git]

a) 下载代码到本地

b) 准备数据库，数据库使用的PostgreSQL，需要初始化quartz的数据库表，建表语句如下：

-- Thanks to Patrick Lightbody for submitting this...
    --
    -- In your Quartz properties file, you'll need to set 
    -- org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.PostgreSQLDelegate
     
    DROP TABLE IF EXISTS QRTZ_FIRED_TRIGGERS;
    DROP TABLE IF EXISTS QRTZ_PAUSED_TRIGGER_GRPS;
    DROP TABLE IF EXISTS QRTZ_SCHEDULER_STATE;
    DROP TABLE IF EXISTS QRTZ_LOCKS;
    DROP TABLE IF EXISTS QRTZ_SIMPLE_TRIGGERS;
    DROP TABLE IF EXISTS QRTZ_CRON_TRIGGERS;
    DROP TABLE IF EXISTS QRTZ_SIMPROP_TRIGGERS;
    DROP TABLE IF EXISTS QRTZ_BLOB_TRIGGERS;
    DROP TABLE IF EXISTS QRTZ_TRIGGERS;
    DROP TABLE IF EXISTS QRTZ_JOB_DETAILS;
    DROP TABLE IF EXISTS QRTZ_CALENDARS;
     
    CREATE TABLE QRTZ_JOB_DETAILS
    (
      SCHED_NAME        VARCHAR(120) NOT NULL,
      JOB_NAME          VARCHAR(200) NOT NULL,
      JOB_GROUP         VARCHAR(200) NOT NULL,
      DESCRIPTION       VARCHAR(250) NULL,
      JOB_CLASS_NAME    VARCHAR(250) NOT NULL,
      IS_DURABLE        BOOL         NOT NULL,
      IS_NONCONCURRENT  BOOL         NOT NULL,
      IS_UPDATE_DATA    BOOL         NOT NULL,
      REQUESTS_RECOVERY BOOL         NOT NULL,
      JOB_DATA          BYTEA        NULL,
      PRIMARY KEY (SCHED_NAME, JOB_NAME, JOB_GROUP)
    );
     
    CREATE TABLE QRTZ_TRIGGERS
    (
      SCHED_NAME     VARCHAR(120) NOT NULL,
      TRIGGER_NAME   VARCHAR(200) NOT NULL,
      TRIGGER_GROUP  VARCHAR(200) NOT NULL,
      JOB_NAME       VARCHAR(200) NOT NULL,
      JOB_GROUP      VARCHAR(200) NOT NULL,
      DESCRIPTION    VARCHAR(250) NULL,
      NEXT_FIRE_TIME BIGINT       NULL,
      PREV_FIRE_TIME BIGINT       NULL,
      PRIORITY       INTEGER      NULL,
      TRIGGER_STATE  VARCHAR(16)  NOT NULL,
      TRIGGER_TYPE   VARCHAR(8)   NOT NULL,
      START_TIME     BIGINT       NOT NULL,
      END_TIME       BIGINT       NULL,
      CALENDAR_NAME  VARCHAR(200) NULL,
      MISFIRE_INSTR  SMALLINT     NULL,
      JOB_DATA       BYTEA        NULL,
      PRIMARY KEY (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP),
      FOREIGN KEY (SCHED_NAME, JOB_NAME, JOB_GROUP)
      REFERENCES QRTZ_JOB_DETAILS (SCHED_NAME, JOB_NAME, JOB_GROUP)
    );
     
    CREATE TABLE QRTZ_SIMPLE_TRIGGERS
    (
      SCHED_NAME      VARCHAR(120) NOT NULL,
      TRIGGER_NAME    VARCHAR(200) NOT NULL,
      TRIGGER_GROUP   VARCHAR(200) NOT NULL,
      REPEAT_COUNT    BIGINT       NOT NULL,
      REPEAT_INTERVAL BIGINT       NOT NULL,
      TIMES_TRIGGERED BIGINT       NOT NULL,
      PRIMARY KEY (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP),
      FOREIGN KEY (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP)
      REFERENCES QRTZ_TRIGGERS (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP)
    );
     
    CREATE TABLE QRTZ_CRON_TRIGGERS
    (
      SCHED_NAME      VARCHAR(120) NOT NULL,
      TRIGGER_NAME    VARCHAR(200) NOT NULL,
      TRIGGER_GROUP   VARCHAR(200) NOT NULL,
      CRON_EXPRESSION VARCHAR(120) NOT NULL,
      TIME_ZONE_ID    VARCHAR(80),
      PRIMARY KEY (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP),
      FOREIGN KEY (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP)
      REFERENCES QRTZ_TRIGGERS (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP)
    );
     
    CREATE TABLE QRTZ_SIMPROP_TRIGGERS
    (
      SCHED_NAME    VARCHAR(120)   NOT NULL,
      TRIGGER_NAME  VARCHAR(200)   NOT NULL,
      TRIGGER_GROUP VARCHAR(200)   NOT NULL,
      STR_PROP_1    VARCHAR(512)   NULL,
      STR_PROP_2    VARCHAR(512)   NULL,
      STR_PROP_3    VARCHAR(512)   NULL,
      INT_PROP_1    INT            NULL,
      INT_PROP_2    INT            NULL,
      LONG_PROP_1   BIGINT         NULL,
      LONG_PROP_2   BIGINT         NULL,
      DEC_PROP_1    NUMERIC(13, 4) NULL,
      DEC_PROP_2    NUMERIC(13, 4) NULL,
      BOOL_PROP_1   BOOL           NULL,
      BOOL_PROP_2   BOOL           NULL,
      PRIMARY KEY (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP),
      FOREIGN KEY (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP)
      REFERENCES QRTZ_TRIGGERS (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP)
    );
     
    CREATE TABLE QRTZ_BLOB_TRIGGERS
    (
      SCHED_NAME    VARCHAR(120) NOT NULL,
      TRIGGER_NAME  VARCHAR(200) NOT NULL,
      TRIGGER_GROUP VARCHAR(200) NOT NULL,
      BLOB_DATA     BYTEA        NULL,
      PRIMARY KEY (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP),
      FOREIGN KEY (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP)
      REFERENCES QRTZ_TRIGGERS (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP)
    );
     
    CREATE TABLE QRTZ_CALENDARS
    (
      SCHED_NAME    VARCHAR(120) NOT NULL,
      CALENDAR_NAME VARCHAR(200) NOT NULL,
      CALENDAR      BYTEA        NOT NULL,
      PRIMARY KEY (SCHED_NAME, CALENDAR_NAME)
    );
     
     
    CREATE TABLE QRTZ_PAUSED_TRIGGER_GRPS
    (
      SCHED_NAME    VARCHAR(120) NOT NULL,
      TRIGGER_GROUP VARCHAR(200) NOT NULL,
      PRIMARY KEY (SCHED_NAME, TRIGGER_GROUP)
    );
     
    CREATE TABLE QRTZ_FIRED_TRIGGERS
    (
      SCHED_NAME        VARCHAR(120) NOT NULL,
      ENTRY_ID          VARCHAR(95)  NOT NULL,
      TRIGGER_NAME      VARCHAR(200) NOT NULL,
      TRIGGER_GROUP     VARCHAR(200) NOT NULL,
      INSTANCE_NAME     VARCHAR(200) NOT NULL,
      FIRED_TIME        BIGINT       NOT NULL,
      SCHED_TIME        BIGINT       NOT NULL,
      PRIORITY          INTEGER      NOT NULL,
      STATE             VARCHAR(16)  NOT NULL,
      JOB_NAME          VARCHAR(200) NULL,
      JOB_GROUP         VARCHAR(200) NULL,
      IS_NONCONCURRENT  BOOL         NULL,
      REQUESTS_RECOVERY BOOL         NULL,
      PRIMARY KEY (SCHED_NAME, ENTRY_ID)
    );
     
    CREATE TABLE QRTZ_SCHEDULER_STATE
    (
      SCHED_NAME        VARCHAR(120) NOT NULL,
      INSTANCE_NAME     VARCHAR(200) NOT NULL,
      LAST_CHECKIN_TIME BIGINT       NOT NULL,
      CHECKIN_INTERVAL  BIGINT       NOT NULL,
      PRIMARY KEY (SCHED_NAME, INSTANCE_NAME)
    );
     
    CREATE TABLE QRTZ_LOCKS
    (
      SCHED_NAME VARCHAR(120) NOT NULL,
      LOCK_NAME  VARCHAR(40)  NOT NULL,
      PRIMARY KEY (SCHED_NAME, LOCK_NAME)
    );
     
    CREATE INDEX IDX_QRTZ_J_REQ_RECOVERY
      ON QRTZ_JOB_DETAILS (SCHED_NAME, REQUESTS_RECOVERY);
    CREATE INDEX IDX_QRTZ_J_GRP
      ON QRTZ_JOB_DETAILS (SCHED_NAME, JOB_GROUP);
     
    CREATE INDEX IDX_QRTZ_T_J
      ON QRTZ_TRIGGERS (SCHED_NAME, JOB_NAME, JOB_GROUP);
    CREATE INDEX IDX_QRTZ_T_JG
      ON QRTZ_TRIGGERS (SCHED_NAME, JOB_GROUP);
    CREATE INDEX IDX_QRTZ_T_C
      ON QRTZ_TRIGGERS (SCHED_NAME, CALENDAR_NAME);
    CREATE INDEX IDX_QRTZ_T_G
      ON QRTZ_TRIGGERS (SCHED_NAME, TRIGGER_GROUP);
    CREATE INDEX IDX_QRTZ_T_STATE
      ON QRTZ_TRIGGERS (SCHED_NAME, TRIGGER_STATE);
    CREATE INDEX IDX_QRTZ_T_N_STATE
      ON QRTZ_TRIGGERS (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP, TRIGGER_STATE);
    CREATE INDEX IDX_QRTZ_T_N_G_STATE
      ON QRTZ_TRIGGERS (SCHED_NAME, TRIGGER_GROUP, TRIGGER_STATE);
    CREATE INDEX IDX_QRTZ_T_NEXT_FIRE_TIME
      ON QRTZ_TRIGGERS (SCHED_NAME, NEXT_FIRE_TIME);
    CREATE INDEX IDX_QRTZ_T_NFT_ST
      ON QRTZ_TRIGGERS (SCHED_NAME, TRIGGER_STATE, NEXT_FIRE_TIME);
    CREATE INDEX IDX_QRTZ_T_NFT_MISFIRE
      ON QRTZ_TRIGGERS (SCHED_NAME, MISFIRE_INSTR, NEXT_FIRE_TIME);
    CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE
      ON QRTZ_TRIGGERS (SCHED_NAME, MISFIRE_INSTR, NEXT_FIRE_TIME, TRIGGER_STATE);
    CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE_GRP
      ON QRTZ_TRIGGERS (SCHED_NAME, MISFIRE_INSTR, NEXT_FIRE_TIME, TRIGGER_GROUP, TRIGGER_STATE);
     
    CREATE INDEX IDX_QRTZ_FT_TRIG_INST_NAME
      ON QRTZ_FIRED_TRIGGERS (SCHED_NAME, INSTANCE_NAME);
    CREATE INDEX IDX_QRTZ_FT_INST_JOB_REQ_RCVRY
      ON QRTZ_FIRED_TRIGGERS (SCHED_NAME, INSTANCE_NAME, REQUESTS_RECOVERY);
    CREATE INDEX IDX_QRTZ_FT_J_G
      ON QRTZ_FIRED_TRIGGERS (SCHED_NAME, JOB_NAME, JOB_GROUP);
    CREATE INDEX IDX_QRTZ_FT_JG
      ON QRTZ_FIRED_TRIGGERS (SCHED_NAME, JOB_GROUP);
    CREATE INDEX IDX_QRTZ_FT_T_G
      ON QRTZ_FIRED_TRIGGERS (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP);
    CREATE INDEX IDX_QRTZ_FT_TG
      ON QRTZ_FIRED_TRIGGERS (SCHED_NAME, TRIGGER_GROUP);
     
     
    COMMIT;

c) 准备redis

本人是在docker中运行redis，可执行以下命令：

docker pull redis   \#将docker镜像下载到本地

docker run -d -p 6379:6379 --name=redis redis    \#启动redis

d) 修改配置

修改application.yaml

server:
      port: 8080
    spring:
      redis:
        database: 0
        host: 172.17.189.65
        port: 6379
        jedis:
          pool:
            max-active: 8
            max-wait: 1ms
        timeout: 1000ms

将redis的地址和端口设置为实际的地址和端口。

修改quartz.properties

#============================================================================
    # Configure Main Scheduler Properties
    #============================================================================
    
    org.quartz.scheduler.instanceName: TestScheduler
    org.quartz.scheduler.instanceId: AUTO
    
    #============================================================================
    # Configure ThreadPool
    #============================================================================
    
    org.quartz.threadPool.class: org.quartz.simpl.SimpleThreadPool
    org.quartz.threadPool.threadCount: 100
    org.quartz.threadPool.threadPriority: 5
    
    #============================================================================
    # Configure JobStore
    #============================================================================
    
    org.quartz.jobStore.misfireThreshold: 60000
    
    org.quartz.jobStore.class=org.quartz.impl.jdbcjobstore.JobStoreTX
    org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.PostgreSQLDelegate
    org.quartz.jobStore.useProperties=false
    org.quartz.jobStore.dataSource=myDS
    org.quartz.jobStore.tablePrefix=QRTZ_
    org.quartz.jobStore.isClustered=true
    
    #============================================================================
    # Configure Datasources
    #============================================================================
    
    org.quartz.dataSource.myDS.driver: org.postgresql.Driver
    org.quartz.dataSource.myDS.URL: jdbc:postgresql://localhost:5432/itone
    org.quartz.dataSource.myDS.user: postgres
    org.quartz.dataSource.myDS.password:
    org.quartz.dataSource.myDS.maxConnections: 5
    org.quartz.dataSource.myDS.validationQuery: select 0

将数据库的地址和端口修改为实际的地址和端口。

e) 编译测试程序

mvn install

f) 启动实例

启动实例1

java -jar target\\quartz\\quartz-1.0-SNAPSHOT.jar --server.port=8080

启动实例2

java -jar target\\quartz\\quartz-1.0-SNAPSHOT.jar --server.port=8082

**API说明：**

添加任务接口

GET  /addJob/\{group\}/\{prefix\}/\{count\}/\{interval\}

删除任务接口

GET /removeJob/\{jobName\}/\{group\}

删除全部任务接口

GET /clearAllJob

触发某任务执行接口

GET /triggerJob/\{jobName\}

**请求示例：**

添加A任务，group为test，数量为1，间隔30s  
http://localhost:8080/addJob/test/A/1/30  
添加A任务，group为test，数量为1，执行2次，间隔30秒  
http://localhost:8080/addJob/test/A/1/2-20  
添加A任务，group为test，数量为1，执行1次  
http://localhost:8080/addJob/test/A/1/0-20  
触发某任务立即执行，任务名称为job\_A\_1  
http://localhost:8080/triggerJob/job\_A\_1  
删除所有任务  
http://localhost:8080/clearAllJob  
删除某个任务，任务名称为job\_A\_1， group为test  
http://localhost:8080/removeJob/jobName/test

**任务类型说明：**

A任务，执行时间60s阻塞  
B任务，执行时间10s阻塞  
C任务，密集计算任务  
D任务，简单计算，第一次执行抛异常  
E任务，InterruptableJob  
F任务，普通可并行任务

**测试记录及结果如下：**

**2. 性能容量**

**2.1 单实例**

当定时任务为短任务(10s阻塞)时，线程数多了则无法打满，不足一半，当任务为长任务时(60s阻塞)线程能够打满

长任务60s阻塞，1000线程， 能打满

长任务60s阻塞，1500线程， 能打满

长任务60s阻塞，2000线程， 最多1600

长任务计算密集型，1000， 能打满，死机

**2.2 双实例**

长任务60s阻塞，各1000线程，能打满2x1000，实例A打满后，再调度实例B

短任务10s阻塞，各1000线程，每个最多打150

长任务60s阻塞，各2000线程，每个最多打1100

**2.3 三实例**

长任务60s阻塞，各2000线程，负载不均衡，总计最大2000

**2.4 结论**

集群的容量取决于硬件资源（CPU、内存等），任务的执行类型（阻塞、密集计算）

在同等资源情况下：

单实例：长阻塞任务：1600并发

双实例：长阻塞任务：2200并发，短任务：300并发

三实例：长阻塞任务：2000并发

**3. 并发测试**

并发测试（任务执行时间为10s，配置为每5秒执行一次）

任务增加@DisallowConcurrentExecution，严格按照单例执行，一个执行完成会立即执行下一个，在单个实例上执行

不增加@DisallowConcurrentExecution，每5秒执行一次。在一个实例上执行

任务有group标识是哪一个实例创建的，调用时优先同group的实例调用。

relax任务集群测试

非并发任务测试

任务阻塞60s，配置为每30s执行一次

实际：每90s执行一次。

当前任务为非并发

**结论：**

a) 任务增加@DisallowConcurrentExecution，严格按照单例执行，不增加则可并发执行。

b) 在Relax上测试结果不同，没有增加@DisallowConcurrentExecution，也能单例执行，但是实际执行频率为：配置频率+执行时长。原因是Relax自定义实现了先的Trigger，该trigger做了特殊的设置。

**4. 故障转移**

**4.1 节点故障转移**

故障转移测试1（任务执行时间为60s，配置为每5秒执行一次，共执行20次，任务设置requestRecovery）

由节点1创建任务，在节点1上开始执行，当执行到第2次时，节点崩溃，节点2继续执行剩余的次数。

故障转移测试2（任务执行时间为60s，配置为每5秒执行一次，共执行3次，任务未设置requestRecovery）

由节点1创建任务，在节点1上开始执行，当执行到第2次时，节点崩溃，节点2继续执行剩余的次数。

故障转移测试3（任务执行时间为60s，配置为每5秒执行一次，共执行1次，任务未设置requestRecovery）

由节点1创建任务，在节点1上开始执行，当执行到第2次时，节点崩溃，节点2继续执行剩余的次数。

**结论**

a) group属性关联所在实例，默认优先在此实例上调度，但是偶尔会在其他的实例上调度。

b) 当一个实例发生崩溃（程序shutdown），正在执行的任务会被其他实例接管并执行一次。

**4.2 任务故障转移**

一次性任务，执行过程中异常必须是JobExecutionException，抛出异常后，不再执行，因quartz已经删除了任务和trigger的相关信息。

重复任务，如在任务执行构成中抛异常，则会重复调度。

**结论**

当任务发生异常后，在所在实例上会重新调度一次。

**5. 立即执行**

**5.1 立即执行**

非并行任务

需要等到正在执行的任务执行完成后，才进行下一次调度，调度花费时间为60-100ms

当任务间隔小于任务执行时间时，调度会出现不稳定。如：发生一次misfire后，相隔几个调度周期后才继续调度。

当执行周期大于执行时间的任务，调度频率正常。

**5.2 一次性执行**

方法一：

JobDetail jobDetail = newJob(clazz)
    		.withIdentity(jobIdentity, schedulerManager.getSchedulerId())
    		.requestRecovery()
    		.build();
    Trigger trigger = TriggerBuilder.newTrigger()
    					.withIdentity(triggerIdentity, schedulerManager.getSchedulerId())
    					.startAt(futureDate(1, DateBuilder.IntervalUnit.SECOND))
    					.withSchedule(
    							simpleSchedule().withRepeatCount(0).withIntervalInSeconds(5))
    					.build();
    scheduler.scheduleJob(jobDetail, trigger);

重复次数=0的SimpleTrigger即可实现。

一次性任务执行完成后，仅qrtz\_scheduler\_state、qrtz\_locks中留存记录，其他表的记录都将清除。

方法二：

JobKey jobKey = new JobKey(jobName, group);
    	scheduler.triggerJob(jobKey);

jobName必须存在，group必须存在

非并行重复任务，如果任务当前不在执行，则立即执行，如果任务正在执行，则等该次执行完成后再执行。

**6. 任务删除、调度**

删除任务时，一个实例可删除与自己实例名称相同的实例创建的任务，任务需要指定group，不指定group，默认的group为DEFAULT。

可能存在的问题：如果多个实例都创建了任务，在删除时仅能删除本实例创建的job。

[https_github.com_jiangbb868_alltest-spring-boot.git]: https://github.com/jiangbb868/alltest-spring-boot.git