主頁 > 後端開發 > 我終于會寫 Java 的定時任務了！

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

2022-10-26 08:07:52 後端開發

前言

學過定時任務，但是我忘了，忘得一干二凈，害怕，一直聽別人說：

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

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

我不會，所以現在得補回來了，欠下的終究要還的，/(ㄒ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

總結

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

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

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

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

最后的最后

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

最后，謝謝你看到這里，謝謝你認真對待我的努力，希望這篇博客對你有所幫助！

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

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/519264.html

標籤：其他

上一篇：BigDecimal精度詳解

下一篇：從改一個老專案開始的PHP踩坑記

標籤雲
其他(157675) Python(38076) JavaScript(25376) Java(17977) C(15215) 區塊鏈(8255) C＃(7972) AI(7469) 爪哇(7425) MySQL(7132) html(6777) 基礎類(6313) sql(6102) 熊猫(6058) PHP(5869) 数组(5741) R(5409) Linux(5327) 反应(5209) 腳本語言(PerlPython)(5129) 非技術區(4971) Android(4554) 数据框(4311) css(4259) 节点.js(4032) C語言(3288) json(3245) 列表(3129) 扑(3119) C++語言(3117) 安卓(2998) 打字稿(2995) VBA(2789) Java相關(2746) 疑難問題(2699) 细绳(2522) 單片機工控(2479) iOS(2429) ASP.NET(2402) MongoDB(2323) 麻木的(2285) 正则表达式(2254) 字典(2211) 循环(2198) 迅速(2185) 擅长(2169) 镖(2155) 功能(1967) .NET技术(1958) Web開發(1951) python-3.x(1918) HtmlCss(1915) 弹簧靴(1913) C++(1909) xml(1889) PostgreSQL(1872) .NETCore(1853) 谷歌表格(1846) Unity3D(1843) for循环(1842)

熱門瀏覽
  • 【C++】Microsoft C++、C 和匯編程式檔案

    ......

    uj5u.com 2020-09-10 00:57:23 more
  • 例外宣告

    相比于斷言適用于排除邏輯上不可能存在的狀態，例外通常是用于邏輯上可能發生的錯誤。 例外宣告 Item 1：當函式不可能拋出例外或不能接受拋出例外時，使用noexcept 理由 如果不打算拋出例外的話，程式就會認為無法處理這種錯誤，并且應當盡早終止，如此可以有效地阻止例外的傳播與擴散。 示例 //不可 ......

    uj5u.com 2020-09-10 00:57:27 more
  • Codeforces 1400E Clear the Multiset(貪心 + 分治)

    鏈接：https://codeforces.com/problemset/problem/1400/E 來源：Codeforces 思路：給你一個陣列，現在你可以進行兩種操作，操作1：將一段沒有 0 的區間進行減一的操作，操作2：將 i 位置上的元素歸零。最終問：將這個陣列的全部元素歸零后操作的最少 ......

    uj5u.com 2020-09-10 00:57:30 more
  • UVA11610 【Reverse Prime】

    本人看到此題沒有翻譯，就附帶了一個自己的翻譯版本 思考 這一題，它的第一個要求是找出所有 $7$ 位反向質數及其質因數的個數。 我們應該需要質數篩篩選1~$10^{7}$的所有數，這里就不慢慢介紹了。但是，重讀題，我們突然發現反向質數都是 $7$ 位，而將它反過來后的數字卻是 $6$ 位數，這就說明 ......

    uj5u.com 2020-09-10 00:57:36 more
  • 統計區間素數數量

    1 #pragma GCC optimize(2) 2 #include <bits/stdc++.h> 3 using namespace std; 4 bool isprime[1000000010]; 5 vector<int> prime; 6 inline int getlist(int ......

    uj5u.com 2020-09-10 00:57:47 more
  • C/C++編程筆記：C++中的 const 變數詳解，教你正確認識const用法

    1、C中的const 1、區域const變數存放在堆疊區中，會分配記憶體（也就是說可以通過地址間接修改變數的值）。測驗代碼如下： 運行結果： 2、全域const變數存放在只讀資料段（不能通過地址修改，會發生寫入錯誤）， 默認為外部聯編，可以給其他源檔案使用（需要用extern關鍵字修飾） 運行結果： ......

    uj5u.com 2020-09-10 00:58:04 more
  • 【C++犯錯記錄】VS2019 MFC添加資源不懂如何修改資源宏ID

    1. 首先在資源視圖中，添加資源 2. 點擊新添加的資源，復制自動生成的ID 3. 在解決方案資源管理器中找到Resource.h檔案，編輯，使用整個專案搜索和替換的方式快速替換 宏宣告 4. Ctrl+Shift+F 全域搜索，點擊查找全部，然后逐個替換 5. 為什么使用搜索替換而不使用屬性視窗直 ......

    uj5u.com 2020-09-10 00:59:11 more
  • 【C++犯錯記錄】VS2019 MFC不懂的批量添加資源

    1. 打開資源頭檔案Resource.h，在其中預先定義好宏 ID（不清楚其實ID值應該設定多少，可以先新建一個相同的資源項，再在這個資源的ID值的基礎上遞增即可） 2. 在資源視圖中選中專案資源，按F7編輯資源檔案，按 ID 型別 相對路徑的形式添加 資源。（別忘了先把檔案拷貝到專案中的res檔案 ......

    uj5u.com 2020-09-10 01:00:19 more
  • C/C++編程筆記：關于C++的參考型別，專供新手入門使用

    今天要講的是C++中我最喜歡的一個用法——參考，也叫別名。 參考就是給一個變數名取一個變數名，方便我們間接地使用這個變數。我們可以給一個變數創建N個參考，這N + 1個變數共享了同一塊記憶體區域。(參考型別的變數會占用記憶體空間，占用的記憶體空間的大小和指標型別的大小是相同的。雖然參考是一個物件的別名，但 ......

    uj5u.com 2020-09-10 01:00:22 more
  • 【C/C++編程筆記】從頭開始學習C ++：初學者完整指南

    眾所周知，C ++的學習曲線陡峭，但是花時間學習這種語言將為您的職業帶來奇跡，并使您與其他開發人員區分開。您會更輕松地學習新語言，形成真正的解決問題的技能，并在編程的基礎上打下堅實的基礎。 C ++將幫助您養成良好的編程習慣（即清晰一致的編碼風格，在撰寫代碼時注釋代碼，并限制類內部的可見性），并且由 ......

    uj5u.com 2020-09-10 01:00:41 more
最新发布
  • Rust中的智能指標:Box<T> Rc<T> Arc<T> Cell<T> RefCell<T> Weak

    Rust中的智能指標是什么 智能指標（smart pointers）是一類資料結構，是擁有資料所有權和額外功能的指標。是指標的進一步發展 指標（pointer）是一個包含記憶體地址的變數的通用概念。這個地址參考，或 ” 指向”（points at）一些其 他資料 。參考以 & 符號為標志并借用了他們所 ......

    uj5u.com 2023-04-20 07:24:10 more
  • Java的值傳遞和參考傳遞

    值傳遞不會改變本身，參考傳遞（如果傳遞的值需要實體化到堆里）如果發生修改了會改變本身。 1.基本資料型別都是值傳遞 package com.example.basic; public class Test { public static void main(String[] args) { int ......

    uj5u.com 2023-04-20 07:24:04 more
  • [2]SpinalHDL教程——Scala簡單入門

    第一個 Scala 程式 shell里面輸入 $ scala scala> 1 + 1 res0: Int = 2 scala> println("Hello World!") Hello World! 檔案形式 object HelloWorld { /* 這是我的第一個 Scala 程式 * 以 ......

    uj5u.com 2023-04-20 07:23:58 more
  • 理解函式指標和回呼函式

    理解 函式指標 指向函式的指標。比如： 理解函式指標的偽代碼 void (*p)(int type, char *data); // 定義一個函式指標p void func(int type, char *data); // 宣告一個函式func p = func; // 將指標p指向函式func ......

    uj5u.com 2023-04-20 07:23:52 more
  • Django筆記二十五之資料庫函式之日期函式

    本文首發于公眾號：Hunter后端 原文鏈接：Django筆記二十五之資料庫函式之日期函式 日期函式主要介紹兩個大類，Extract() 和 Trunc() Extract() 函式作用是提取日期，比如我們可以提取一個日期欄位的年份，月份，日等資料 Trunc() 的作用則是截取，比如 2022-0 ......

    uj5u.com 2023-04-20 07:23:45 more
  • 一天吃透JVM面試八股文

    什么是JVM？ JVM，全稱Java Virtual Machine（Java虛擬機），是通過在實際的計算機上仿真模擬各種計算機功能來實作的。由一套位元組碼指令集、一組暫存器、一個堆疊、一個垃圾回收堆和一個存盤方法域等組成。JVM屏蔽了與作業系統平臺相關的資訊，使得Java程式只需要生成在Java虛擬機 ......

    uj5u.com 2023-04-20 07:23:31 more
  • 使用Java接入小程式訂閱訊息！

    更新完微信服務號的模板訊息之后，我又趕緊把微信小程式的訂閱訊息給實作了！之前我一直以為微信小程式也是要企業才能申請，沒想到小程式個人就能申請。 訊息推送平臺🔥推送下發【郵件】【短信】【微信服務號】【微信小程式】【企業微信】【釘釘】等訊息型別。 https://gitee.com/zhongfuch ......

    uj5u.com 2023-04-20 07:22:59 more
  • java -- 緩沖流、轉換流、序列化流

    緩沖流 緩沖流, 也叫高效流, 按照資料型別分類： 位元組緩沖流：BufferedInputStream，BufferedOutputStream 字符緩沖流：BufferedReader，BufferedWriter 緩沖流的基本原理，是在創建流物件時，會創建一個內置的默認大小的緩沖區陣列，通過緩沖 ......

    uj5u.com 2023-04-20 07:22:49 more
  • Java-SpringBoot-Range請求頭設定實作視頻分段傳輸

    老實說，人太懶了，現在基本都不喜歡寫筆記了，但是網上有關Range請求頭的文章都太水了 下面是抄的一段StackOverflow的代碼...自己大修改過的，寫的注釋挺全的，應該直接看得懂，就不解釋了 寫的不好...只是希望能給視頻網站開發的新手一點點幫助吧. 業務場景：視頻分段傳輸、視頻多段傳輸（理 ......

    uj5u.com 2023-04-20 07:22:42 more
  • Windows 10開發教程_編程入門自學教程_菜鳥教程-免費教程分享

    教程簡介 Windows 10開發入門教程 - 從簡單的步驟了解Windows 10開發，從基本到高級概念，包括簡介，UWP，第一個應用程式，商店，XAML控制元件，資料系結，XAML性能，自適應設計，自適應UI，自適應代碼，檔案管理，SQLite資料庫，應用程式到應用程式通信，應用程式本地化，應用程式 ......

    uj5u.com 2023-04-20 07:22:35 more

Copyright © 2010-2020 有解無憂