天天看點
傳回

我終于會寫 Java 的定時任務了

我終于會寫 Java 的定時任務了

前言

學過定時任務，但是我忘了，忘得一幹二淨，害怕，一直聽别人說：

你寫一個定時任務就好了。

寫個定時任務讓他去爬取就行了。

我不會，是以現在得補回來了，欠下的終究要還的，/(ㄒ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 生成工具：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
複制代碼

總結

首先講了下定時任務是什麼？接着講了有哪些實作方式？對這些方式進行介紹。

主要的定時任務可以通過以下的方式實作：

  1. 純手寫單線程死循環，配合線程的等待機制的方式（不推薦，麻煩，問題多多）
  2. 使用 JDK 提供的 Timer 配合 TimerTask 的方式（不推薦，單線程）
  3. 使用 JDK 提供的多線程的 ScheduledExecutorService 的方式（可代替 Timer，多線程的）
  4. 使用 Spring 提供的定時任務的方式（推薦，更加友善，可異步）

當然，除了這些方式，還可以使用定時任務架構，比如 Quartz、XXL-JOB、Elastic-Job 等等。

最後的最後

由本人水準所限，難免有錯誤以及不足之處， 螢幕前的靓仔靓女們 如有發現，懇請指出！

最後，謝謝你看到這裡，謝謝你認真對待我的努力，希望這篇部落格對你有所幫助！

你輕輕地點了個贊，那将在我的心裡世界增添一顆明亮而耀眼的星！

定時任務
上一篇: AI技術大發展的今天，為什麼道路病害識别無法真正實作智能化？
下一篇: 顔甯回國登上熱搜，看了一段她早期的采訪視訊，講述美國普林斯頓大學與清華大學行政管理差別，稱贊普林斯頓非常高效。她舉了一個

繼續閱讀