SpringBoot | 第二十二章：定時任務的使用

阿新 • • 發佈：2018-12-10

前言

上兩章節，我們簡單的講解了關於非同步呼叫和非同步請求相關知識點。這一章節，我們來講講開發過程也是經常會碰見的定時任務。比如每天定時清理無效資料、定時傳送簡訊、定時傳送郵件、支付系統中的定時對賬等等，往往都會定義一些定時器，進行此業務的開發。所以，本章節介紹下在SpringBoot中定時任務如何使用及一點分散式定時服務的思考總結。

一點知識

在JAVA開發領域，目前可以通過以下幾種方式進行定時任務:

Timer：jdk中自帶的一個定時排程類，可以簡單的實現按某一頻度進行任務執行。提供的功能比較單一，無法實現複雜的排程任務。
ScheduledExecutorService：也是jdk自帶的一個基於執行緒池設計的定時任務類。其每個排程任務都會分配到執行緒池中的一個執行緒執行，所以其任務是併發執行的，互不影響。

Spring Task：Spring提供的一個任務排程工具，支援註解和配置檔案形式，支援Cron表示式，使用簡單但功能強大。
Quartz：一款功能強大的任務排程器，可以實現較為複雜的排程功能，如每月一號執行、每天凌晨執行、每週五執行等等，還支援分散式排程，就是配置稍顯複雜。

題外話：對於Quartz，早前用過1.6版本的，更新到2.x及以上版本後基本沒怎麼接觸了，原來還有倒騰過結合Kettle做了一些動態的定時抽取資料啥的還編寫過一個Cron表示式編輯器，現在基本忘記了。。等有機會，再次深入學習後再來單獨分享一些關於的Quartz心得吧。

基於JDK方式實現簡單定時

剛剛有介紹過，基於JDK

方式一共有兩種：Timer和ScheduledExecutorService。接下來，就簡單講解下這兩種方式。

Timer

Timer是jdk提供的java.util.Timer類。

簡單示例：

@GetMapping("/timer")
public String doTimer() {
    Timer timer = new Timer();
    timer.schedule(new TimerTask() {
        
        @Override
        public void run() {
            log.info("Timer定時任務啟動：" + new Date());
            
        }
    }, 1000,1000);//延遲1秒啟動，每1秒執行一次
    return "timer";

啟動後，訪問即可看見控制檯週期性輸出資訊了：

2018-08-18 21:30:35.171  INFO 13352 --- [        Timer-0] c.l.l.s.c.controller.TaskController      : Timer定時任務啟動：Sat Aug 18 21:30:35 CST 2018
2018-08-18 21:30:36.173  INFO 13352 --- [        Timer-0] c.l.l.s.c.controller.TaskController      : Timer定時任務啟動：Sat Aug 18 21:30:36 CST 2018
2018-08-18 21:30:37.173  INFO 13352 --- [        Timer-0] c.l.l.s.c.controller.TaskController      : Timer定時任務啟動：Sat Aug 18 21:30:37 CST 2018
2018-08-18 21:30:38.173  INFO 13352 --- [        Timer-0] c.l.l.s.c.controller.TaskController      : Timer定時任務啟動：Sat Aug 18 21:30:38 CST 2018
2018-08-18 21:30:39.174  INFO 13352 --- [        Timer-0] c.l.l.s.c.controller.TaskController      : Timer定時任務啟動：Sat Aug 18 21:30:39 CST 2018
......

相關API簡單說明：

1、在特定時間執行任務，只執行一次

public void schedule(TimerTask task,Date time)

2、在特定時間之後執行任務，只執行一次

public void schedule(TimerTask task,long delay)

3、指定第一次執行的時間，然後按照間隔時間，重複執行

public void schedule(TimerTask task,Date firstTime,long period)

4、在特定延遲之後第一次執行，然後按照間隔時間，重複執行

public void schedule(TimerTask task,long delay,long period)

5、第一次執行之後，特定頻率執行，與3同

public void scheduleAtFixedRate(TimerTask task,Date firstTime,long period)

6、在delay毫秒之後第一次執行，後按照特定頻率執行

public void scheduleAtFixedRate(TimerTask task,long delay,long period)

引數：

delay：延遲執行的毫秒數，即在delay毫秒之後第一次執行
period：重複執行的時間間隔

取消任務使用：timer.cancel()方法即可登出任務。

此類相對用的較少了，簡單瞭解下。

ScheduledExecutorService

ScheduledExecutorService可以說是Timer的替代類，因為Timer不支援多執行緒，任務是序列的，而且也不捕獲異常，假設某個任務異常了，整個Timer就無法運行了。

簡單示例：

@GetMapping("/executor")
public String ScheduledExecutorService() {
    //
    ScheduledExecutorService service = Executors.newScheduledThreadPool(10);
    service.scheduleAtFixedRate(new Runnable() {
        
        @Override
        public void run() {
            log.info("ScheduledExecutorService定時任務執行：" + new Date());                
        }
    }, 1, 1, TimeUnit.SECONDS);//首次延遲1秒，之後每1秒執行一次
    log.info("ScheduledExecutorService定時任務啟動：" + new Date());    
    return "ScheduledExecutorService!";        
}

啟動後，可看見控制檯按設定的頻率輸出：

2018-08-18 22:03:24.840  INFO 6752 --- [nio-8080-exec-1] c.l.l.s.c.controller.TaskController      : ScheduledExecutorService定時任務啟動：Sat Aug 18 22:03:24 CST 2018
2018-08-18 22:03:25.841  INFO 6752 --- [pool-1-thread-1] c.l.l.s.c.controller.TaskController      : ScheduledExecutorService定時任務執行：Sat Aug 18 22:03:25 CST 2018
2018-08-18 22:03:26.842  INFO 6752 --- [pool-1-thread-1] c.l.l.s.c.controller.TaskController      : ScheduledExecutorService定時任務執行：Sat Aug 18 22:03:26 CST 2018
2018-08-18 22:03:27.841  INFO 6752 --- [pool-1-thread-2] c.l.l.s.c.controller.TaskController      : ScheduledExecutorService定時任務執行：Sat Aug 18 22:03:27 CST 2018
2018-08-18 22:03:28.840  INFO 6752 --- [pool-1-thread-1] c.l.l.s.c.controller.TaskController      : ScheduledExecutorService定時任務執行：Sat Aug 18 22:03:28 CST 2018
2018-08-18 22:03:29.840  INFO 6752 --- [pool-1-thread-3] c.l.l.s.c.controller.TaskController      : ScheduledExecutorService定時任務執行：Sat Aug 18 22:03:29 CST 2018

可同時設定多個任務，只需再次設定scheduleAtFixedRate即可。

常用方法說明：

ScheduleAtFixedRate：

public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,long initialDelay,long period,TimeUnit unit);

引數說明：

command：執行執行緒
initialDelay：初始化延時
period：兩次開始執行最小間隔時間
unit：計時單位

ScheduleWithFixedDelay：

public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,long initialDelay,long delay,TimeUnit unit);

引數說明：

command：執行執行緒
initialDelay：初始化延時
delay：前一次執行結束到下一次執行開始的間隔時間（間隔執行延遲時間）
unit：計時單位

其他的方法大家可自行谷歌下。

基於SpingTask實現定時任務

使用SpringTask在SpringBoot是很簡單的，使用@Scheduled註解即可輕鬆搞定。

0.啟動類，加入@EnableScheduling讓註解@Scheduled生效。

@SpringBootApplication
@EnableScheduling
@Slf4j
public class Chapter22Application {

    public static void main(String[] args) {
        SpringApplication.run(Chapter22Application.class, args);
        log.info("Chapter22啟動!");
    }
}

1.編寫一個排程類，系統啟動後自動掃描，自動執行。

@Component
@Slf4j
public class ScheduledTask {

    /**
     * 自動掃描，啟動時間點之後5秒執行一次
     */
    @Scheduled(fixedRate=5000)
    public void getCurrentDate() {
        log.info("Scheduled定時任務執行：" + new Date());
    }
}

2.啟動後，控制檯可就看見每5秒一次輸出了：

2018-08-18 22:23:09.735  INFO 13812 --- [pool-1-thread-1] c.l.l.s.c.controller.ScheduledTask       : Scheduled定時任務執行：Sat Aug 18 22:23:09 CST 2018
2018-08-18 22:23:14.734  INFO 13812 --- [pool-1-thread-1] c.l.l.s.c.controller.ScheduledTask       : Scheduled定時任務執行：Sat Aug 18 22:23:14 CST 2018
2018-08-18 22:23:19.735  INFO 13812 --- [pool-1-thread-1] c.l.l.s.c.controller.ScheduledTask       : Scheduled定時任務執行：Sat Aug 18 22:23:19 CST 2018
2018-08-18 22:23:24.735  INFO 13812 --- [pool-1-thread-1] c.l.l.s.c.controller.ScheduledTask       : Scheduled定時任務執行：Sat Aug 18 22:23:24 CST 2018
2018-08-18 22:23:29.735  INFO 13812 --- [pool-1-thread-1] c.l.l.s.c.controller.ScheduledTask       : Scheduled定時任務執行：Sat Aug 18 22:23:29 CST 2018
......

使用都是簡單的，現在我們來看看註解@Scheduled的引數意思：

fixedRate：定義一個按一定頻率執行的定時任務
fixedDelay：定義一個按一定頻率執行的定時任務，與上面不同的是，改屬性可以配合initialDelay，定義該任務延遲執行時間。
cron：通過表示式來配置任務執行時間

Cron表示式詳解

一個cron表示式有至少6個（也可能7個）有空格分隔的時間元素。

依次順序如下表所示：

欄位	允許值	允許的特殊字元
秒	0~59	, – * /
分	0~59	, – * /
小時	0~23	, – * /
日期	1-31	, – * ? / L W C
月份	1~12或者JAN~DEC	, – * /
星期	1~7或者SUN~SAT	, – * ? / L C #
年（可選）	留空，1970~2099	, – * /

簡單舉例：

0/1 * * * * ?：每秒執行一次
0 0 2 1 * ? ：表示在每月的1日的凌晨2點調整任務
0 0 10,14,16 ? ：每天上午10點，下午2點，4點
0 0 12 * * ? ：每天中午12點觸發
0 15 10 ? * MON-FRI ：週一至週五的上午10:15觸發

自定義執行緒池

從控制檯輸出可以看見，多工使用的是同一個執行緒。可結合上章節的非同步呼叫來實現不同任務使用不同的執行緒進行任務執行。

0.編寫配置類,同時啟用@Async註解：

@Configuration
@EnableAsync
public class Config {
    /**
     * 配置執行緒池
     * @return
     */
    @Bean(name = "scheduledPoolTaskExecutor")
    public ThreadPoolTaskExecutor getAsyncThreadPoolTaskExecutor() {
        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        taskExecutor.setCorePoolSize(20);
        taskExecutor.setMaxPoolSize(200);
        taskExecutor.setQueueCapacity(25);
        taskExecutor.setKeepAliveSeconds(200);
        taskExecutor.setThreadNamePrefix("oKong-Scheduled-");
        // 執行緒池對拒絕任務（無執行緒可用）的處理策略，目前只支援AbortPolicy、CallerRunsPolicy；預設為後者
        taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        //排程器shutdown被呼叫時等待當前被排程的任務完成
        taskExecutor.setWaitForTasksToCompleteOnShutdown(true);
        //等待時長
        taskExecutor.setAwaitTerminationSeconds(60);
        taskExecutor.initialize();
        return taskExecutor;
    }
}

1.排程類上加入@Async。

@Component
@Slf4j
public class ScheduledTask {

    /**
     * 自動掃描，啟動時間點之後5秒執行一次
     */
    @Async("scheduledPoolTaskExecutor")
    @Scheduled(fixedRate=5000)
    public void getCurrentDate() {
        log.info("Scheduled定時任務執行：" + new Date());
    }
}

再次啟動程式，可看見控制檯輸出，任務已經是不同執行緒下執行了：

2018-08-18 22:47:13.313  INFO 14212 --- [ong-Scheduled-1] c.l.l.s.c.controller.ScheduledTask       : Scheduled定時任務執行：Sat Aug 18 22:47:13 CST 2018
2018-08-18 22:47:13.343  INFO 14212 --- [           main] s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat started on port(s): 8080 (http)
2018-08-18 22:47:13.348  INFO 14212 --- [           main] c.l.l.s.chapter22.Chapter22Application   : Started Chapter22Application in 2.057 seconds (JVM running for 2.855)
2018-08-18 22:47:13.348  INFO 14212 --- [           main] c.l.l.s.chapter22.Chapter22Application   : Chapter22啟動!
2018-08-18 22:47:18.308  INFO 14212 --- [ong-Scheduled-2] c.l.l.s.c.controller.ScheduledTask       : Scheduled定時任務執行：Sat Aug 18 22:47:18 CST 2018

動態新增定時任務

使用註解的方式，無法實現動態的修改或者新增新的定時任務的，這個使用就需要使用程式設計的方式進行任務的更新操作了。可直接使用ThreadPoolTaskScheduler或者SchedulingConfigurer介面進行自定義定時任務建立。

ThreadPoolTaskScheduler

ThreadPoolTaskScheduler是SpringTask的核心實現類，該類提供了大量的過載方法進行任務排程。這裡簡單示例下，具體的大家自行搜尋下，用的少不太瞭解呀。

0.建立一個ThreadPoolTaskScheduler類。

@Bean("taskExecutor")
public TaskScheduler taskExecutor() {
    ThreadPoolTaskScheduler executor = new ThreadPoolTaskScheduler();
    executor.setPoolSize(20);
    executor.setThreadNamePrefix("oKong-taskExecutor-");
    executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
    //排程器shutdown被呼叫時等待當前被排程的任務完成
    executor.setWaitForTasksToCompleteOnShutdown(true);
    //等待時長
    executor.setAwaitTerminationSeconds(60);
    return executor;
}

1.編寫一個控制類，動態設定定時任務：

@Autowired
TaskScheduler taskScheduler;

@GetMapping("/poolTask")
public String threadPoolTaskScheduler() {

    taskScheduler.schedule(new Runnable() {
        
        @Override
        public void run() {
            log.info("ThreadPoolTaskScheduler定時任務：" + new Date());
        }
    }, new CronTrigger("0/3 * * * * ?"));//每3秒執行一次
    return "ThreadPoolTaskScheduler!";
}

2.啟動後，訪問介面，即可看見控制檯每3秒輸出一次：

2018-08-18 23:20:39.002  INFO 9120 --- [Kong-Executor-1] c.l.l.s.c.controller.TaskController      : ThreadPoolTaskScheduler定時任務：Sat Aug 18 23:20:39 CST 2018
2018-08-18 23:20:42.000  INFO 9120 --- [Kong-Executor-1] c.l.l.s.c.controller.TaskController      : ThreadPoolTaskScheduler定時任務：Sat Aug 18 23:20:42 CST 2018
2018-08-18 23:20:45.002  INFO 9120 --- [Kong-Executor-2] c.l.l.s.c.controller.TaskController      : ThreadPoolTaskScheduler定時任務：Sat Aug 18 23:20:45 CST 2018
2018-08-18 23:20:48.001  INFO 9120 --- [Kong-Executor-1] c.l.l.s.c.controller.TaskController      : ThreadPoolTaskScheduler定時任務：Sat Aug 18 23:20:48 CST 2018

SchedulingConfigurer

此類十個介面，直接實現其configurerTasks方法即可。

0.編寫配置類：

@Configuration
@Slf4j
public class ScheduleConfig implements SchedulingConfigurer {

    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        taskRegistrar.setTaskScheduler(taskExecutor());
        taskRegistrar.getScheduler().schedule(new Runnable() {
            
            @Override
            public void run() {
                log.info("SchedulingConfigurer定時任務：" + new Date());
            }
        }, new CronTrigger("0/3 * * * * ?"));//每3秒執行一次
    }
    
    @Bean("taskExecutor")
    public TaskScheduler taskExecutor() {
        ThreadPoolTaskScheduler executor = new ThreadPoolTaskScheduler();
        executor.setPoolSize(20);
        executor.setThreadNamePrefix("oKong-Executor-");
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        //排程器shutdown被呼叫時等待當前被排程的任務完成
        executor.setWaitForTasksToCompleteOnShutdown(true);
        //等待時長
        executor.setAwaitTerminationSeconds(60);
        return executor;
    }

}

1.啟動後，控制檯也可以看見每3秒輸出一次：

2018-08-18 23:24:39.001  INFO 868 --- [Kong-Executor-1] c.l.l.s.chapter22.config.ScheduleConfig  : SchedulingConfigurer定時任務：Sat Aug 18 23:24:39 CST 2018
2018-08-18 23:24:42.001  INFO 868 --- [Kong-Executor-1] c.l.l.s.chapter22.config.ScheduleConfig  : SchedulingConfigurer定時任務：Sat Aug 18 23:24:42 CST 2018
2018-08-18 23:24:45.000  INFO 868 --- [Kong-Executor-2] c.l.l.s.chapter22.config.ScheduleConfig  : SchedulingConfigurer定時任務：Sat Aug 18 23:24:45 CST 2018

基於Quartz實現定時排程

由於本章節是基於SpringBoot 1.x版本的，所以沒有基於Quartz的starter配置，這裡直接引入了Quartz相關依賴包來整合。

題外話：原本使用SpringMvc時，一般上都是通過xml檔案，配置其org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean類進行具體執行任務的配置，指定執行的物件和方法。然後通過設定CronTriggerFactoryBean或者SimpleTriggerFactoryBean設定定時器，最後通過org.springframework.scheduling.quartz.SchedulerFactoryBean加入排程的trigger。所以，我們就使用javaConfig方式進行簡單整合下。

0.加入pom依賴

<!-- quartz -->
<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.2.3</version>
</dependency>
<!-- spring整合quartz -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context-support</artifactId>
</dependency>
<!-- 因為SchedulerFactoryBean中依賴了org.springframework.transaction.PlatformTransactionManager,所以需依賴tx相關包，其實還是quartz有個分散式功能，是使用資料庫完成的。 -->
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
</dependency>

1.編寫配置類。

@Configuration
@Slf4j
public class QuartzConfig {
    
    /**
     * 通過工廠類，建立job例項
     * @return
     */
    @Bean
    public MethodInvokingJobDetailFactoryBean customJobDetailFactoryBean() {
        
        MethodInvokingJobDetailFactoryBean jobDetail = new MethodInvokingJobDetailFactoryBean();
        //設定執行任務的bean
        jobDetail.setTargetBeanName("quartzTask");
        //設定具體執行的方法
        jobDetail.setTargetMethod("quartzTask");
        //同步執行，上一任務未執行完，下一任務等待
        //true 任務併發執行
        //false 下一個任務必須等待上一任務完成
        jobDetail.setConcurrent(false);
        return jobDetail; 
    }
    
    /**
     * 通過工廠類建立Trigger
     * @param jobDetailFactoryBean
     * @return
     * @throws ParseException 
     */
    @Bean(name = "cronTriggerBean")
    public Trigger cronTriggerBean(MethodInvokingJobDetailFactoryBean jobDetailFactoryBean) throws ParseException {
        CronTriggerFactoryBean cronTriggerFactoryBean = new CronTriggerFactoryBean();
        cronTriggerFactoryBean.setJobDetail(jobDetailFactoryBean.getObject());
        cronTriggerFactoryBean.setCronExpression("0/3 * * * * ?");//每3秒執行一次
        cronTriggerFactoryBean.setName("customCronTrigger");
        cronTriggerFactoryBean.afterPropertiesSet();
        return cronTriggerFactoryBean.getObject();

    }
    
    /**
     * 排程工廠類,自動注入Trigger
     * @return
     */
    @Bean
    public SchedulerFactoryBean schedulerFactoryBean(Trigger... triggers) {
        SchedulerFactoryBean bean = new SchedulerFactoryBean();
        
        //也可以直接注入 ApplicationContext,利於 getBeansOfType獲取trigger
//        Map<String,Trigger> triggerMap = appContext.getBeansOfType(Trigger.class);
//        if(triggerMap != null) {
//            List<Trigger> triggers = new ArrayList<>(triggerMap.size());
//            //
//            triggerMap.forEach((key,trigger)->{
//                triggers.add(trigger);
//            });
//            bean.setTriggers(triggers.toArray(new Trigger[triggers.size()]));
//        }
        //這裡注意 對應的trigger 不能為null 不然會異常的
        bean.setTriggers(triggers);
        return bean;
    } 
    
    @Component("quartzTask")
    public class QuartzTask {
      
        public void quartzTask() {
            log.info("Quartz定時任務：" + new Date());
        }
    }
}

2.啟動後，可以看見控制檯以每3秒執行一次輸出：

2018-08-18 23:42:03.019  INFO 772 --- [ryBean_Worker-2] c.l.l.s.chapter22.config.QuartzConfig    : Quartz定時任務：Sun Aug 18 23:42:03 CST 2018
2018-08-18 23:42:06.002  INFO 772 --- [ryBean_Worker-3] c.l.l.s.chapter22.config.QuartzConfig    : Quartz定時任務：Sun Aug 18 23:42:06 CST 2018
2018-08-18 23:42:09.002  INFO 772 --- [ryBean_Worker-4] c.l.l.s.chapter22.config.QuartzConfig    : Quartz定時任務：Sun Aug 18 23:42:09 CST 2018

關於Quartz的詳細用法，再次不表了。好久沒有使用過了。有機會再來詳細闡述吧。

分散式排程服務淺談

在單機模式下，定時任務是沒什麼問題的。但當我們部署了多臺服務，同時又每臺服務又有定時任務時，若不進行合理的控制在同一時間，只有一個定時任務啟動執行，這時，定時執行的結果就可能存在混亂和錯誤了。

這裡簡單的說說相關的解決方案吧，一家之言，希望大家能提出自己的見解，共同進步！

剝離所有定時任務到一個工程：此方案是最簡單的，在定時任務相對較小，併發任務不多時，可以使用此方案。簡單也容易維護。當定時任務牽扯的業務越來越多，越來越雜時，維護量就成本增加了，工程會越來越臃腫，此方案就不實用了。
利用Quartz叢集方案：本身Quartz是支援通過資料庫實現叢集的，以下是其叢集架構圖：

叢集架構圖

其實現原理也相對簡單：通過資料庫實現任務的持久化，儲存定時任務的相關配置資訊，以保證下次系統啟動時，定時任務能自動啟動。同時，通過資料庫行鎖(for update)機制，控制一個任務只能被一個例項執行，只有獲取鎖的例項才能執行任務，其他的只能等待，直到鎖被釋放。這種方式有些弊端，就是依賴了資料庫，同時也需要保證各伺服器之間的時間需要同步，不然也是會混亂的。

現在Quartz也有基於Redis的叢集方案，有興趣的可以搜尋下。

分散式鎖：可通過使用Redis或者ZooKeeper實現一個分散式鎖的機制，使得只有獲取到鎖的例項方能執行定時任務，避免任務重複執行。可檢視下開源的基於Redis實現的分散式鎖專案：redisson。github地址：https://github.com/redisson/redisson有興趣的同學可以瞭解下。
統一排程中心：

可構建一個純粹的定時服務，只有定時器相關配置，比如定時時間，定時排程的api介面或者http服務，甚至是統一註冊中心下的服務類，如dubbo服務等。而具體的任務執行操作都在各自業務方系統中，排程中心只負責介面的呼叫，具體實現還是在業務方。這種方案相對來說比較通用，實現起來也簡單。就是需要業務方進行約定程式設計，或者對外提供一個api介面。

當然，為了實現定時任務的自動發現和註冊功能，還是需要規範一套規則來實現自動註冊功能。簡單來說，以Dubbo服務為例，可以定義一個定時任務介面類，排程中心只需要獲取所有實現此介面的服務，同時通過服務的相關配置(排程時間、失敗策略等)進行相關定時操作。或者編寫一個服務註冊與發現的客戶端，通過Spring獲取到實現此介面的所有實現類，上送到排程中心。

而且，統一排程中心，還可以對所有的定時任務的排程情況進行有效監控，日誌記錄等，也可以約定介面，讓定時任務回傳定時結果，做到全域性把控的目的。

以上就是對分散式排程的一點理解，有錯誤的地方還望指正，有更好的方案也希望能分享下。

參考資料

總結

本章節主要是講解了通過不同的方式實現定時任務。對於定時任務而言，本身是門大學問，一倆篇文章是講不完的。像SpringTask和Quartz都是很強大的排程器，兩者很相似，像如何實現任務的動態修改排程週期，動態停止相關任務，排程任務的監控，這些本文章都沒有涉及。還希望有相關需求的同學自行搜尋相關資料了。

最後

目前網際網路上很多大佬都有SpringBoot系列教程，如有雷同，請多多包涵了。本文是作者在電腦前一字一句敲的，每一步都是自己實踐的。若文中有所錯誤之處，還望提出，謝謝。

SpringBoot | 第二十二章：定時任務的使用

前言

一點知識

基於JDK方式實現簡單定時

Timer

ScheduledExecutorService

基於SpingTask實現定時任務

Cron表示式詳解

自定義執行緒池

動態新增定時任務

ThreadPoolTaskScheduler

SchedulingConfigurer

基於Quartz實現定時排程

分散式排程服務淺談

參考資料

總結

最後

SpringBoot | 第二十二章：定時任務的使用

第二十二章：JQuery

“全棧2019”Java第二十二章：控制流程語句中的決策語句if-else

SpringBoot | 第二十八章：監控管理之Spring Boot Admin使用

SpringBoot | 第二十一章：非同步開發之非同步呼叫

SpringBoot | 第十二章：給大家推薦8個SpringBoot精選專案

SpringBoot | 第二十九章：Dubbo的整合和使用

卜若的程式碼筆記系列-Web系列-SpringBoot-第十二章：Swagger的批註詳解-3212

演算法導論第二十二章：拓撲排序

Flask 教程第二十二章：後臺作業

Introduction to 3D Game Programming with DirectX 12 學習筆記之 --- 第二十二章：四元數（QUATERNIONS）

SpringBoot第十七篇：定時任務

SpringBoot第二十二篇：應用監控之Actuator

第二十二章 Linux文件比較，文本文件的交集、差集與求差：comm命令

SpringBoot | 第三十二章：事件的釋出和監聽

第二十七章：SpringBoot使用ApplicationEvent&Listener完成業務解耦

第二十五章：SpringBoot新增支援CORS跨域訪問

第十二章：查找與處理文件

第十二章：類的無參方法

python學習第二十二章

SpringBoot | 第二十二章：定時任務的使用

前言

一點知識

基於JDK方式實現簡單定時

Timer

ScheduledExecutorService

基於SpingTask實現定時任務

Cron表示式詳解

自定義執行緒池

動態新增定時任務

ThreadPoolTaskScheduler

SchedulingConfigurer

基於Quartz實現定時排程

分散式排程服務淺談

參考資料

總結

最後

相關推薦