大家都用過鬧鐘，鬧鐘可以說是一種定時任務。比如我們設定了周一到周五早上7點半的時間響鈴，那麼鬧鐘就會在周一到周五的早上7點半進行響鈴，這種就是定時的任務。 ...
前言
學過定時任務，但是我忘了，忘得一干二凈，害怕，一直聽別人說：
你寫一個定時任務就好了。
寫個定時任務讓他去爬取就行了。
我不會，所以現在得補回來了，欠下的終究要還的，/(ㄒoㄒ)/~~
定時任務是什麼？
大家都用過鬧鐘，鬧鐘可以說是一種定時任務。
比如我們設定了周一到周五早上7點半的時間響鈴，那麼鬧鐘就會在周一到周五的早上7點半進行響鈴，這種就是定時的任務。時間定在 周一到周五的早上7點半 ，任務就是 響鈴。
那麼，在 Java 中，如何實現這樣的功能呢？即如何實現定時任務呢？
定時任務的有哪些是實現方式？
說明：@Slf4j 註解來源於 Lombok ，需要引入 Lombok 依賴
純手寫單線程迴圈
單線程，寫一個死迴圈，通過線程的睡眠（等待）完成定時任務：
@Slf4j
public class ThreadTaskDemo {
public static void main(String[] args) {
timer1();
}
public static void timer1() {
new Thread(() -> {
while (true) {
log.info("當前時間 {}", LocalDateTime.now());
try {
// 每個1秒執行一次
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
}
控制台輸出：
14:02:35.893 [Thread-0] INFO cn.god23bin.demo.timer.ThreadTaskDemo - 當前時間 2022-10-25T14:02:35.892
14:02:36.904 [Thread-0] INFO cn.god23bin.demo.timer.ThreadTaskDemo - 當前時間 2022-10-25T14:02:36.904
14:02:37.907 [Thread-0] INFO cn.god23bin.demo.timer.ThreadTaskDemo - 當前時間 2022-10-25T14:02:37.907
可以看到每秒執行一次，成功實現了定時任務。
Timer 和它的小伙伴
在 java.util 包下，有這麼 3 個東西，分別是 Timer 類、TimerTask 介面、TimerThread 類，這 3 個東西就可以幫我們實現定時任務。
Timer 有這麼 2 個方法（當然不止這兩個，還有 4 個相關的）：
// 延遲delay秒後執行task任務
public void schedule(TimerTask task, long delay);
// 延遲delay秒後，以period間隔時間執行task任務
public void schedule(TimerTask task, long delay, long period);
TimerTask 有個 run() 抽象方法，那我們可以實現這個抽象方法作為我們的任務邏輯，由於 TimerTask 是介面，需要一個類實現它，那我們下麵就用匿名內部類的方式來實現這個介面。代碼如下：
@Slf4j
public class TimerDemo {
public static void main(String[] args) {
timer1();
}
public static void timer1() {
// 單線程
Timer timer = new Timer();
log.info("1秒後執行任務A，A完成後，等待1秒開始定時執行任務B，當前時間 {}", LocalDateTime.now());
// 1秒後執行
timer.schedule(new TimerTask() {
@Override
public void run() {
log.info("任務A 當前時間 {}", LocalDateTime.now());
}
}, 1000); // 這裡 1000，就是代表延遲 1000 毫秒後再執行
// 每隔2秒執行一次這個任務
timer.schedule(new TimerTask() {
@Override
public void run() {
log.info("定時任務B 當前時間 {}", LocalDateTime.now());
}
}, 1000, 2000); // 1000 同理，2000 即執行完本次任務後，隔 2000 毫秒後再一次執行，達到定時任務的效果
}
}
控制台輸出：
14:09:37.416 [main] INFO cn.god23bin.demo.timer.TimerDemo - 1秒後執行任務A，A完成後，等待1秒開始定時執行任務B，當前時間 2022-10-25T14:09:37.415
14:09:38.428 [Timer-0] INFO cn.god23bin.demo.timer.TimerDemo - 任務A 當前時間 2022-10-25T14:09:38.428
14:09:38.428 [Timer-0] INFO cn.god23bin.demo.timer.TimerDemo - 定時任務B 當前時間 2022-10-25T14:09:38.428
14:09:40.443 [Timer-0] INFO cn.god23bin.demo.timer.TimerDemo - 定時任務B 當前時間 2022-10-25T14:09:40.443
14:09:42.457 [Timer-0] INFO cn.god23bin.demo.timer.TimerDemo - 定時任務B 當前時間 2022-10-25T14:09:42.457
從控制台輸出的時間可以看到，任務 A 是只執行了一次，因為我們沒有傳遞 period 參數給 schedule () 方法。而任務 B 是一個定時任務，因為傳遞了 period 參數，period 參數為 2000，即 2000 毫秒。
所以，任務 B 會每隔 2 秒執行一次。到這裡，我們通過 Timer 實現了定時任務。下麵看看基於多線程的 ScheduledExecutorService 介面。
ScheduledExecutorService
ScheduledExecutorService 介面位於 java.util.concurrent 包中，是繼承 ExecutorService 介面的。
這個介面有 4 個抽象方法（先瞭解一下）：
public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit);
public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit);
public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit);
public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit);
從上面的抽象方法可以看到，第一個參數是 Runnable 介面或 Callable 介面，這裡就是寫任務邏輯的，後面的 delay 也和之前的意思一樣，延遲多少時間才開始執行這個定時任務，unit 主要是指定 long 參數的時間單位。period 也是一樣的意思，間隔多少秒（周期）才執行下一次的任務。
ExecutorService 介面表述了非同步執行的機制，並且可以讓任務在後臺執行。ExecutorService 介面的實現類有我們知道的
ThreadPoolExecutor（不知道的話，現在就知道啦）。
基本使用
那我們如何獲取 ScheduledExecutorService 的實現類？如何使用它實現定時任務？
可以通過 Executors.newSingleThreadScheduledExecutor() 獲取其實現類，然後調用 schedule() 方法實現定時任務。
現在先看一下，如何使用：
@Slf4j
public class ScheduledExecutorServiceDemo {
public static void main(String[] args) throws ExecutionException, InterruptedException {
testScheduledExecutorService();
}
public static void testScheduledExecutorService() throws ExecutionException, InterruptedException {
ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
log.info("2秒後開始執行任務，此刻時間---{}", LocalDateTime.now());
ScheduledFuture<?> future = scheduledExecutorService.schedule(() -> {
log.info("任務開始---{}", LocalDateTime.now());
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
log.info("任務結束---{}", LocalDateTime.now());
return "ok";
}, 2000, TimeUnit.MILLISECONDS); // 延遲 2 秒後執行
log.info("任務執行後 future {}, 時間 {}", future.get(), LocalDateTime.now());
}
}
控制台輸出：
14:15:44.510 [main] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 2秒後開始執行任務，此刻時間---2022-10-25T14:15:44.509
14:15:46.524 [pool-1-thread-1] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 任務開始---2022-10-25T14:15:46.524
14:15:48.537 [pool-1-thread-1] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 任務結束---2022-10-25T14:15:48.537
14:15:48.538 [main] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 任務執行後 future ok, 時間 2022-10-25T14:15:48.538
很明顯，這裡不是一個定時任務，因為只執行了一次就結束了，所以我們需要調用兩外兩個來實現，分別是 scheduleAtFixedRate() 方法和 scheduleWithFixedDelay() 方法。
固定頻率觸發定時任務
scheduleAtFixedRate() 方法，可以固定多久就觸發一次任務。下麵我們寫一個延遲 2 秒後開始執行任務，經過 5 秒後再執行下一次的任務的代碼：
@Slf4j
public class ScheduledExecutorServiceDemo {
public static void main(String[] args) throws ExecutionException, InterruptedException {
testFixedRate();
}
public static void testFixedRate() {
ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
log.info("2秒後開始執行任務，此刻時間---{}", LocalDateTime.now());
// 固定頻率（每隔5秒）開始執行一個任務
scheduledExecutorService.scheduleAtFixedRate(() -> {
log.info("任務開始---{}", LocalDateTime.now());
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
log.info("任務結束---{}", LocalDateTime.now());
}, 2000, 5000, TimeUnit.MILLISECONDS);
}
}
通過 Thread.sleep(2000) 模擬任務執行了 2 秒的時間，控制台輸出如下：
14:17:15.081 [main] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 2秒後開始執行任務，此刻時間---2022-10-25T14:17:15.079
14:17:17.094 [pool-1-thread-1] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 任務開始---2022-10-25T14:17:17.094
14:17:19.109 [pool-1-thread-1] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 任務結束---2022-10-25T14:17:19.109
14:17:22.094 [pool-1-thread-1] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 任務開始---2022-10-25T14:17:22.094
14:17:24.106 [pool-1-thread-1] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 任務結束---2022-10-25T14:17:24.106
14:17:27.090 [pool-1-thread-1] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 任務開始---2022-10-25T14:17:27.090
14:17:29.099 [pool-1-thread-1] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 任務結束---2022-10-25T14:17:29.099
可以看到，第一次執行的時間是 14:17:17 ，即第 17 秒，下一次執行的時間是 14:17:22 ，即第 22 秒，這個過程經過了 5 秒鐘，這就是 scheduleAtFixedRate() 方法的效果。
固定延遲觸發定時任務
scheduleWithFixedDelay() 方法，可以固定任務完成後延遲多久才執行下一次任務。下麵我們寫一個延遲 1 秒後開始執行定時任務，當任務完成後，延遲 4 秒再執行下一次任務。代碼如下：
@Slf4j
public class ScheduledExecutorServiceDemo {
public static void main(String[] args) throws ExecutionException, InterruptedException {
testFixedDelay();
}
public static void testFixedDelay() {
ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
log.info("1秒後開始執行任務，此刻時間---{}", LocalDateTime.now());
// 任務完成後間隔4秒開始執行下一次任務
scheduledExecutorService.scheduleWithFixedDelay(() -> {
log.info("任務開始---{}", LocalDateTime.now());
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
log.info("任務結束---{}", LocalDateTime.now());
}, 1000, 4000, TimeUnit.MILLISECONDS);
}
}
通過 Thread.sleep(2000) 模擬任務執行了 2 秒的時間，控制台輸出如下：
14:20:31.352 [main] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 1秒後開始執行任務，此刻時間---2022-10-25T14:20:31.351
14:20:32.370 [pool-1-thread-1] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 任務開始---2022-10-25T14:20:32.370
14:20:34.371 [pool-1-thread-1] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 任務結束---2022-10-25T14:20:34.371
14:20:38.379 [pool-1-thread-1] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 任務開始---2022-10-25T14:20:38.379
14:20:40.381 [pool-1-thread-1] INFO cn.god23bin.demo.timer.ScheduledExecutorServiceDemo - 任務結束---2022-10-25T14:20:40.381
可以看到，第一次任務結束的時間是 14:20:34 ，即第 34 秒，下一次執行的時間是 14:17:38 ，即第 38 秒，這個過程經過了 4 秒鐘，這就是 scheduleWithFixedDelay() 方法的效果。
以上就是 ScheduledExecutorService 實現的定時任務，接下來看看 Spring 提供的。
Spring 提供的定時任務
Spring 提供了 @EnableScheduling 和 @Scheduled 這兩個註解來實現定時任務。
我們可以編寫一個類，加上 @Component 讓 Spring 來管理這個 Bean（當然，也可以用 @Configuration 註解），加上 @EnableScheduling 表明該 Bean 具有可開啟定時任務的功能。
在這個普通的類中編寫方法，你可以讓你寫的方法成為一個定時任務，只需在方法上加上 @Scheduled 註解就可以了，就是這麼簡單！
還有一個就是 cron 表達式 需要學習，這個表達式可以表明這個方法何時執行。
下麵是一個簡單的定時任務：
@Slf4j
@Component
@EnableScheduling
public class TaskDemo {
@Scheduled(cron = "*/1 * * * * ?")
public void printTime() throws InterruptedException {
log.info("此刻時間 {}", LocalDateTime.now());
}
}
cron 表達式有 6 位，是必須的，從左到右分別表示：秒、分、時、日、月、周。
當然也有可能是 7 位，那麼最後一位就是年（一般省略不寫）：秒、分、時、日、月、周、年。
取值說明：正常認識，秒分都是 0 - 59，時則是 0 - 23，日則是 1 - 31，月則是 1-12，周則是 1 - 7。年則只有 1970 - 2099
每一位都可以用數字表示，當然還可以用一些特殊字元表示，比如上面出現的 */1 * * * * ? ，第 1 位的 */1 表示任意秒每隔1秒，第 2 位的 * 表示任意分鐘，以此類推。
詳細可參考這裡：簡書-Cron表達式的詳細用法
Cron 生成工具：https://cron.qqe2.com/
上面的代碼運行之後，控制台輸出：
2022-10-25 14:26:22.013 INFO 18304 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 此刻時間 2022-10-25T14:26:22.013
2022-10-25 14:26:23.010 INFO 18304 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 此刻時間 2022-10-25T14:26:23.010
2022-10-25 14:26:24.011 INFO 18304 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 此刻時間 2022-10-25T14:26:24.011
2022-10-25 14:26:25.011 INFO 18304 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 此刻時間 2022-10-25T14:26:25.011
可以看到，確實是每隔 1 秒執行一次 printTime() 這個定時任務。
@Scheduled 的另外兩個屬性
@Scheduled 註解除了 cron 這個屬性外，還有 fixedRate 屬性和 fixedDelay 屬性，同理，就是固定頻率觸發定時任務和固定延遲觸發定時任務
fixedRate
@Slf4j
@Component
@EnableScheduling
public class TaskDemo {
/**
* 當前任務執行到下一個任務開始的時間（固定頻率開始執行一個任務，每5秒執行），都是單線程處理的
**/
@Scheduled(fixedRate = 5000)
public void printTime1() throws InterruptedException {
log.info("任務開始------- {}", LocalDateTime.now());
Thread.sleep(1000);
log.info("任務完成------- {}", LocalDateTime.now());
}
}
控制台輸出：
2022-10-25 14:54:04.824 INFO 23520 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 任務開始------- 2022-10-25T14:54:04.824
2022-10-25 14:54:05.833 INFO 23520 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 任務完成------- 2022-10-25T14:54:05.833
2022-10-25 14:54:09.834 INFO 23520 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 任務開始------- 2022-10-25T14:54:09.834
2022-10-25 14:54:10.843 INFO 23520 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 任務完成------- 2022-10-25T14:54:10.843
當然，如果任務的處理邏輯超過了固定的頻率時間，比如我們修改下 Thread.sleep(1000) ，模擬成 6 秒，即 Thread.sleep(6000)，那麼輸出如下：
2022-10-25 14:57:04.212 INFO 9324 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 任務開始------- 2022-10-25T14:57:04.212
2022-10-25 14:57:10.227 INFO 9324 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 任務完成------- 2022-10-25T14:57:10.227
2022-10-25 14:57:10.227 INFO 9324 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 任務開始------- 2022-10-25T14:57:10.227
2022-10-25 14:57:16.241 INFO 9324 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 任務完成------- 2022-10-25T14:57:16.241
2022-10-25 14:57:16.242 INFO 9324 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 任務開始------- 2022-10-25T14:57:16.242
2022-10-25 14:57:22.243 INFO 9324 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 任務完成------- 2022-10-25T14:57:22.243
2022-10-25 14:57:22.243 INFO 9324 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 任務開始------- 2022-10-25T14:57:22.243
可以發現，當前任務一完成就會立刻執行下一次任務，這就是當任務的處理邏輯超過了固定的頻率時間會出現的情況。
fixedDelay
@Slf4j
@Component
@EnableScheduling
public class TaskDemo {
/**
* 執行完成後間隔2秒執行下一次
**/
@Scheduled(fixedDelay = 2000)
public void printTime2() throws InterruptedException {
log.info("任務開始------- {}", LocalDateTime.now());
Thread.sleep(4000);
log.info("任務完成------- {}", LocalDateTime.now());
}
}
控制台輸出：
2022-10-25 14:55:50.973 INFO 22128 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 任務開始------- 2022-10-25T14:55:50.973
2022-10-25 14:55:54.977 INFO 22128 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 任務完成------- 2022-10-25T14:55:54.977
2022-10-25 14:55:56.987 INFO 22128 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 任務開始------- 2022-10-25T14:55:56.987
2022-10-25 14:56:01.001 INFO 22128 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 任務完成------- 2022-10-25T14:56:01.001
2022-10-25 14:56:03.012 INFO 22128 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 任務開始------- 2022-10-25T14:56:03.012
多個定時任務的執行
同步
如果我們寫多個定時任務，那麼它們只會同步執行，如下：
@Slf4j
@Component
@EnableScheduling
public class TaskDemo {
@Scheduled(fixedRate = 2000)
public void printTime3() throws InterruptedException {
log.info("任務A開始------- {}", LocalDateTime.now());
Thread.sleep(2000);
log.info("任務A完成------- {}", LocalDateTime.now());
}
@Scheduled(fixedDelay = 2000)
public void printTime4() throws InterruptedException {
log.info("任務B開始------- {}", LocalDateTime.now());
Thread.sleep(2000);
log.info("任務B完成------- {}", LocalDateTime.now());
}
}
控制台輸出：
2022-10-25 14:59:14.279 INFO 21588 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 任務A開始------- 2022-10-25T14:59:14.279
2022-10-25 14:59:16.283 INFO 21588 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 任務A完成------- 2022-10-25T14:59:16.283
2022-10-25 14:59:16.283 INFO 21588 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 任務B開始------- 2022-10-25T14:59:16.283
2022-10-25 14:59:18.288 INFO 21588 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 任務B完成------- 2022-10-25T14:59:18.288
2022-10-25 14:59:18.288 INFO 21588 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 任務A開始------- 2022-10-25T14:59:18.288
2022-10-25 14:59:20.301 INFO 21588 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 任務A完成------- 2022-10-25T14:59:20.301
2022-10-25 14:59:20.301 INFO 21588 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 任務A開始------- 2022-10-25T14:59:20.301
2022-10-25 14:59:22.307 INFO 21588 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 任務A完成------- 2022-10-25T14:59:22.307
2022-10-25 14:59:22.307 INFO 21588 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 任務A開始------- 2022-10-25T14:59:22.307
2022-10-25 14:59:24.323 INFO 21588 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 任務A完成------- 2022-10-25T14:59:24.323
2022-10-25 14:59:24.323 INFO 21588 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 任務B開始------- 2022-10-25T14:59:24.323
2022-10-25 14:59:26.337 INFO 21588 --- [ scheduling-1] cn.god23bin.demo.task.TaskDemo : 任務B完成------- 2022-10-25T14:59:26.337
可以看到，只有某一個任務完成後，下一個任務才會執行。
如果想要非同步，如何非同步呢？
非同步
很簡單，使用 @EnableAsync 和 @Async 這兩個註解就可以了，如下：
@Slf4j
@Component
@EnableScheduling
@EnableAsync
public class TaskDemo {
@Async
@Scheduled(fixedRate = 2000)
public void printTime3() throws InterruptedException {
log.info("任務A開始------- {}", LocalDateTime.now());
Thread.sleep(2000);
log.info("任務A完成------- {}", LocalDateTime.now());
}
@Async
@Scheduled(fixedDelay = 2000)
public void printTime4() throws InterruptedException {
log.info("任務B開始------- {}", LocalDateTime.now());
Thread.sleep(2000);
log.info("任務B完成------- {}", LocalDateTime.now());
}
}
控制台輸出：
2022-10-25 15:04:05.833 INFO 15604 --- [ task-1] cn.god23bin.demo.task.TaskDemo : 任務A開始------- 2022-10-25T15:04:05.833
2022-10-25 15:04:05.833 INFO 15604 --- [ task-2] cn.god23bin.demo.task.TaskDemo : 任務B開始------- 2022-10-25T15:04:05.833
2022-10-25 15:04:07.833 INFO 15604 --- [ task-4] cn.god23bin.demo.task.TaskDemo : 任務B開始------- 2022-10-25T15:04:07.833
2022-10-25 15:04:07.833 INFO 15604 --- [ task-3] cn.god23bin.demo.task.TaskDemo : 任務A開始------- 2022-10-25T15:04:07.833
2022-10-25 15:04:07.848 INFO 15604 --- [ task-2] cn.god23bin.demo.task.TaskDemo : 任務B完成------- 2022-10-25T15:04:07.848
2022-10-25 15:04:07.848 INFO 15604 --- [ task-1] cn.god23bin.demo.task.TaskDemo : 任務A完成------- 2022-10-25T15:04:07.848
2022-10-25 15:04:09.833 INFO 15604 --- [ task-5] cn.god23bin.demo.task.TaskDemo : 任務A開始------- 2022-10-25T15:04:09.833
2022-10-25 15:04:09.843 INFO 15604 --- [ task-4] cn.god23bin.demo.task.TaskDemo : 任務B完成------- 2022-10-25T15:04:09.843
2022-10-25 15:04:09.843 INFO 15604 --- [ task-3] cn.god23bin.demo.task.TaskDemo : 任務A完成------- 2022-10-25T15:04:09.843
2022-10-25 15:04:09.844 INFO 15604 --- [ task-6] cn.god23bin.demo.task.TaskDemo : 任務B開始------- 2022-10-25T15:04:09.843
2022-10-25 15:04:11.830 INFO 15604 --- [ task-7] cn.god23bin.demo.task.TaskDemo : 任務A開始------- 2022-10-25T15:04:11.830
2022-10-25 15:04:11.845 INFO 15604 --- [ task-6] cn.god23bin.demo.task.TaskDemo : 任務B完成------- 2022-10-25T15:04:11.845
2022-10-25 15:04:11.845 INFO 15604 --- [ task-5] cn.god23bin.demo.task.TaskDemo : 任務A完成------- 2022-10-25T15:04:11.845
總結
首先講了下定時任務是什麼？接著講了有哪些實現方式？對這些方式進行介紹。
主要的定時任務可以通過以下的方式實現：
- 純手寫單線程死迴圈，配合線程的等待機制的方式（不推薦，麻煩，問題多多）
- 使用 JDK 提供的 Timer 配合 TimerTask 的方式（不推薦，單線程）
- 使用 JDK 提供的多線程的 ScheduledExecutorService 的方式（可代替 Timer，多線程的）
- 使用 Spring 提供的定時任務的方式（推薦，更加方便，可非同步）
當然，除了這些方式，還可以使用定時任務框架，比如 Quartz、XXL-JOB、Elastic-Job 等等。
最後的最後
由本人水平所限，難免有錯誤以及不足之處， 屏幕前的靚仔靚女們 如有發現，懇請指出！
最後，謝謝你看到這裡，謝謝你認真對待我的努力，希望這篇博客對你有所幫助！
你輕輕地點了個贊，那將在我的心裡世界增添一顆明亮而耀眼的星！
