java定時任務目前主要有三種：
- Java自帶的java.util.Timer類，這個類允許你調度一個java.util.TimerTask任務，使用這種方式可以讓你的程式按照某一個頻度執行，但不能在指定時間運行；而且作業類需要集成java.util.TimerTask，一般用的較少，
- Spring3.0以后自帶的task，即：spring schedule，可以將它看成一個輕量級的Quartz，而且使用起來比Quartz簡單許多，
- Quartz，這是一個功能比較強大的的調度器，可以讓你的程式在指定時間執行，也可以按照某一個頻度執行；代碼稍顯復雜，
定時器演算法
1.小頂堆
堆，實際上是一種經過排序的完全二叉樹，其中任一非終端節點的資料值均不大于（或不小于）其左子節點和右子節點的值，
堆又分為兩種，最大堆、最小堆，
- 最大堆： 任一非葉子節點的值均大于其左子節點和右子節點的值，根節點的值是最大的，
- 最小堆： 任一非葉子節點的值均小于其左子節點和右子節點的值，根節點的值是最小的，
小頂堆的實作方式
由于堆是一種經過排序的完全二叉樹，因此在構建的時候需要對其新插入的節點進行一些操作以使其符合堆的性質，這種操作就叫上浮與下沉，
- 上浮：將當前節點與其父節點相比，如果當前節點的值比父節點小，就把當前節點與父節點交換，然后繼續前面的交換，直到當前節點比父節點的值大為止，上浮就是將符合條件的節點往上移的程序，
- 下沉：將當前節點與其左、右子節點相比，如果當前節點的值比其中一個或兩個子節點的值大，就把當前節點與兩個子節點種比較小的那個交換，，然后繼續前面的比較，直到當前節點的值比兩個子節點的值都小為止，下沉就是將符合條件的節點往下移的程序，
2.時間輪演算法
見名知意，時間輪演算法的資料結構類似于鐘表上的資料指標，時間輪用環形陣列的方式實作，陣列中的每個元素都可以稱之為槽（和redis集群的槽一樣稱呼），槽的內部用雙向鏈表存盤著待執行的任務，添加和洗掉鏈表的操作時間復雜度為O（1），槽位本身也指代時間精度，比如一秒掃一個槽，那么這個時間輪的最高精度就是1秒，
當有一個延遲任務要插入時間輪時，首先計算其延遲時間與單位時間的余值，從指標指向的當前槽位移動余值的個數槽位，就是該延遲任務需要被放入的槽位，
舉個例子，時間輪有8個槽位，編號為 0 ~ 7 ，指標當前指向槽位 2 ，新增一個延遲時間為 4 秒的延遲任務，4 % 8 = 4，因此該任務會被插入 4 + 2 = 6，也就是槽位6的延遲任務佇列，
時間槽位的實作方式
時間輪的槽位實作可以采用回圈陣列的方式達成，也就是讓指標在越過陣列的邊界后重新回到起始下標，概括來說，可以將時間輪的演算法描述為:
用佇列來存盤延遲任務，同一個佇列中的任務，其延遲時間相同，用回圈陣列的方式來存盤元素，陣列中的每一個元素都指向一個延遲任務佇列，有一個當前指標指向陣列中的某一個槽位，每間隔一個單位時間，指標就移動到下一個槽位，被指標指向的槽位的延遲佇列，其中的延遲任務全部被觸發，在時間輪中新增一個延遲任務，將其延遲時間除以單位時間得到的余值，從當前指標開始，移動余值對應個數的槽位，就是延遲任務被放入的槽位，
基于這樣的資料結構，插入一個延遲任務的時間復雜度就下降到 O(1) ，而當指標指向到一個槽位時，該槽位連接的延遲任務佇列中的延遲任務全部被觸發，
延遲任務的觸發和執行不應該影響指標向后移動的時間精確性，因此一般情況下，用于移動指標的執行緒只負責任務的觸發，任務的執行交由其他的執行緒來完成，比如，可以將槽位上的延遲任務佇列放入到額外的執行緒池中執行，然后在槽位上新建一個空白的新的延遲任務佇列用于后續任務的添加，
代碼實作
Timer
/**
* @className: TimerTest
* @description: 測驗java.util.Timer的定時器實作
* @author: charon
* @create: 2021-10-10 10:35
*/
public class TimerTest {
public static void main(String[] args) {
Timer timer = new Timer();
// 延遲1s執行任務
timer.schedule(new TimerTask() {
@Override
public void run() {
System.out.println("延遲1s執行的任務"+new Date());
}
},1000);
// 延遲3s執行任務，每隔5s執行一次
timer.schedule(new TimerTask() {
@Override
public void run() {
System.out.println("延遲3s每隔5s執行一次的任務"+new Date());
}
},3000,5000);
// try {
// Thread.sleep(5000);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// timer.cancel();
// System.out.println("任務執行完畢"+new Date());
}
}
延遲1s執行的任務Sun Oct 10 14:34:13 CST 2021
延遲3s執行的任務Sun Oct 10 14:34:15 CST 2021
延遲3s執行的任務Sun Oct 10 14:34:20 CST 2021
延遲3s執行的任務Sun Oct 10 14:34:25 CST 2021
延遲3s執行的任務Sun Oct 10 14:34:30 CST 2021
Timer的實作方式比較簡單，其內部有兩個主要的屬性：
/**
* 用于存放定時任務TimeTask的串列
*/
private final TaskQueue queue = new TaskQueue();
/**
* 用于執行定時任務的執行緒
*/
private final TimerThread thread = new TimerThread(queue);
TimerTask是一個實作了Runnable介面的抽象類，其run（）方法用于提供具體的延時任務邏輯，
TaskQueue內部采用的是小頂堆的演算法實作，根據任務的觸發時間采用死回圈的方式進行排序，將執行時間最小的任務放在前面，
void add(TimerTask task) {
// Grow backing store if necessary
if (size + 1 == queue.length)
queue = Arrays.copyOf(queue, 2*queue.length);
queue[++size] = task;
fixUp(size);
}
private void fixUp(int k) {
while (k > 1) {
int j = k >> 1;
if (queue[j].nextExecutionTime <= queue[k].nextExecutionTime)
break;
TimerTask tmp = queue[j]; queue[j] = queue[k]; queue[k] = tmp;
k = j;
}
}
這樣的方式就會有三個問題：
- 由于執行任務的執行緒只有一個，所以如果某個任務的執行時間過長，那么將破壞其他任務的定時精確性，如一個任務每1秒執行一次，而另一個任務執行一次需要5秒，那么如果是固定速率的任務，那么會在5秒這個任務執行完成后連續執行5次，而固定延遲的任務將丟失4次執行，
- 如果執行某個任務程序中拋出了例外，那么執行執行緒將會終止，導致Timer中的其他任務也不能再執行，
- Timer使用的是絕對時間，即是某個時間點，所以它執行依賴系統的時間，如果系統時間修改了的話，將導致任務可能不會被執行，
由于Timer存在上面說的這些缺陷，在JDK1.5中，我們可以使用ScheduledThreadPoolExecutor來代替它，使用Executors.newScheduledThreadPool工廠方法或使用ScheduledThreadPoolExecutor的建構式來創建定時任務，它是基于執行緒池的實作，不會存在Timer存在的上述問題，當執行緒數量為1時，它相當于Timer，
schedule
Spring Schedule在使用前都需要引入spring的包，
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>5.0.2.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.0.2.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>5.0.2.RELEASE</version>
</dependency>
在這里我主要是使用spring boot注解的方式來實作：
/**
* 在spring boot的啟動類上面添加 @EnableScheduling 注解
*/
@SpringBootApplication
@EnableScheduling
public class ScheduleApplication {
public static void main(String[] args) {
SpringApplication.run(ScheduleApplication.class,args);
}
}
新創建一個類，用來實作定時任務，這個類要注冊成為Bean才行，
/**
* @className: ScheduleTest
* @description: 測驗schedule的執行器
* @author: charon
* @create: 2021-10-10 19:04
*/
@Component
public class ScheduleTest {
/**
* corn運算式：秒、分、時、日、月、星期
* 值可以是數字，也可以是以下符號：
* *：所有值都匹配 示例： 0 0 * * * *：每小時（當秒和分都為0的時候）
* ?：只能用在日期和星期兩個運算式種 示例： 0 0 12 * * ? 每天中午12點觸發
* ,：或者 示例：0 0 9,13 * * *：每天的9點和13點
* /：增量值 示例: */10 * * * * *：每10秒
* -：區間 示例： 0 0/30 9-17 * * ? ： 朝九晚五作業時間內每半小時
*/
@Scheduled(cron="0 * * * * *")
public void doSomething(){
System.out.println("測驗schedule的定時器，當秒為0的時候執行一次："+new Date());
}
}
測驗schedule的定時器，當秒為0的時候執行一次：Sun Oct 10 19:18:00 CST 2021
測驗schedule的定時器，當秒為0的時候執行一次：Sun Oct 10 19:19:00 CST 2021
測驗schedule的定時器，當秒為0的時候執行一次：Sun Oct 10 19:20:00 CST 2021
@Scheduled注解的另外兩個重要屬性：fixedRate和fixedDelay
- fixedDelay：上一個任務結束后多久執行下一個任務
- fixedRate：上一個任務的開始到下一個任務開始時間的間隔
/**
* 測驗fixedRate，每2s執行一次
* @throws Exception
*/
@Scheduled(fixedRate = 2000)
public void fixedRate() throws Exception {
System.out.println("fixedRate開始執行時間:" + new Date(System.currentTimeMillis()));
//休眠1秒
Thread.sleep(1000);
System.out.println("fixedRate執行結束時間:" + new Date(System.currentTimeMillis()));
}
fixedRate開始執行時間:Sun Oct 10 19:59:05 CST 2021
fixedRate執行結束時間:Sun Oct 10 19:59:06 CST 2021
fixedRate開始執行時間:Sun Oct 10 19:59:07 CST 2021
fixedRate執行結束時間:Sun Oct 10 19:59:08 CST 2021
fixedRate開始執行時間:Sun Oct 10 19:59:09 CST 2021
fixedRate執行結束時間:Sun Oct 10 19:59:10 CST 2021
/**
* 等上一次執行完等待1s執行
* @throws Exception
*/
@Scheduled(fixedDelay = 1000)
public void fixedDelay() throws Exception {
System.out.println("fixedDelay開始執行時間:" + new Date(System.currentTimeMillis()));
//休眠兩秒
Thread.sleep(1000 * 2);
System.out.println("fixedDelay執行結束時間:" + new Date(System.currentTimeMillis()));
}
fixedDelay執行結束時間:Sun Oct 10 20:07:23 CST 2021
fixedDelay開始執行時間:Sun Oct 10 20:07:24 CST 2021
fixedDelay執行結束時間:Sun Oct 10 20:07:26 CST 2021
fixedDelay開始執行時間:Sun Oct 10 20:07:27 CST 2021
fixedDelay執行結束時間:Sun Oct 10 20:07:29 CST 2021
如果是強調任務間隔的定時任務，建議使用fixedRate和fixedDelay，如果是強調任務在某時某分某刻執行的定時任務，建議使用cron運算式，
Spring Schedule的Corn是使用的時間輪演算法（分層時間輪,每個時間粒度對應一個時間輪，多個時間輪時間進行級聯協調），
在CronSequenceGenerator.java這個類中，對每個CornTask都維護了一下7個Bitset（使用位陣列而不用list，set之類的資料結構，一方面是因為空間效率，更重要的是接下來的操作主要是判斷某個值是否匹配和從某個值開始找最近的下一個能夠匹配的值）
private final BitSet months = new BitSet(12);
private final BitSet daysOfMonth = new BitSet(31);
private final BitSet daysOfWeek = new BitSet(7);
private final BitSet hours = new BitSet(24);
private final BitSet minutes = new BitSet(60);
private final BitSet seconds = new BitSet(60);
然后根據配置的corn值計算這個任務對應的值計算每個bit的值，如我這里配置的每分鐘執行一次的CornTask的結果如下：
CronSequenceGenerator負責決議用戶配置的Cron運算式，并提供next方法，根據給定的時間獲取符合cron運算式規則的最近的下一個時間，CronTrigger實作Trigger的nextExecutionTime方法，根據定時任務執行的背景關系環境(最近調度時間和最近完成時間)決定查找下一次執行時間的左邊界，之后呼叫CronSequenceGenerator的next方法從左邊界開始找下一次的執行時間，
CronSequenceGenerator的doNext演算法從指定時間開始(包括指定時間)查找符合cron運算式規則下一個匹配的時間，如圖3-4所示，其整體思路是：沿著秒→分→時→日→月逐步檢查指定時間的值，如果所有域上的值都已經符合規則那么指定時間符合cron運算式，演算法結束，否則，必然有某個域的值不符合規則，調整該域到下一個符合規則的值(可能調整更高的域)，并將較低域的值調整到最小值，然后從秒開始重新檢查和調整，
private void doNext(Calendar calendar, int dot) {
List<Integer> resets = new ArrayList<>();
int second = calendar.get(Calendar.SECOND);
List<Integer> emptyList = Collections.emptyList();
int updateSecond = findNext(this.seconds, second, calendar, Calendar.SECOND, Calendar.MINUTE, emptyList);
if (second == updateSecond) {
resets.add(Calendar.SECOND);
}
int minute = calendar.get(Calendar.MINUTE);
int updateMinute = findNext(this.minutes, minute, calendar, Calendar.MINUTE, Calendar.HOUR_OF_DAY, resets);
if (minute == updateMinute) {
resets.add(Calendar.MINUTE);
}
else {
doNext(calendar, dot);
}
int hour = calendar.get(Calendar.HOUR_OF_DAY);
int updateHour = findNext(this.hours, hour, calendar, Calendar.HOUR_OF_DAY, Calendar.DAY_OF_WEEK, resets);
if (hour == updateHour) {
resets.add(Calendar.HOUR_OF_DAY);
}
else {
doNext(calendar, dot);
}
int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK);
int dayOfMonth = calendar.get(Calendar.DAY_OF_MONTH);
int updateDayOfMonth = findNextDay(calendar, this.daysOfMonth, dayOfMonth, this.daysOfWeek, dayOfWeek, resets);
if (dayOfMonth == updateDayOfMonth) {
resets.add(Calendar.DAY_OF_MONTH);
}
else {
doNext(calendar, dot);
}
int month = calendar.get(Calendar.MONTH);
int updateMonth = findNext(this.months, month, calendar, Calendar.MONTH, Calendar.YEAR, resets);
if (month != updateMonth) {
if (calendar.get(Calendar.YEAR) - dot > 4) {
throw new IllegalArgumentException("Invalid cron expression \"" + this.expression +
"\" led to runaway search for next trigger");
}
doNext(calendar, dot);
}
}
private int findNext(BitSet bits, int value, Calendar calendar, int field, int nextField, List<Integer> lowerOrders) {
int nextValue = https://www.cnblogs.com/pluto-charon/p/bits.nextSetBit(value);
// 下一個匹配值是－1，則將對更高的域做加1操作，從0開始查找下一個匹配值,將當前域設定為下一個匹配值，重置比當前域低的所有域設定為最小值，遞回調度本演算法，
if (nextValue == -1) {
calendar.add(nextField, 1);
reset(calendar, Collections.singletonList(field));
nextValue = bits.nextSetBit(0);
}
// 下一個匹配值不是當前值但也不是－1，則將當前域設定為下一個匹配值，將比當前域低的所有域設定為最小值，遞回調度本演算法
if (nextValue != value) {
calendar.set(field, nextValue);
reset(calendar, lowerOrders);
}
// 下一個匹配值就是當前值，則匹配通過，如果當前域是月則演算法結束，否則繼續處理下一個更高的域，
return nextValue;
}
Quartz
在這里還是使用Spring Boot 集成Quartz；
引入依賴：
<dependency>
<groupId>org.quartz-scheduler</groupId>
<artifactId>quartz</artifactId>
<version>2.3.0</version>
</dependency>
測驗的job業務處理類：
/**
* @className: QuartzJob
* @description: 業務邏輯處理類
* @author: charon
* @create: 2021-10-11 14:32
*/
public class QuartzJob implements Job {
@Override
public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
System.out.println("執行quartz定時器開始：" + new Date());
// 模擬業務邏輯
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("執行quartz定時器結束：" + new Date());
}
}
實體化Job，將任務觸發器加入任務調度中：
/**
* @className: QuartzConfig
* @description: scheduler的啟動、結束等控制類
* @author: charon
* @create: 2021-10-11 14:38
*/
@Configuration
public class QuartzConfig {
@Autowired
private Scheduler scheduler;
/**
* 開始定時器
*/
public void startJob() throws SchedulerException {
// 通過JobBuilder構建JobDetail實體，JobDetail規定只能是實作Job介面的實體
// JobDetail 是具體Job實體
JobDetail jobDetail = JobBuilder.newJob(QuartzJob.class).withIdentity("job", "group").build();
// 基于運算式構建觸發器 每5秒種執行一次
CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule("0/5 * * * * ?");
// CronTrigger運算式觸發器 繼承于Trigger
// TriggerBuilder 用于構建觸發器實體
CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity("job1", "group1")
.withSchedule(cronScheduleBuilder).build();
scheduler.scheduleJob(jobDetail, cronTrigger);
}
/**
* 洗掉某個任務
*
* @param name job的名稱
* @param group job的分組
* @throws SchedulerException
*/
public void deleteJob(String name, String group) throws SchedulerException {
JobKey jobKey = new JobKey(name, group);
if (scheduler.checkExists(jobKey)){
scheduler.deleteJob(jobKey);
}
}
}
測驗類（spring容器初始化完成后執行）：
/**
* @className: QuartzTest
* @description: 測驗quartz的定時器
* @author: charon
* @create: 2021-10-11 10:33
*/
@Configuration
public class QuartzTest implements ApplicationListener<ContextRefreshedEvent> {
@Autowired
private QuartzConfig quartzConfig;
/**
* 監聽初始化quartz
* @param event
*/
@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
System.out.println("容器初始化完成");
try {
quartzConfig.startJob();
} catch (SchedulerException e) {
e.printStackTrace();
}
}
}
容器初始化完成
2021-10-11 15:02:46.947 INFO 19628 --- [ main] o.s.b.w.embedded.tomcat.TomcatWebServer : Tomcat started on port(s): 7010 (http) with context path ''
2021-10-11 15:02:49.558 INFO 19628 --- [ main] c.c.ScheduleApplication : Started ScheduleApplication in 10.734 seconds (JVM running for 11.644)
執行quartz定時器開始：Mon Oct 11 15:02:50 CST 2021
執行quartz定時器結束：Mon Oct 11 15:02:52 CST 2021
執行quartz定時器開始：Mon Oct 11 15:02:55 CST 2021
執行quartz定時器結束：Mon Oct 11 15:02:57 CST 2021
執行quartz定時器開始：Mon Oct 11 15:03:00 CST 2021
執行quartz定時器結束：Mon Oct 11 15:03:02 CST 2021
參考文章：
https://blog.csdn.net/liuxiao723846/article/details/90546619
https://www.cnblogs.com/WangJinYang/p/15160354.html
https://blog.csdn.net/andy2019/article/details/79436869
https://blog.csdn.net/weixin_42522400/article/details/112783846
本文著作權歸Charon和博客園共有，原創文章，歡迎轉載，但未經作者同意必須保留此段宣告，且在文章頁面明顯位置給出原文連接，否則保留追究法律責任的權利，轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/335055.html
標籤：Java
上一篇：反射解決微信開發加解密illegal key size，不需要修改JDK jar包
下一篇：改變世界的 5 位程式員！