SpringBoot官方支援任務排程框架，輕量級用起來也挺香！

大家好，我是二哥呀。定時任務的應用場景其實蠻常見的，比如說：

• 資料備份
• 訂單未支付則自動取消
• 定時爬取資料
• 定時推送資訊
• 定時釋出文章
• 等等（想不出來了，只能等等來湊，?，反正只要等的都需要定時，怎麼樣，這波圓場可以吧）

程式設計喵?實戰專案裡需要做一個定時釋出文章的功能，一開始我想用 Spring Task，於是研究了一番，發現 Spring Task 用起來確實簡單，但對於複雜業務卻也無能為力。

於是我就把注意力放到了 Quartz 上面，這是一款老而彌堅的開源任務排程框架。

記得我在 14 年開發大宗期貨交易平臺的時候就用到了它，每天凌晨定時需要統計一波交易資料，生成日報報表，當時配合 Cron 表示式用的。

可惜後來平臺穩定了，新的政策出來了，直接把大宗期貨交易滅了。於是我發財的機會也隨著破滅了。想想都覺得可惜，哈哈哈。

時光荏苒，Quartz 發展到現在，已經可以和 Spring Boot 專案無縫銜接了，今天我們就來實戰一把。

Timer

JDK 1.3 就開始支援的一種定時任務的實現方式。內部通過 TaskQueue 的類來存放定時任務，用起來比較簡單，但缺陷比較多，比如說一個 Timer 就會起一個執行緒，任務多了效能就非常差，再比如說如果執行任務期間某個 TimerTask 耗時比較久，就會影響其他任務的排程。

@Slf4j
public class TimerDemo {
    public static void main(String[] args) {
        TimerTask task = new TimerTask() {
            @Override
            public void run() {
                log.debug("當前時間{}執行緒名稱{}", DateTime.now(),
                        Thread.currentThread().getName());
            }
        };
        log.debug("當前時間{}執行緒名稱{}", DateTime.now(),
                Thread.currentThread().getName());
        Timer timer = new Timer("TimerDemo");
        timer.schedule(task,1000L);
    }
}

程式碼跑起來後的日誌如下所示：

13:11:45.268 [main] DEBUG top.springtask.TimerDemo - 當前時間2022-04-27 13:11:45執行緒名稱main
13:11:46.280 [TimerDemo] DEBUG top.springtask.TimerDemo - 當前時間2022-04-27 13:11:46執行緒名稱TimerDemo

ScheduledThreadPoolExecutor

JDK 1.5 開始提供的的定時任務，它繼承了 ThreadPoolExecutor，實現了 ScheduledExecutorService 介面，所以支援併發場景下的任務執行。同時，優化了 Timer 的缺陷。不過，由於使用了佇列來實現定時器，就有出入佇列、調整堆等操作，所以定時不是非常非常準確（吹毛求疵）。

@Slf4j
public class ScheduledThreadPoolExecutorDemo {
    public static void main(String[] args) throws InterruptedException {
        TimerTask task = new TimerTask() {
            @Override
            public void run() {
                log.debug("當前時間{}執行緒名稱{}", DateTime.now(),
                        Thread.currentThread().getName());
            }
        };

        log.debug("當前時間{}執行緒名稱{}", DateTime.now(),
                Thread.currentThread().getName());
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(3);
        executorService.scheduleAtFixedRate(task, 1000L,1000L, TimeUnit.MILLISECONDS);
        Thread.sleep(1000+1000*4);
        executorService.shutdown();
    }
}

輸出結果如下所示：

14:43:41.740 [main] DEBUG top.springtask.ScheduledThreadPoolExecutorDemo - 當前時間2022-04-27 14:43:41執行緒名稱main
14:43:42.752 [pool-1-thread-1] DEBUG top.springtask.ScheduledThreadPoolExecutorDemo - 當前時間2022-04-27 14:43:42執行緒名稱pool-1-thread-1
14:43:43.748 [pool-1-thread-1] DEBUG top.springtask.ScheduledThreadPoolExecutorDemo - 當前時間2022-04-27 14:43:43執行緒名稱pool-1-thread-1
14:43:44.749 [pool-1-thread-2] DEBUG top.springtask.ScheduledThreadPoolExecutorDemo - 當前時間2022-04-27 14:43:44執行緒名稱pool-1-thread-2
14:43:45.749 [pool-1-thread-2] DEBUG top.springtask.ScheduledThreadPoolExecutorDemo - 當前時間2022-04-27 14:43:45執行緒名稱pool-1-thread-2
14:43:46.749 [pool-1-thread-2] DEBUG top.springtask.ScheduledThreadPoolExecutorDemo - 當前時間2022-04-27 14:43:46執行緒名稱pool-1-thread-2

Spring Task

Spring Task 是 Spring 提供的輕量級定時任務工具，也就意味著不需要再新增第三方依賴了，相比其他第三方類庫更加方便易用。

好像關於 Spring Task，沒有其他廢話可說了，我們來直接上手。

第一步，新建配置類 SpringTaskConfig，並新增 @EnableScheduling註解開啟 Spring Task。

@Configuration
@EnableScheduling
public class SpringTaskConfig {
}

當然了，也可以不新建這個配置類，直接在主類上新增 @EnableScheduling 註解。

@SpringBootApplication
@EnableScheduling
public class CodingmoreSpringtaskApplication {

	public static void main(String[] args) {
		SpringApplication.run(CodingmoreSpringtaskApplication.class, args);
	}

}

第二步，新建定時任務類 CronTask，使用 @Scheduled 註解註冊 Cron 表示式執行定時任務。

@Slf4j
@Component
public class CronTask {
    @Scheduled(cron = "0/1 * * ? * ?")
    public void cron() {
        log.info("定時執行，時間{}", DateUtil.now());
    }
}

啟動伺服器端，發現每隔一秒鐘會列印一次日誌，證明 Spring Task 的 cron 表示式形式已經起效了。

預設情況下，@Scheduled 建立的執行緒池大小為 1，如果想增加執行緒池大小的話，可以讓 SpringTaskConfig 類實現 SchedulingConfigurer 介面，通過 setPoolSize 增加執行緒池大小。

@Configuration
@EnableScheduling
public class SpringTaskConfig implements SchedulingConfigurer {
    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();

        threadPoolTaskScheduler.setPoolSize(10);
        threadPoolTaskScheduler.setThreadNamePrefix("my-scheduled-task-pool-");
        threadPoolTaskScheduler.initialize();

        taskRegistrar.setTaskScheduler(threadPoolTaskScheduler);
    }
}

服務熱部署完成後，會在控制檯看到這樣的資訊：

可以確認自定義執行緒池大小已經生效了，有的任務用的是執行緒led-task-pool-3，有的是執行緒led-task-pool-7，跑時間長了，可以發現 led-task-pool-1 到 led-task-pool-10 的都有。

Spring Task 除了支援 Cron 表示式，還有 fixedRate（固定速率執行）、fixedDelay（固定延遲執行）、initialDelay（初始延遲）三種用法。

/**
 * fixedRate：固定速率執行。每5秒執行一次。
 */
@Scheduled(fixedRate = 5000)
public void reportCurrentTimeWithFixedRate() {
    log.info("Current Thread : {}", Thread.currentThread().getName());
    log.info("Fixed Rate Task : The time is now {}", DateUtil.now());
}

/**
 * fixedDelay：固定延遲執行。距離上一次呼叫成功後2秒才執。
 */
@Scheduled(fixedDelay = 2000)
public void reportCurrentTimeWithFixedDelay() {
    try {
        TimeUnit.SECONDS.sleep(3);
        log.info("Fixed Delay Task : The time is now {}",DateUtil.now());
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

/**
 * initialDelay:初始延遲。任務的第一次執行將延遲5秒，然後將以5秒的固定間隔執行。
 */
@Scheduled(initialDelay = 5000, fixedRate = 5000)
public void reportCurrentTimeWithInitialDelay() {
    log.info("Fixed Rate Task with Initial Delay : The time is now {}", DateUtil.now());
}

不過，fixedRate 有個坑，假如某個方法的定時器設定的固定速率是每5秒執行一次，這個方法現在要執行下面四個任務，四個任務的耗時是：6s、6s、 2s、 3s，任務會如何執行呢（單執行緒環境下）？

2022-04-27 15:25:52.400  INFO 4343 --- [led-task-pool-1] c.codingmore.component.PublishPostTask   : Fixed Rate Task : The time is now 2022-04-27 15:25:52
2022-04-27 15:25:58.401  INFO 4343 --- [led-task-pool-1] c.codingmore.component.PublishPostTask   : Fixed Rate Task : The time is now 2022-04-27 15:25:58
2022-04-27 15:26:00.407  INFO 4343 --- [led-task-pool-1] c.codingmore.component.PublishPostTask   : Fixed Rate Task : The time is now 2022-04-27 15:26:00
2022-04-27 15:26:04.318  INFO 4343 --- [led-task-pool-1] c.codingmore.component.PublishPostTask   : Fixed Rate Task : The time is now 2022-04-27 15:26:04

第一個任務開始的相對時間是第 0 秒，但由於執行了 6 秒，所以原來應該是第 5 秒執行的任務，延遲到第 6 秒才開始執行，第三個任務延遲了 12 秒，原本應該是第 10 秒執行，第三個任務沒有延遲，正常 15 秒後執行。

假如我們使用 @EnableAsync 註解開啟多執行緒環境的話，結果會怎麼樣呢？

2022-04-27 15:33:01.385  INFO 4421 --- [led-task-pool-1] c.codingmore.component.PublishPostTask   : Fixed Rate Task : The time is now 2022-04-27 15:33:01
2022-04-27 15:33:07.390  INFO 4421 --- [led-task-pool-1] c.codingmore.component.PublishPostTask   : Fixed Rate Task : The time is now 2022-04-27 15:33:07
2022-04-27 15:33:09.391  INFO 4421 --- [led-task-pool-1] c.codingmore.component.PublishPostTask   : Fixed Rate Task : The time is now 2022-04-27 15:33:09
2022-04-27 15:33:13.295  INFO 4421 --- [led-task-pool-1] c.codingmore.component.PublishPostTask   : Fixed Rate Task : The time is now 2022-04-27 15:33:13

關於 Cron 表示式

這裡順帶普及一下 Cron 表示式，在定時任務中會經常會遇到。Cron 這個詞來源於希臘語 chronos，原意也就是時間。

Cron 表示式是一個含有時間意義的字串，以 5 個空格隔開，分成 6 個時間元素。舉幾個例子就一目瞭然了。

示例	說明
0 15 10 ? * *	每天上午10:15執行任務
0 0 10,14,16 * * ?	每天10 點、14 點、16 點執行任務
0 0 12 ? * 3	每個星期三中午 12 點執行任務
0 15 10 15 * ?	每月 15 日上午 10 點 15 執行任務

Cron 的語法格式可以總結為：

Seconds Minutes Hours DayofMonth Month DayofWeek

每個時間元素的取值範圍，以及可出現的特殊字元如下所示。

時間元素	取值範圍	可出現的特殊字元
秒	[0,59]	*,-/
分鐘	[0,59]	*,-/
小時	[0,59]	*,-/
日期	[0,31]	*,-/?LW
月份	[1,12]	*,-/
星期	[1,7]	*,-/?L#

特殊字元的含義和示例如下所示。

特殊字元	含義	示例
*	所有可能的值	很好理解，月域中為每個月，星期域中每個星期幾
,	列舉的值	很好理解，小時域中 10,14,16，就表示這幾個小時可選
-	範圍	很好理解，分鐘域中 10-19，就表示 10-19 分鐘每隔一分鐘執行一次
/	指定數值的增量	很好理解，分鐘域中 0/15，就表示每隔 15 分鐘執行一次
?	不指定值	很好理解，日期域指定了星期域就不能指定值，反之亦然，因為日期域和星期域屬於衝突關係
L	單詞 Last 的首字母	很好理解，日期域和星期域支援，表示月的最後一天或者星期的最後一天
W	除週末以外的工作日	很好理解，僅日期域支援
#	每個月的第幾個星期幾	很好理解，僅星期域支援，4#2表示某月的第二個星期四

關於 Quartz

Quartz 是一款功能強大的開源的任務排程框架，在 GitHub 上已經累計有 5k+ 的 star 了。小到單機應用，大到分散式，都可以整合 Quartz。

在使用 Quartz 之前，讓我們先來搞清楚 4 個核心概念：

• Job：任務，要執行的具體內容。
• JobDetail：任務詳情，Job 是它要執行的內容，同時包含了這個任務排程的策略和方案。
• Trigger：觸發器，可以通過 Cron 表示式來指定任務執行的時間。
• Scheduler：排程器，可以註冊多個 JobDetail 和 Trigger，用來排程、暫停和刪除任務。

整合 Quartz

Quartz 儲存任務的方式有兩種，一種是使用記憶體，另外一種是使用資料庫。記憶體在程式重啟後就丟失了，所以我們這次使用資料庫的方式來進行任務的持久化。

第一步，在 pom.xml 檔案中新增 Quartz 的 starter。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-quartz</artifactId>
    <version>2.6.7</version>
</dependency>

第二步，在 application.yml 新增 Quartz 相關配置，配置說明直接看註釋。

spring:
  quartz:
    job-store-type: jdbc # 預設為記憶體 memory 的方式，這裡我們使用資料庫的形式
    wait-for-jobs-to-complete-on-shutdown: true # 關閉時等待任務完成
    overwrite-existing-jobs: true # 可以覆蓋已有的任務
    jdbc:
      initialize-schema: never # 是否自動使用 SQL 初始化 Quartz 表結構
    properties: # quartz原生配置
      org:
        quartz:
          scheduler:
            instanceName: scheduler # 排程器例項名稱
            instanceId: AUTO # 排程器例項ID自動生成
          # JobStore 相關配置
          jobStore:
            class: org.quartz.impl.jdbcjobstore.JobStoreTX # JobStore 實現類
            driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate # 使用完全相容JDBC的驅動
            tablePrefix: QRTZ_ # Quartz 表字首
            useProperties: false # 是否將JobDataMap中的屬性轉為字串儲存
          # 執行緒池相關配置
          threadPool:
            threadCount: 25 # 執行緒池大小。預設為 10 。
            threadPriority: 5 # 執行緒優先順序
            class: org.quartz.simpl.SimpleThreadPool # 指定執行緒池實現類，對排程器提供固定大小的執行緒池

Quartz 預設使用的是記憶體的方式來儲存任務，為了持久化，我們這裡改為 JDBC 的形式，並且指定 spring.quartz.jdbc.initialize-schema=never，這樣我們可以手動建立資料表。因為該值的另外兩個選項ALWAYS和EMBEDDED都不太符合我們的要求：

• ALWAYS：每次都初始化
• EMBEDDED：只初始化嵌入式資料庫，比如說 H2、HSQL

那手動建立資料表的 SQL 語句去哪裡找呢？

GitHub 地址：https://github.com/quartz-scheduler/quartz/tree/master/quartz-core/src/main/resources/org/quartz/impl/jdbcjobstore

為了方便小夥伴們下載，我把它放在了本教程的原始碼裡面了：

如果使用 Intellij IDEA 旗艦版的話，首次開啟 SQL 檔案的時候會提示你指定資料來源。在上圖中，我配置了本地的 MySQL 資料庫，匯入成功後可以在資料庫中檢視到以下資料表：

Quartz資料庫核心表如下：

Table Name	Description
QRTZ_CALENDARS	儲存Quartz的Calendar資訊
QRTZ_CRON_TRIGGERS	儲存CronTrigger，包括Cron表示式和時區資訊
QRTZ_FIRED_TRIGGERS	儲存與已觸發的Trigger相關的狀態資訊，以及相聯Job的執行資訊
QRTZ_PAUSED_TRIGGER_GRPS	儲存已暫停的Trigger組的資訊
QRTZ_SCHEDULER_STATE	儲存少量的有關Scheduler的狀態資訊，和別的Scheduler例項
QRTZ_LOCKS	儲存程式的悲觀鎖的資訊
QRTZ_JOB_DETAILS	儲存每一個已配置的Job的詳細資訊
QRTZ_JOB_LISTENERS	儲存有關已配置的JobListener的資訊
QRTZ_SIMPLE_TRIGGERS	儲存簡單的Trigger，包括重複次數、間隔、以及已觸的次數
QRTZ_BLOG_TRIGGERS	Trigger作為Blob型別儲存
QRTZ_TRIGGER_LISTENERS	儲存已配置的TriggerListener的資訊
QRTZ_TRIGGERS	儲存已配置的Trigger的資訊

剩下的就是對 Quartz 的 scheduler、jobStore 和 threadPool 配置。

第三步，建立任務排程的介面 IScheduleService，定義三個方法，分別是通過 Cron 表示式來排程任務、指定時間來排程任務，以及取消任務。

public interface IScheduleService {
    /**
     * 通過 Cron 表示式來排程任務
     */
    String scheduleJob(Class<? extends Job> jobBeanClass, String cron, String data);

    /**
     * 指定時間來排程任務
     */
    String scheduleFixTimeJob(Class<? extends Job> jobBeanClass, Date startTime, String data);

    /**
     * 取消定時任務
     */
    Boolean cancelScheduleJob(String jobName);
}

第四步，建立任務排程業務實現類 ScheduleServiceImpl，通過Scheduler、CronTrigger、JobDetail的API來實現對應的方法。

@Slf4j
@Service
public class ScheduleServiceImpl implements IScheduleService {
    private String defaultGroup = "default_group";

    @Autowired
    private Scheduler scheduler;
    @Override
    public String scheduleJob(Class<? extends Job> jobBeanClass, String cron, String data) {
        String jobName = UUID.fastUUID().toString();
        JobDetail jobDetail = JobBuilder.newJob(jobBeanClass)
                .withIdentity(jobName, defaultGroup)
                .usingJobData("data", data)
                .build();
        //建立觸發器，指定任務執行時間
        CronTrigger cronTrigger = TriggerBuilder.newTrigger()
                .withIdentity(jobName, defaultGroup)
                .withSchedule(CronScheduleBuilder.cronSchedule(cron))
                .build();
        // 排程器進行任務排程
        try {
            scheduler.scheduleJob(jobDetail, cronTrigger);
        } catch (SchedulerException e) {
            log.error("任務排程執行失敗{}", e.getMessage());
        }
        return jobName;
    }

    @Override
    public String scheduleFixTimeJob(Class<? extends Job> jobBeanClass, Date startTime, String data) {
        //日期轉CRON表示式
        String startCron = String.format("%d %d %d %d %d ? %d",
                DateUtil.second(startTime),
                DateUtil.minute(startTime),
                DateUtil.hour(startTime, true),
                DateUtil.dayOfMonth(startTime),
                DateUtil.month(startTime) + 1,
                DateUtil.year(startTime));
        return scheduleJob(jobBeanClass, startCron, data);
    }

    @Override
    public Boolean cancelScheduleJob(String jobName) {
        boolean success = false;
        try {
            // 暫停觸發器
            scheduler.pauseTrigger(new TriggerKey(jobName, defaultGroup));
            // 移除觸發器中的任務
            scheduler.unscheduleJob(new TriggerKey(jobName, defaultGroup));
            // 刪除任務
            scheduler.deleteJob(new JobKey(jobName, defaultGroup));
            success = true;
        } catch (SchedulerException e) {
            log.error("任務取消失敗{}", e.getMessage());
        }
        return success;
    }
}

第五步，定義好要執行的任務，繼承 QuartzJobBean 類，實現
executeInternal 方法，這裡只定義一個定時釋出文章的任務。

@Slf4j
@Component
public class PublishPostJob extends QuartzJobBean {
    @Autowired
    private IScheduleService scheduleService;
    @Autowired
    private IPostsService postsService;

    @Override
    protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        Trigger trigger = jobExecutionContext.getTrigger();
        JobDetail jobDetail = jobExecutionContext.getJobDetail();
        JobDataMap jobDataMap = jobDetail.getJobDataMap();
        Long data = jobDataMap.getLong("data");
        log.debug("定時釋出文章操作：{}",data);

        // 獲取文章的 ID後獲取文章，更新文章為釋出的狀態，還有釋出的時間
        boolean success = postsService.updatePostByScheduler(data);

        //完成後刪除觸發器和任務
        if (success) {
            log.debug("定時任務執行成功，開始清除定時任務");
            scheduleService.cancelScheduleJob(trigger.getKey().getName());
        }
    }
}

第六步，釋出文章的介面裡 PostsServiceImpl 新增定時釋出的任務排程方法。

@Service
public class PostsServiceImpl extends ServiceImpl<PostsMapper, Posts> implements IPostsService {

    private void handleScheduledAfter(Posts posts) {
        // 文章已經儲存為草稿了，並且拿到了文章 ID
        // 呼叫定時任務
        String jobName = scheduleService.scheduleFixTimeJob(PublishPostJob.class, posts.getPostDate(), posts.getPostsId().toString());
        LOGGER.debug("定時任務{}開始執行", jobName);
    }

}

好，我們現在啟動服務，通過Swagger 來測試一下，注意設定文章的定時釋出時間。

檢視 Quartz 的資料表 qrtz_cron_triggers，發現任務已經新增進來了。

qrtz_job_details 表裡也可以檢視具體的任務詳情。

文章定時釋出的時間到了之後，在日誌裡也可以看到 Quartz 的執行日誌。

再次檢視 Quartz 資料表 qrtz_cron_triggers 和 qrtz_job_details 的時候，也會發現定時任務已經清除了。

整體上來說，Spring Boot 整合 Quartz還是非常絲滑的，配置少，步驟清晰，比 Spring Task 更強大，既能針對記憶體也能持久化，所以大家在遇到定時任務的時候完全可以嘗試一把。

完整的功能在程式設計喵實戰專案中已經實現了，可以把程式設計喵匯入到本地嘗試一下。

業務梳理

簡單來梳理一下程式設計喵定時釋出文章的業務。

1）使用者在釋出文章的時候可以選擇定時釋出，如果選擇定時釋出，那麼就要設定定時釋出的時間，暫時規定至少十分鐘以後可以定時。

2）當管理端使用者選擇了定時釋出，那麼在儲存文章的時候，文章狀態要先設定為草稿狀態，對前端使用者是不可見的狀態。

3）儲存文章的時候通知 Quartz，我有一個任務，你需要在某個規定的時間去執行。

scheduleService.scheduleFixTimeJob(PublishPostJob.class, posts.getPostDate(), posts.getPostsId().toString());

4）Quartz 收到這個通知後，就會在資料庫中寫入任務，具體的任務是到指定時間把文章從草稿的狀態轉為釋出狀態，這時候，前端使用者就可以看得見文章了。

// 獲取文章的 ID後獲取文章，更新文章為釋出的狀態，還有釋出的時間
boolean success = postsService.updatePostByScheduler(data);

同時，將任務清除。

// 暫停觸發器
scheduler.pauseTrigger(new TriggerKey(jobName, defaultGroup));
// 移除觸發器中的任務
scheduler.unscheduleJob(new TriggerKey(jobName, defaultGroup));
// 刪除任務
scheduler.deleteJob(new JobKey(jobName, defaultGroup));

整個過程就完成了。Quartz 是如何實現定時釋出文章的呢？其實也是通過 Cron 表示式。

CronTrigger cronTrigger = TriggerBuilder.newTrigger()
                .withIdentity(jobName, defaultGroup)
                .withSchedule(CronScheduleBuilder.cronSchedule(cron))
                .build();

也就是當我們傳入一個指定時間後，通過計算，計算出 Cron 表示式。

String startCron = String.format("%d %d %d %d %d ? %d",
                DateUtil.second(startTime),
                DateUtil.minute(startTime),
                DateUtil.hour(startTime, true),
                DateUtil.dayOfMonth(startTime),
                DateUtil.month(startTime) + 1,
                DateUtil.year(startTime));

在 Quartz 中，有兩類執行緒：Scheduler排程執行緒和任務執行執行緒。

• 任務執行執行緒：Quartz不會在主執行緒(QuartzSchedulerThread)中處理使用者的Job。Quartz把執行緒管理的職責委託給ThreadPool，一般的設定使用SimpleThreadPool。SimpleThreadPool建立了一定數量的WorkerThread例項來使得Job能夠線上程中進行處理。WorkerThread是定義在SimpleThreadPool類中的內部類，它實質上就是一個執行緒。
• QuartzSchedulerThread排程主執行緒：QuartzScheduler被建立時建立一個QuartzSchedulerThread例項。

原始碼路徑

• 程式設計喵：https://github.com/itwanger/coding-more
• codingmore-springtask：https://github.com/itwanger/codingmore-learning
• codingmore-quartz：https://github.com/itwanger/codingmore-learning

本文已收錄到 GitHub 上星標 2.4k+ 的開源專欄《Java 程式設計師進階之路》，據說每一個優秀的 Java 程式設計師都喜歡她，風趣幽默、通俗易懂。內容包括 Java 基礎、Java 併發程式設計、Java 虛擬機器、Java 企業級開發、Java 面試等核心知識點。學 Java，就認準 Java 程式設計師進階之路?。

https://github.com/itwanger/toBeBetterJavaer

star 了這個倉庫就等於你擁有了成為了一名優秀 Java 工程師的潛力。該開源倉庫最近又上 GitHub trending 榜單了，看來是大家都非常認可呀！

沒有什麼使我停留——除了目的，縱然岸旁有玫瑰、有綠蔭、有寧靜的港灣，我是不繫之舟。