java定時任務_定時任務最簡單的3種實現方法（超好用）
如果使用的是 Spring 或 Spring Boot 框架，可以直接使用 Spring Framework 自帶的定時任務 Spring Task
https://blog.csdn.net/weixin_39940788/article/details/109762004

定時任務在實際的開發中特別常見，比如電商平臺 30 分鐘後自動取消未支付的訂單，以及凌晨的資料彙總和備份等，都需要藉助定時任務來實現，那麼我們本文就來看一下定時任務最簡單的幾種實現方式。

TOP 1：Timer

Timer 是 JDK 自帶的定時任務執行類，無論任何專案都可以直接使用 Timer 來實現定時任務，所以 Timer 的優點就是使用方便，它的實現程式碼如下：

public class MyTimerTask {



    public static void main(String[] args) {



        // 定義一個任務




        TimerTask timerTask = new TimerTask() {



            @Override




            public void run() {



                System.out.println("Run timerTask：" + new Date());



            }
 



        };



        // 計時器




        Timer timer = new Timer();



        // 新增執行任務（延遲 1s 執行，每 3s 執行一次）




        timer.schedule(timerTask, 1000, 3000);



    }



}

程式執行結果如下：

Run timerTask：Mon Aug 17 21:29:25 CST 2020
Run timerTask：Mon Aug 17 21:29:28 CST 2020
Run timerTask：Mon Aug 17 21:29:31 CST 2020

Timer 缺點分析

Timer 類實現定時任務雖然方便，但在使用時需要注意以下問題。

問題 1：任務執行時間長影響其他任務

當一個任務的執行時間過長時，會影響其他任務的排程，如下程式碼所示：

public class MyTimerTask {



    public static void main(String[] args) {



        // 定義任務 1




        TimerTask timerTask = new TimerTask() {



            @Override




            public void run() {



                System.out.println("進入 timerTask 1：" + new Date());



                try {



                    // 休眠 5 秒




                    TimeUnit.SECONDS.sleep(5);



                } catch (InterruptedException e) {



                    e.printStackTrace();



                }



                System.out.println("Run timerTask 1：" + new Date());



            }



        };



        // 定義任務 2




        TimerTask timerTask2 = new TimerTask() {



            @Override




            public void run() {



                System.out.println("Run timerTask 2：" + new Date());



            }



        };



        // 計時器




        Timer timer = new Timer();



        // 新增執行任務（延遲 1s 執行，每 3s 執行一次）




        timer.schedule(timerTask, 1000, 3000);



        timer.schedule(timerTask2, 1000, 3000);



    }



}

程式執行結果如下：

進入 timerTask 1：Mon Aug 17 21:44:08 CST 2020
Run timerTask 1：Mon Aug 17 21:44:13 CST 2020 Run timerTask 2：Mon Aug 17 21:44:13 CST 2020
進入 timerTask 1：Mon Aug 17 21:44:13 CST 2020
Run timerTask 1：Mon Aug 17 21:44:18 CST 2020
進入 timerTask 1：Mon Aug 17 21:44:18 CST 2020
Run timerTask 1：Mon Aug 17 21:44:23 CST 2020 Run timerTask 2：Mon Aug 17 21:44:23 CST 2020
進入 timerTask 1：Mon Aug 17 21:44:23 CST 2020

從上述結果中可以看出，當任務 1 執行時間超過設定的間隔時間時，任務 2 也會延遲執行。 原本任務 1 和任務 2 的執行時間間隔都是 3s，但因為任務 1 執行了 5s，因此任務 2 的執行時間間隔也變成了 10s（和原定時間不符）。

問題 2：任務異常影響其他任務

使用 Timer 類實現定時任務時，當一個任務丟擲異常，其他任務也會終止執行，如下程式碼所示：

public class MyTimerTask {



    public static void main(String[] args) {



        // 定義任務 1




        TimerTask timerTask = new TimerTask() {



            @Override




            public void run() {



                System.out.println("進入 timerTask 1：" + new Date());



                // 模擬異常




                int num = 8 / 0;



                System.out.println("Run timerTask 1：" + new Date());



            }



        };



        // 定義任務 2




        TimerTask timerTask2 = new TimerTask() {



            @Override




            public void run() {



                System.out.println("Run timerTask 2：" + new Date());



            }



        };



        // 計時器




        Timer timer = new Timer();



        // 新增執行任務（延遲 1s 執行，每 3s 執行一次）




        timer.schedule(timerTask, 1000, 3000);



        timer.schedule(timerTask2, 1000, 3000);



    }



}

程式執行結果如下：

進入 timerTask 1：Mon Aug 17 22:02:37 CST 2020
Exception in thread "Timer-0" java.lang.ArithmeticException: / by zero
at com.example.MyTimerTask$1.run(MyTimerTask.java:21)
at java.util.TimerThread.mainLoop(Timer.java:555)
at java.util.TimerThread.run(Timer.java:505)
Process finished with exit code 0

Timer 小結

Timer 類實現定時任務的優點是方便，因為它是 JDK 自定的定時任務，但缺點是任務如果執行時間太長或者是任務執行異常，會影響其他任務排程，所以在生產環境下建議謹慎使用。

TOP 2：ScheduledExecutorService

ScheduledExecutorService 也是 JDK 1.5 自帶的 API，我們可以使用它來實現定時任務的功能，也就是說 ScheduledExecutorService 可以實現 Timer 類具備的所有功能，並且它可以解決了 Timer 類存在的所有問題。

ScheduledExecutorService 實現定時任務的程式碼示例如下：

public class MyScheduledExecutorService {



    public static void main(String[] args) {



        // 建立任務佇列




        ScheduledExecutorService scheduledExecutorService =



                Executors.newScheduledThreadPool(10); // 10 為執行緒數量




  // 執行任務




        scheduledExecutorService.scheduleAtFixedRate(() -> {



            System.out.println("Run Schedule：" + new Date());



        }, 1, 3, TimeUnit.SECONDS); // 1s 後開始執行，每 3s 執行一次




    }



}

程式執行結果如下：

Run Schedule：Mon Aug 17 21:44:23 CST 2020
Run Schedule：Mon Aug 17 21:44:26 CST 2020
Run Schedule：Mon Aug 17 21:44:29 CST 2020

ScheduledExecutorService 可靠性測試

① 任務超時執行測試

ScheduledExecutorService 可以解決 Timer 任務之間相應影響的缺點，首先我們來測試一個任務執行時間過長，會不會對其他任務造成影響，測試程式碼如下：

public class MyScheduledExecutorService {



    public static void main(String[] args) {



        // 建立任務佇列




        ScheduledExecutorService scheduledExecutorService =



                Executors.newScheduledThreadPool(10);



        // 執行任務 1




        scheduledExecutorService.scheduleAtFixedRate(() -> {



            System.out.println("進入 Schedule：" + new Date());



            try {



                // 休眠 5 秒




                TimeUnit.SECONDS.sleep(5);



            } catch (InterruptedException e) {



                e.printStackTrace();



            }



            System.out.println("Run Schedule：" + new Date());



        }, 1, 3, TimeUnit.SECONDS); // 1s 後開始執行，每 3s 執行一次




        // 執行任務 2




        scheduledExecutorService.scheduleAtFixedRate(() -> {



            System.out.println("Run Schedule2：" + new Date());



        }, 1, 3, TimeUnit.SECONDS); // 1s 後開始執行，每 3s 執行一次




    }



}

程式執行結果如下：

Run Schedule2：Mon Aug 17 11:27:55 CST 2020
進入 Schedule：Mon Aug 17 11:27:55 CST 2020 Run Schedule2：Mon Aug 17 11:27:58 CST 2020
Run Schedule：Mon Aug 17 11:28:00 CST 2020
進入 Schedule：Mon Aug 17 11:28:00 CST 2020 Run Schedule2：Mon Aug 17 11:28:01 CST 2020 Run Schedule2：Mon Aug 17 11:28:04 CST 2020

從上述結果可以看出，當任務 1 執行時間 5s 超過了執行頻率 3s 時，並沒有影響任務 2 的正常執行，因此使用 ScheduledExecutorService 可以避免任務執行時間過長對其他任務造成的影響。

② 任務異常測試

接下來我們來測試一下 ScheduledExecutorService 在一個任務異常時，是否會對其他任務造成影響，測試程式碼如下：

public class MyScheduledExecutorService {



    public static void main(String[] args) {



        // 建立任務佇列




        ScheduledExecutorService scheduledExecutorService =



                Executors.newScheduledThreadPool(10);



        // 執行任務 1




        scheduledExecutorService.scheduleAtFixedRate(() -> {



            System.out.println("進入 Schedule：" + new Date());



            // 模擬異常




            int num = 8 / 0;



            System.out.println("Run Schedule：" + new Date());



        }, 1, 3, TimeUnit.SECONDS); // 1s 後開始執行，每 3s 執行一次




        // 執行任務 2




        scheduledExecutorService.scheduleAtFixedRate(() -> {



            System.out.println("Run Schedule2：" + new Date());



        }, 1, 3, TimeUnit.SECONDS); // 1s 後開始執行，每 3s 執行一次




    }



}

程式執行結果如下：

進入 Schedule：Mon Aug 17 22:17:37 CST 2020
Run Schedule2：Mon Aug 17 22:17:37 CST 2020
Run Schedule2：Mon Aug 17 22:17:40 CST 2020
Run Schedule2：Mon Aug 17 22:17:43 CST 2020

從上述結果可以看出，當任務 1 出現異常時，並不會影響任務 2 的執行。

ScheduledExecutorService 小結

在單機生產環境下建議使用 ScheduledExecutorService 來執行定時任務，它是 JDK 1.5 之後自帶的 API，因此使用起來也比較方便，並且使用 ScheduledExecutorService 來執行任務，不會造成任務間的相互影響。

TOP 3：Spring Task

如果使用的是 Spring 或 Spring Boot 框架，可以直接使用 Spring Framework 自帶的定時任務，使用上面兩種定時任務的實現方式，很難實現設定了具體時間的定時任務，比如當我們需要每週五來執行某項任務時，但如果使用 Spring Task 就可輕鬆的實現此需求。

以 Spring Boot 為例，實現定時任務只需兩步：

1. 開啟定時任務；
2. 新增定時任務。

具體實現步驟如下。

① 開啟定時任務

開啟定時任務只需要在 Spring Boot 的啟動類上宣告 @EnableScheduling 即可，實現程式碼如下：

@SpringBootApplication




@EnableScheduling // 開啟定時任務





public class DemoApplication {



    // do someing




}

② 新增定時任務

定時任務的新增只需要使用 @Scheduled 註解標註即可，如果有多個定時任務可以建立多個 @Scheduled 註解標註的方法，示例程式碼如下：

import org.springframework.scheduling.annotation.Scheduled;




import org.springframework.stereotype.Component;



 




@Component // 把此類託管給 Spring，不能省略





public class TaskUtils {



    // 新增定時任務




    @Scheduled(cron = "59 59 23 0 0 5") // cron 表示式，每週五 23:59:59 執行




    public void doTask(){



        System.out.println("我是定時任務~");



    }



}

注意：定時任務是自動觸發的無需手動干預，也就是說 Spring Boot 啟動後會自動載入並執行定時任務。

Cron 表示式

Spring Task 的實現需要使用 cron 表示式來宣告執行的頻率和規則，cron 表示式是由 6 位或者 7 位組成的（最後一位可以省略），每位之間以空格分隔，每位從左到右代表的含義如下：

其中 * 和 ? 號都表示匹配所有的時間。

cron 表示式線上生成地址：https://cron.qqe2.com/

知識擴充套件：分散式定時任務

上面的方法都是關於單機定時任務的實現，如果是分散式環境可以使用 Redis 來實現定時任務。

使用 Redis 實現延遲任務的方法大體可分為兩類：通過 ZSet 的方式和鍵空間通知的方式。

① ZSet 實現方式

通過 ZSet 實現定時任務的思路是，將定時任務存放到 ZSet 集合中，並且將過期時間儲存到 ZSet 的 Score 欄位中，然後通過一個無線迴圈來判斷當前時間內是否有需要執行的定時任務，如果有則進行執行，具體實現程式碼如下：

import redis.clients.jedis.Jedis;




import utils.JedisUtils;




import java.time.Instant;




import java.util.Set;



 




public class DelayQueueExample {



    // zset key




    private static final String _KEY = "myTaskQueue";



    



    public static void main(String[] args) throws InterruptedException {



        Jedis jedis = JedisUtils.getJedis();



        // 30s 後執行




        long delayTime = Instant.now().plusSeconds(30).getEpochSecond();



        jedis.zadd(_KEY, delayTime, "order_1");



        // 繼續新增測試資料




        jedis.zadd(_KEY, Instant.now().plusSeconds(2).getEpochSecond(), "order_2");



        jedis.zadd(_KEY, Instant.now().plusSeconds(2).getEpochSecond(), "order_3");



        jedis.zadd(_KEY, Instant.now().plusSeconds(7).getEpochSecond(), "order_4");



        jedis.zadd(_KEY, Instant.now().plusSeconds(10).getEpochSecond(), "order_5");



        // 開啟定時任務佇列




        doDelayQueue(jedis);



    }



 



    /**




     * 定時任務佇列消費



     * @param jedis Redis 客戶端



     */



    public static void doDelayQueue(Jedis jedis) throws InterruptedException {



        while (true) {



            // 當前時間




            Instant nowInstant = Instant.now();



            long lastSecond = nowInstant.plusSeconds(-1).getEpochSecond(); // 上一秒時間




            long nowSecond = nowInstant.getEpochSecond();



            // 查詢當前時間的所有任務




            Set<String> data = jedis.zrangeByScore(_KEY, lastSecond, nowSecond);



            for (String item : data) {



                // 消費任務




                System.out.println("消費：" + item);



            }



            // 刪除已經執行的任務




            jedis.zremrangeByScore(_KEY, lastSecond, nowSecond);



            Thread.sleep(1000); // 每秒查詢一次




        }



    }



}

② 鍵空間通知

我們可以通過 Redis 的鍵空間通知來實現定時任務，它的實現思路是給所有的定時任務設定一個過期時間，等到了過期之後，我們通過訂閱過期訊息就能感知到定時任務需要被執行了，此時我們執行定時任務即可。

預設情況下 Redis 是不開啟鍵空間通知的，需要我們通過 config set notify-keyspace-events Ex 的命令手動開啟，開啟之後定時任務的程式碼如下：

import redis.clients.jedis.Jedis;




import redis.clients.jedis.JedisPubSub;




import utils.JedisUtils;



 




public class TaskExample {



    public static final String _TOPIC = "__keyevent@0__:expired"; // 訂閱頻道名稱




    public static void main(String[] args) {



        Jedis jedis = JedisUtils.getJedis();



        // 執行定時任務




        doTask(jedis);



    }



 



    /**




     * 訂閱過期訊息，執行定時任務



     * @param jedis Redis 客戶端



     */



    public static void doTask(Jedis jedis) {



        // 訂閱過期訊息




        jedis.psubscribe(new JedisPubSub() {



            @Override




            public void onPMessage(String pattern, String channel, String message) {



                // 接收到訊息，執行定時任務




                System.out.println("收到訊息：" + message);



            }



        }, _TOPIC);



    }



}