java定時任務(wù)目前主要有三種：

1. Java自帶的java.util.Timer類，這個類允許你調(diào)度一個java.util.TimerTask任務(wù)。使用這種方式可以讓你的程序按照某一個頻度執(zhí)行，但不能在指定時間運行；而且作業(yè)類需要集成java.util.TimerTask，一般用的較少。
2. Spring3.0以后自帶的task，即：spring schedule，可以將它看成一個輕量級的Quartz，而且使用起來比Quartz簡單許多。
3. Quartz，這是一個功能比較強大的的調(diào)度器，可以讓你的程序在指定時間執(zhí)行，也可以按照某一個頻度執(zhí)行；代碼稍顯復雜。

定時器算法

1.小頂堆

堆，實際上是一種經(jīng)過排序的完全二叉樹，其中任一非終端節(jié)點的數(shù)據(jù)值均不大于（或不小于）其左子節(jié)點和右子節(jié)點的值。

堆又分為兩種，最大堆、最小堆。
– 最大堆： 任一非葉子節(jié)點的值均大于其左子節(jié)點和右子節(jié)點的值。根節(jié)點的值是最大的。
– 最小堆： 任一非葉子節(jié)點的值均小于其左子節(jié)點和右子節(jié)點的值。根節(jié)點的值是最小的。

小頂堆的實現(xiàn)方式

由于堆是一種經(jīng)過排序的完全二叉樹，因此在構(gòu)建的時候需要對其新插入的節(jié)點進行一些操作以使其符合堆的性質(zhì)。這種操作就叫上浮與下沉。

• 上?。簩斍肮?jié)點與其父節(jié)點相比，如果當前節(jié)點的值比父節(jié)點小，就把當前節(jié)點與父節(jié)點交換，然后繼續(xù)前面的交換，直到當前節(jié)點比父節(jié)點的值大為止。上浮就是將符合條件的節(jié)點往上移的過程。
• 下沉：將當前節(jié)點與其左、右子節(jié)點相比，如果當前節(jié)點的值比其中一個或兩個子節(jié)點的值大，就把當前節(jié)點與兩個子節(jié)點種比較小的那個交換，，然后繼續(xù)前面的比較，直到當前節(jié)點的值比兩個子節(jié)點的值都小為止。下沉就是將符合條件的節(jié)點往下移的過程。

2.時間輪算法

見名知意，時間輪算法的數(shù)據(jù)結(jié)構(gòu)類似于鐘表上的數(shù)據(jù)指針，時間輪用環(huán)形數(shù)組的方式實現(xiàn)，數(shù)組中的每個元素都可以稱之為槽（和redis集群的槽一樣稱呼）。槽的內(nèi)部用雙向鏈表存儲著待執(zhí)行的任務(wù)，添加和刪除鏈表的操作時間復雜度為O（1），槽位本身也指代時間精度，比如一秒掃一個槽，那么這個時間輪的最高精度就是1秒。

當有一個延遲任務(wù)要插入時間輪時，首先計算其延遲時間與單位時間的余值，從指針指向的當前槽位移動余值的個數(shù)槽位，就是該延遲任務(wù)需要被放入的槽位。

舉個例子，時間輪有8個槽位，編號為 0 ~ 7 。指針當前指向槽位 2 。新增一個延遲時間為 4 秒的延遲任務(wù)，4 % 8 = 4，因此該任務(wù)會被插入 4 2 = 6，也就是槽位6的延遲任務(wù)隊列。

時間槽位的實現(xiàn)方式

時間輪的槽位實現(xiàn)可以采用循環(huán)數(shù)組的方式達成，也就是讓指針在越過數(shù)組的邊界后重新回到起始下標。概括來說，可以將時間輪的算法描述為:

用隊列來存儲延遲任務(wù)，同一個隊列中的任務(wù)，其延遲時間相同。用循環(huán)數(shù)組的方式來存儲元素，數(shù)組中的每一個元素都指向一個延遲任務(wù)隊列。有一個當前指針指向數(shù)組中的某一個槽位，每間隔一個單位時間，指針就移動到下一個槽位。被指針指向的槽位的延遲隊列，其中的延遲任務(wù)全部被觸發(fā)。在時間輪中新增一個延遲任務(wù)，將其延遲時間除以單位時間得到的余值，從當前指針開始，移動余值對應個數(shù)的槽位，就是延遲任務(wù)被放入的槽位。

基于這樣的數(shù)據(jù)結(jié)構(gòu)，插入一個延遲任務(wù)的時間復雜度就下降到 O(1) 。而當指針指向到一個槽位時，該槽位連接的延遲任務(wù)隊列中的延遲任務(wù)全部被觸發(fā)。

延遲任務(wù)的觸發(fā)和執(zhí)行不應該影響指針向后移動的時間精確性。因此一般情況下，用于移動指針的線程只負責任務(wù)的觸發(fā)，任務(wù)的執(zhí)行交由其他的線程來完成。比如，可以將槽位上的延遲任務(wù)隊列放入到額外的線程池中執(zhí)行，然后在槽位上新建一個空白的新的延遲任務(wù)隊列用于后續(xù)任務(wù)的添加。

代碼實現(xiàn)

Timer

/**
* @className: TimerTest
* @description: 測試java.util.Timer的定時器實現(xiàn)
* @author: charon
* @create: 2021-10-10 10:35
*/
public class TimerTest {
public static void main(String[] args) {
Timer timer = new Timer();
// 延遲1s執(zhí)行任務(wù)
timer.schedule(new TimerTask() {
@Override
public void run() {
System.out.println("延遲1s執(zhí)行的任務(wù)" new Date());
}
},1000);
// 延遲3s執(zhí)行任務(wù)，每隔5s執(zhí)行一次
timer.schedule(new TimerTask() {
@Override
public void run() {
System.out.println("延遲3s每隔5s執(zhí)行一次的任務(wù)" new Date());
}
},3000,5000);
// try {
// Thread.sleep(5000);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// timer.cancel();
// System.out.println("任務(wù)執(zhí)行完畢" new Date());
}
}

延遲1s執(zhí)行的任務(wù)Sun Oct 10 14:34:13 CST 2021
延遲3s執(zhí)行的任務(wù)Sun Oct 10 14:34:15 CST 2021
延遲3s執(zhí)行的任務(wù)Sun Oct 10 14:34:20 CST 2021
延遲3s執(zhí)行的任務(wù)Sun Oct 10 14:34:25 CST 2021
延遲3s執(zhí)行的任務(wù)Sun Oct 10 14:34:30 CST 2021

Timer的實現(xiàn)方式比較簡單，其內(nèi)部有兩個主要的屬性：

/**
* 用于存放定時任務(wù)TimeTask的列表
*/
private final TaskQueue queue = new TaskQueue();
/**
* 用于執(zhí)行定時任務(wù)的線程
*/
private final TimerThread thread = new TimerThread(queue);

TimerTask是一個實現(xiàn)了Runnable接口的抽象類。其run（）方法用于提供具體的延時任務(wù)邏輯。

TaskQueue內(nèi)部采用的是小頂堆的算法實現(xiàn)。根據(jù)任務(wù)的觸發(fā)時間采用死循環(huán)的方式進行排序，將執(zhí)行時間最小的任務(wù)放在前面。

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. 由于執(zhí)行任務(wù)的線程只有一個，所以如果某個任務(wù)的執(zhí)行時間過長，那么將破壞其他任務(wù)的定時精確性。如一個任務(wù)每1秒執(zhí)行一次，而另一個任務(wù)執(zhí)行一次需要5秒，那么如果是固定速率的任務(wù)，那么會在5秒這個任務(wù)執(zhí)行完成后連續(xù)執(zhí)行5次，而固定延遲的任務(wù)將丟失4次執(zhí)行。
2. 如果執(zhí)行某個任務(wù)過程中拋出了異常，那么執(zhí)行線程將會終止，導致Timer中的其他任務(wù)也不能再執(zhí)行。
3. Timer使用的是絕對時間，即是某個時間點，所以它執(zhí)行依賴系統(tǒng)的時間，如果系統(tǒng)時間修改了的話，將導致任務(wù)可能不會被執(zhí)行。

由于Timer存在上面說的這些缺陷，在JDK1.5中，我們可以使用ScheduledThreadPoolExecutor來代替它，使用Executors.newScheduledThreadPool工廠方法或使用ScheduledThreadPoolExecutor的構(gòu)造函數(shù)來創(chuàng)建定時任務(wù)，它是基于線程池的實現(xiàn)，不會存在Timer存在的上述問題，當線程數(shù)量為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注解的方式來實現(xiàn)：

/**
* 在spring boot的啟動類上面添加 @EnableScheduling 注解
*/
@SpringBootApplication
@EnableScheduling
public class ScheduleApplication {
public static void main(String[] args) {
SpringApplication.run(ScheduleApplication.class,args);
}
}

新創(chuàng)建一個類，用來實現(xiàn)定時任務(wù)，這個類要注冊成為Bean才行。

/**
* @className: ScheduleTest
* @description: 測試schedule的執(zhí)行器
* @author: charon
* @create: 2021-10-10 19:04
*/
@Component
public class ScheduleTest {
/**
* corn表達式：秒、分、時、日、月、星期
* 值可以是數(shù)字，也可以是以下符號：
* *：所有值都匹配 示例： 0 0 * * * *：每小時（當秒和分都為0的時候）
* ?：只能用在日期和星期兩個表達式中 示例： 0 0 12 * * ? 每天中午12點觸發(fā)
* ,：或者 示例：0 0 9,13 * * *：每天的9點和13點
* /：增量值 示例: */10 * * * * *：每10秒
* -：區(qū)間 示例： 0 0/30 9-17 * * ? ： 朝九晚五工作時間內(nèi)每半小時
*/
@Scheduled(cron="0 * * * * *")
public void doSomething(){
System.out.println("測試schedule的定時器，當秒為0的時候執(zhí)行一次：" new Date());
}
}

測試schedule的定時器，當秒為0的時候執(zhí)行一次：Sun Oct 10 19:18:00 CST 2021
測試schedule的定時器，當秒為0的時候執(zhí)行一次：Sun Oct 10 19:19:00 CST 2021
測試schedule的定時器，當秒為0的時候執(zhí)行一次：Sun Oct 10 19:20:00 CST 2021

@Scheduled注解的另外兩個重要屬性：fixedRate和fixedDelay

• fixedDelay：上一個任務(wù)結(jié)束后多久執(zhí)行下一個任務(wù)
• fixedRate：上一個任務(wù)的開始到下一個任務(wù)開始時間的間隔

/**
* 測試fixedRate，每2s執(zhí)行一次
* @throws Exception
*/
@Scheduled(fixedRate = 2000)
public void fixedRate() throws Exception {
System.out.println("fixedRate開始執(zhí)行時間:" new Date(System.currentTimeMillis()));
//休眠1秒
Thread.sleep(1000);
System.out.println("fixedRate執(zhí)行結(jié)束時間:" new Date(System.currentTimeMillis()));
}

fixedRate開始執(zhí)行時間:Sun Oct 10 19:59:05 CST 2021
fixedRate執(zhí)行結(jié)束時間:Sun Oct 10 19:59:06 CST 2021
fixedRate開始執(zhí)行時間:Sun Oct 10 19:59:07 CST 2021
fixedRate執(zhí)行結(jié)束時間:Sun Oct 10 19:59:08 CST 2021
fixedRate開始執(zhí)行時間:Sun Oct 10 19:59:09 CST 2021
fixedRate執(zhí)行結(jié)束時間:Sun Oct 10 19:59:10 CST 2021

/**
* 等上一次執(zhí)行完等待1s執(zhí)行
* @throws Exception
*/
@Scheduled(fixedDelay = 1000)
public void fixedDelay() throws Exception {
System.out.println("fixedDelay開始執(zhí)行時間:" new Date(System.currentTimeMillis()));
//休眠兩秒
Thread.sleep(1000 * 2);
System.out.println("fixedDelay執(zhí)行結(jié)束時間:" new Date(System.currentTimeMillis()));
}

fixedDelay執(zhí)行結(jié)束時間:Sun Oct 10 20:07:23 CST 2021
fixedDelay開始執(zhí)行時間:Sun Oct 10 20:07:24 CST 2021
fixedDelay執(zhí)行結(jié)束時間:Sun Oct 10 20:07:26 CST 2021
fixedDelay開始執(zhí)行時間:Sun Oct 10 20:07:27 CST 2021
fixedDelay執(zhí)行結(jié)束時間:Sun Oct 10 20:07:29 CST 2021

如果是強調(diào)任務(wù)間隔的定時任務(wù)，建議使用fixedRate和fixedDelay，如果是強調(diào)任務(wù)在某時某分某刻執(zhí)行的定時任務(wù)，建議使用cron表達式。

Spring Schedule的Corn是使用的時間輪算法（分層時間輪,每個時間粒度對應一個時間輪，多個時間輪時間進行級聯(lián)協(xié)調(diào)）。

在CronSequenceGenerator.java這個類中，對每個CornTask都維護了一下7個Bitset（使用位數(shù)組而不用list，set之類的數(shù)據(jù)結(jié)構(gòu)，一方面是因為空間效率，更重要的是接下來的操作主要是判斷某個值是否匹配和從某個值開始找最近的下一個能夠匹配的值）

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);

然后根據(jù)配置的corn值計算這個任務(wù)對應的值計算每個bit的值。如我這里配置的每分鐘執(zhí)行一次的CornTask的結(jié)果如下：

CronSequenceGenerator負責解析用戶配置的Cron表達式，并提供next方法，根據(jù)給定的時間獲取符合cron表達式規(guī)則的最近的下一個時間。CronTrigger實現(xiàn)Trigger的nextExecutionTime方法，根據(jù)定時任務(wù)執(zhí)行的上下文環(huán)境(最近調(diào)度時間和最近完成時間)決定查找下一次執(zhí)行時間的左邊界，之后調(diào)用CronSequenceGenerator的next方法從左邊界開始找下一次的執(zhí)行時間。

CronSequenceGenerator的doNext算法從指定時間開始(包括指定時間)查找符合cron表達式規(guī)則下一個匹配的時間。如圖3-4所示，其整體思路是：沿著秒→分→時→日→月逐步檢查指定時間的值。如果所有域上的值都已經(jīng)符合規(guī)則那么指定時間符合cron表達式，算法結(jié)束。否則，必然有某個域的值不符合規(guī)則，調(diào)整該域到下一個符合規(guī)則的值(可能調(diào)整更高的域)，并將較低域的值調(diào)整到最小值，然后從秒開始重新檢查和調(diào)整。

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 = bits.nextSetBit(value);
// 下一個匹配值是－1，則將對更高的域做加1操作，從0開始查找下一個匹配值,將當前域設(shè)置為下一個匹配值，重置比當前域低的所有域設(shè)置為最小值，遞歸調(diào)度本算法。
if (nextValue == -1) {
calendar.add(nextField, 1);
reset(calendar, Collections.singletonList(field));
nextValue = bits.nextSetBit(0);
}
// 下一個匹配值不是當前值但也不是－1，則將當前域設(shè)置為下一個匹配值，將比當前域低的所有域設(shè)置為最小值，遞歸調(diào)度本算法
if (nextValue != value) {
calendar.set(field, nextValue);
reset(calendar, lowerOrders);
}
// 下一個匹配值就是當前值，則匹配通過，如果當前域是月則算法結(jié)束，否則繼續(xù)處理下一個更高的域。
return nextValue;
}

Quartz

在這里還是使用Spring Boot 集成Quartz；

引入依賴：

<dependency>
<groupId>org.quartz-scheduler</groupId>
<artifactId>quartz</artifactId>
<version>2.3.0</version>
</dependency>

測試的job業(yè)務(wù)處理類：

/**
* @className: QuartzJob
* @description: 業(yè)務(wù)邏輯處理類
* @author: charon
* @create: 2021-10-11 14:32
*/
public class QuartzJob implements Job {
@Override
public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
System.out.println("執(zhí)行quartz定時器開始：" new Date());
// 模擬業(yè)務(wù)邏輯
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("執(zhí)行quartz定時器結(jié)束：" new Date());
}
}

實例化Job，將任務(wù)觸發(fā)器加入任務(wù)調(diào)度中：

/**
* @className: QuartzConfig
* @description: scheduler的啟動、結(jié)束等控制類
* @author: charon
* @create: 2021-10-11 14:38
*/
@Configuration
public class QuartzConfig {

@Autowired
private Scheduler scheduler;

/**
* 開始定時器
*/
public void startJob() throws SchedulerException {
// 通過JobBuilder構(gòu)建JobDetail實例，JobDetail規(guī)定只能是實現(xiàn)Job接口的實例
// JobDetail 是具體Job實例
JobDetail jobDetail = JobBuilder.newJob(QuartzJob.class).withIdentity("job", "group").build();
// 基于表達式構(gòu)建觸發(fā)器 每5秒種執(zhí)行一次
CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule("0/5 * * * * ?");
// CronTrigger表達式觸發(fā)器 繼承于Trigger
// TriggerBuilder 用于構(gòu)建觸發(fā)器實例
CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity("job1", "group1")
.withSchedule(cronScheduleBuilder).build();
scheduler.scheduleJob(jobDetail, cronTrigger);
}

/**
* 刪除某個任務(wù)
*
* @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容器初始化完成后執(zhí)行）：

/**
* @className: QuartzTest
* @description: 測試quartz的定時器
* @author: charon
* @create: 2021-10-11 10:33
*/
@Configuration
public class QuartzTest implements ApplicationListener<ContextRefreshedEvent> {

@Autowired
private QuartzConfig quartzConfig;

/**
* 監(jiān)聽初始化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)
執(zhí)行quartz定時器開始：Mon Oct 11 15:02:50 CST 2021
執(zhí)行quartz定時器結(jié)束：Mon Oct 11 15:02:52 CST 2021
執(zhí)行quartz定時器開始：Mon Oct 11 15:02:55 CST 2021
執(zhí)行quartz定時器結(jié)束：Mon Oct 11 15:02:57 CST 2021
執(zhí)行quartz定時器開始：Mon Oct 11 15:03:00 CST 2021
執(zhí)行quartz定時器結(jié)束：Mon Oct 11 15:03:02 CST 2021

作者 | pluto_charon

來源 | cnblogs.com/pluto-charon/p/15451928.html