定時任務在實際的開發(fā)中特別常見，比如電商平臺 30 分鐘后自動取消未支付的訂單，以及凌晨的數據匯總和備份等，都需要借助定時任務來實現，那么我們本文就來看一下定時任務最簡單的幾種實現方式。
TOP 1：Timer
Timer 是 JDK 自帶的定時任務執(zhí)行類，無論任何項目都可以直接使用 Timer 來實現定時任務，所以 Timer 的優(yōu)點就是使用方便，它的實現代碼如下：
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();
// 添加執(zhí)行任務（延遲 1s 執(zhí)行，每 3s 執(zhí)行一次）
timer.schedule(timerTask, 1000, 3000);
}
}程序執(zhí)行結果如下：
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：任務執(zhí)行時間長影響其他任務
當一個任務的執(zhí)行時間過長時，會影響其他任務的調度，如下代碼所示：
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();
// 添加執(zhí)行任務（延遲 1s 執(zhí)行，每 3s 執(zhí)行一次）
timer.schedule(timerTask, 1000, 3000);
timer.schedule(timerTask2, 1000, 3000);
}
}程序執(zhí)行結果如下：
進入 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 也會延遲執(zhí)行。 原本任務 1 和任務 2 的執(zhí)行時間間隔都是 3s，但因為任務 1 執(zhí)行了 5s，因此任務 2 的執(zhí)行時間間隔也變成了 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();
// 添加執(zhí)行任務（延遲 1s 執(zhí)行，每 3s 執(zhí)行一次）
timer.schedule(timerTask, 1000, 3000);
timer.schedule(timerTask2, 1000, 3000);
}
}程序執(zhí)行結果如下：
進入 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 類實現定時任務的優(yōu)點是方便，因為它是 JDK 自定的定時任務，但缺點是任務如果執(zhí)行時間太長或者是任務執(zhí)行異常，會影響其他任務調度，所以在生產環(huán)境下建議謹慎使用。
TOP 2：ScheduledExecutorService
ScheduledExecutorService 也是 JDK 1.5 自帶的 API，我們可以使用它來實現定時任務的功能，也就是說 ScheduledExecutorService 可以實現 Timer 類具備的所有功能，并且它可以解決了 Timer 類存在的所有問題。
ScheduledExecutorService 實現定時任務的代碼示例如下：
public class MyScheduledExecutorService {
public static void main(String[] args) {
// 創(chuàng)建任務隊列
ScheduledExecutorService scheduledExecutorService =
Executors.newScheduledThreadPool(10); // 10 為線程數量
// 執(zhí)行任務
scheduledExecutorService.scheduleAtFixedRate(() -> {
System.out.println("Run Schedule：" + new Date());
}, 1, 3, TimeUnit.SECONDS); // 1s 后開始執(zhí)行，每 3s 執(zhí)行一次
}
}程序執(zhí)行結果如下：
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 可靠性測試
① 任務超時執(zhí)行測試
ScheduledExecutorService 可以解決 Timer 任務之間相應影響的缺點，首先我們來測試一個任務執(zhí)行時間過長，會不會對其他任務造成影響，測試代碼如下：
public class MyScheduledExecutorService {
public static void main(String[] args) {
// 創(chuàng)建任務隊列
ScheduledExecutorService scheduledExecutorService =
Executors.newScheduledThreadPool(10);
// 執(zhí)行任務 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 后開始執(zhí)行，每 3s 執(zhí)行一次
// 執(zhí)行任務 2
scheduledExecutorService.scheduleAtFixedRate(() -> {
System.out.println("Run Schedule2：" + new Date());
}, 1, 3, TimeUnit.SECONDS); // 1s 后開始執(zhí)行，每 3s 執(zhí)行一次
}
}程序執(zhí)行結果如下：
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 執(zhí)行時間 5s 超過了執(zhí)行頻率 3s 時，并沒有影響任務 2 的正常執(zhí)行，因此使用 ScheduledExecutorService 可以避免任務執(zhí)行時間過長對其他任務造成的影響。
② 任務異常測試
接下來我們來測試一下 ScheduledExecutorService 在一個任務異常時，是否會對其他任務造成影響，測試代碼如下：
public class MyScheduledExecutorService {
public static void main(String[] args) {
// 創(chuàng)建任務隊列
ScheduledExecutorService scheduledExecutorService =
Executors.newScheduledThreadPool(10);
// 執(zhí)行任務 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 后開始執(zhí)行，每 3s 執(zhí)行一次
// 執(zhí)行任務 2
scheduledExecutorService.scheduleAtFixedRate(() -> {
System.out.println("Run Schedule2：" + new Date());
}, 1, 3, TimeUnit.SECONDS); // 1s 后開始執(zhí)行，每 3s 執(zhí)行一次
}
}程序執(zhí)行結果如下：
進入 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 的執(zhí)行。
ScheduledExecutorService 小結
在單機生產環(huán)境下建議使用 ScheduledExecutorService 來執(zhí)行定時任務，它是 JDK 1.5 之后自帶的 API，因此使用起來也比較方便，并且使用 ScheduledExecutorService 來執(zhí)行任務，不會造成任務間的相互影響。
TOP 3：Spring Task
如果使用的是 Spring 或 Spring Boot 框架，可以直接使用 Spring Framework 自帶的定時任務，使用上面兩種定時任務的實現方式，很難實現設定了具體時間的定時任務，比如當我們需要每周五來執(zhí)行某項任務時，但如果使用 Spring Task 就可輕松的實現此需求。
以 Spring Boot 為例，實現定時任務只需兩步：
- 開啟定時任務；
- 添加定時任務。
具體實現步驟如下。
① 開啟定時任務
開啟定時任務只需要在 Spring Boot 的啟動類上聲明 @EnableScheduling 即可，實現代碼如下：
@SpringBootApplication
@EnableScheduling // 開啟定時任務
public class DemoApplication {
// do someing
}② 添加定時任務
定時任務的添加只需要使用 @Scheduled 注解標注即可，如果有多個定時任務可以創(chuàng)建多個 @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 執(zhí)行
public void doTask(){
System.out.println("我是定時任務~");
}
}注意：定時任務是自動觸發(fā)的無需手動干預，也就是說 Spring Boot 啟動后會自動加載并執(zhí)行定時任務。
Cron 表達式
Spring Task 的實現需要使用 cron 表達式來聲明執(zhí)行的頻率和規(guī)則，cron 表達式是由 6 位或者 7 位組成的（最后一位可以省略），每位之間以空格分隔，每位從左到右代表的含義如下：
其中 * 和 ? 號都表示匹配所有的時間。
cron 表達式在線生成地址：https://cron.qqe2.com/
知識擴展：分布式定時任務
上面的方法都是關于單機定時任務的實現，如果是分布式環(huán)境可以使用 Redis 來實現定時任務。
使用 Redis 實現延遲任務的方法大體可分為兩類：通過 ZSet 的方式和鍵空間通知的方式。
① ZSet 實現方式
通過 ZSet 實現定時任務的思路是，將定時任務存放到 ZSet 集合中，并且將過期時間存儲到 ZSet 的 Score 字段中，然后通過一個無線循環(huán)來判斷當前時間內是否有需要執(zhí)行的定時任務，如果有則進行執(zhí)行，具體實現代碼如下：
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 后執(zhí)行
long delayTime = Instant.now().plusSeconds(30).getEpochSecond();
jedis.zadd(_KEY, delayTime, "order_1");
// 繼續(xù)添加測試數據
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);
}
// 刪除已經執(zhí)行的任務
jedis.zremrangeByScore(_KEY, lastSecond, nowSecond);
Thread.sleep(1000); // 每秒查詢一次
}
}
}② 鍵空間通知
我們可以通過 Redis 的鍵空間通知來實現定時任務，它的實現思路是給所有的定時任務設置一個過期時間，等到了過期之后，我們通過訂閱過期消息就能感知到定時任務需要被執(zhí)行了，此時我們執(zhí)行定時任務即可。
默認情況下 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();
// 執(zhí)行定時任務
doTask(jedis);
}
/**
* 訂閱過期消息，執(zhí)行定時任務
* @param jedis Redis 客戶端
*/
public static void doTask(Jedis jedis) {
// 訂閱過期消息
jedis.psubscribe(new JedisPubSub() {
@Override
public void onPMessage(String pattern, String channel, String message) {
// 接收到消息，執(zhí)行定時任務
System.out.println("收到消息：" + message);
}
}, _TOPIC);
}
} 
