在我們編程過程中如果需要執(zhí)行一些簡單的定時任務(wù),無須做復(fù)雜的控制,我們可以考慮使用 JDK 中的 Timer 定時任務(wù)來實現(xiàn)。下面 LZ 就其原理、實例以及 Timer 缺陷三個方面來解析 Java Timer 定時器。
在 Java 中一個完整定時任務(wù)需要由 Timer、TimerTask 兩個類來配合完成。 API 中是這樣定義他們的,Timer:一種工具,線程用其安排以后在后臺線程中執(zhí)行的任務(wù)??砂才湃蝿?wù)執(zhí)行一次,或者定期重復(fù)執(zhí)行。由TimerTask:Timer 安排為一次執(zhí)行或重復(fù)執(zhí)行的任務(wù)。我們可以這樣理解 Timer 是一種定時器工具,用來在一個后臺線程計劃執(zhí)行指定任務(wù),而 TimerTask 一個抽象類,它的子類代表一個可以被 Timer 計劃的任務(wù)。
在工具類 Timer 中,提供了四個構(gòu)造方法,每個構(gòu)造方法都啟動了計時器線程,同時 Timer 類可以保證多個線程可以共享單個 Timer 對象而無需進行外部同步,所以 Timer 類是線程安全的。但是由于每一個 Timer 對象對應(yīng)的是單個后臺線程,用于順序執(zhí)行所有的計時器任務(wù),一般情況下我們的線程任務(wù)執(zhí)行所消耗的時間應(yīng)該非常短,但是由于特殊情況導(dǎo)致某個定時器任務(wù)執(zhí)行的時間太長,那么他就會“獨占”計時器的任務(wù)執(zhí)行線程,其后的所有線程都必須等待它執(zhí)行完,這就會延遲后續(xù)任務(wù)的執(zhí)行,使這些任務(wù)堆積在一起,具體情況我們后面分析。
當程序初始化完成 Timer 后,定時任務(wù)就會按照我們設(shè)定的時間去執(zhí)行, Timer 提供了 schedule 方法,該方法有多中重載方式來適應(yīng)不同的情況,如下:
schedule(TimerTask task, Date time):安排在指定的時間執(zhí)行指定的任務(wù)。
schedule(TimerTask task, Date firstTime, long period) :安排指定的任務(wù)在指定的時間開始進行重復(fù)的固定延遲執(zhí)行。
schedule(TimerTask task, long delay) :安排在指定延遲后執(zhí)行指定的任務(wù)。
schedule(TimerTask task, long delay, long period) :安排指定的任務(wù)從指定的延遲后開始進行重復(fù)的固定延遲執(zhí)行。
同時也重載了 scheduleAtFixedRate 方法,scheduleAtFixedRate 方法與 schedule 相同,只不過他們的側(cè)重點不同,區(qū)別后面分析。
scheduleAtFixedRate(TimerTask task, Date firstTime, long period):安排指定的任務(wù)在指定的時間開始進行重復(fù)的固定速率執(zhí)行。
scheduleAtFixedRate(TimerTask task, long delay, long period):安排指定的任務(wù)在指定的延遲后開始進行重復(fù)的固定速率執(zhí)行。
TimerTask 類是一個抽象類,由 Timer 安排為一次執(zhí)行或重復(fù)執(zhí)行的任務(wù)。它有一個抽象方法 run() 方法,該方法用于執(zhí)行相應(yīng)計時器任務(wù)要執(zhí)行的操作。因此每一個具體的任務(wù)類都必須繼承 TimerTask,然后重寫 run() 方法。
另外它還有兩個非抽象的方法:
boolean cancel():取消此計時器任務(wù)。
long scheduledExecutionTime():返回此任務(wù)最近實際執(zhí)行的安排執(zhí)行時間。
public class TimerTest01 {
Timer timer;
public TimerTest01(int time){
timer = new Timer();
timer.schedule(new TimerTaskTest01(), time * 1000);
}
public static void main(String[] args) {
System.out.println("timer begin....");
new TimerTest01(3);
}
}
public class TimerTaskTest01 extends TimerTask{
public void run() {
System.out.println("Time's up!!!!");
}
}
運行結(jié)果:
首先打?。簍imer begin....
3秒后打?。篢ime's up!!!!
public class TimerTest02 {
Timer timer;
public TimerTest02(){
Date time = getTime();
System.out.println("指定時間time=" + time);
timer = new Timer();
timer.schedule(new TimerTaskTest02(), time);
}
public Date getTime(){
Calendar calendar = Calendar.getInstance();
calendar.set(Calendar.HOUR_OF_DAY, 11);
calendar.set(Calendar.MINUTE, 39);
calendar.set(Calendar.SECOND, 00);
Date time = calendar.getTime();
return time;
}
public static void main(String[] args) {
new TimerTest02();
}
}
public class TimerTaskTest02 extends TimerTask{
@Override
public void run() {
System.out.println("指定時間執(zhí)行線程任務(wù)...");
}
}
當時間到達 11:39:00 時就會執(zhí)行該線程任務(wù),當然大于該時間也會執(zhí)行?。?zhí)行結(jié)果為:
指定時間 time=Tue Jun 10 11:39:00 CST 2014
指定時間執(zhí)行線程任務(wù)...
public class TimerTest03 {
Timer timer;
public TimerTest03(){
timer = new Timer();
timer.schedule(new TimerTaskTest03(), 1000, 2000);
}
public static void main(String[] args) {
new TimerTest03();
}
}
public class TimerTaskTest03 extends TimerTask{
@Override
public void run() {
Date date = new Date(this.scheduledExecutionTime());
System.out.println("本次執(zhí)行該線程的時間為:" + date);
}
}
運行結(jié)果:
本次執(zhí)行該線程的時間為:Tue Jun 10 21:19:47 CST 2014
本次執(zhí)行該線程的時間為:Tue Jun 10 21:19:49 CST 2014
本次執(zhí)行該線程的時間為:Tue Jun 10 21:19:51 CST 2014
本次執(zhí)行該線程的時間為:Tue Jun 10 21:19:53 CST 2014
本次執(zhí)行該線程的時間為:Tue Jun 10 21:19:55 CST 2014
本次執(zhí)行該線程的時間為:Tue Jun 10 21:19:57 CST 2014
.................
對于這個線程任務(wù),如果我們不將該任務(wù)停止,他會一直運行下去。
對于上面三個實例,LZ 只是簡單的演示了一下,同時也沒有講解 scheduleAtFixedRate 方法的例子,其實該方法與 schedule 方法一樣!
對于這兩個方法而言,如果指定的計劃執(zhí)行時間 scheduledExecutionTime<= systemCurrentTime,則 task 會被立即執(zhí)行。scheduledExecutionTime 不會因為某一個 task 的過度執(zhí)行而改變。
這兩個方法與上面兩個就有點兒不同的,前面提過 Timer 的計時器任務(wù)會因為前一個任務(wù)執(zhí)行時間較長而延時。在這兩個方法中,每一次執(zhí)行的 task 的計劃時間會隨著前一個 task 的實際時間而發(fā)生改變,也就是 scheduledExecutionTime(n+1)=realExecutionTime(n)+periodTime。也就是說如果第 n 個 task 由于某種情況導(dǎo)致這次的執(zhí)行時間過程,最后導(dǎo)致 systemCurrentTime>= scheduledExecutionTime(n+1),這是第 n+1 個 task 并不會因為到時了而執(zhí)行,他會等待第 n 個 task 執(zhí)行完之后再執(zhí)行,那么這樣勢必會導(dǎo)致 n+2 個的執(zhí)行實現(xiàn) scheduledExecutionTime 放生改變即 scheduledExecutionTime(n+2) = realExecutionTime(n+1)+periodTime。所以這兩個方法更加注重保存間隔時間的穩(wěn)定。
在前面也提過 scheduleAtFixedRate 與 schedule 方法的側(cè)重點不同,schedule 方法側(cè)重保存間隔時間的穩(wěn)定,而 scheduleAtFixedRate 方法更加側(cè)重于保持執(zhí)行頻率的穩(wěn)定。為什么這么說,原因如下。在 schedule 方法中會因為前一個任務(wù)的延遲而導(dǎo)致其后面的定時任務(wù)延時,而 scheduleAtFixedRate 方法則不會,如果第 n 個 task 執(zhí)行時間過長導(dǎo)致 systemCurrentTime>= scheduledExecutionTime(n+1),則不會做任何等待他會立即執(zhí)行第 n+1 個 task,所以 scheduleAtFixedRate 方法執(zhí)行時間的計算方法不同于 schedule,而是 scheduledExecutionTime(n)=firstExecuteTime +n*periodTime,該計算方法永遠保持不變。所以 scheduleAtFixedRate 更加側(cè)重于保持執(zhí)行頻率的穩(wěn)定。
Timer 計時器可以定時(指定時間執(zhí)行任務(wù))、延遲(延遲 5 秒執(zhí)行任務(wù))、周期性地執(zhí)行任務(wù)(每隔個 1 秒執(zhí)行任務(wù)),但是,Timer 存在一些缺陷。首先 Timer 對調(diào)度的支持是基于絕對時間的,而不是相對時間,所以它對系統(tǒng)時間的改變非常敏感。其次 Timer 線程是不會捕獲異常的,如果 TimerTask 拋出的了未檢查異常則會導(dǎo)致 Timer 線程終止,同時 Timer 也不會重新恢復(fù)線程的執(zhí)行,他會錯誤的認為整個 Timer 線程都會取消。同時,已經(jīng)被安排單尚未執(zhí)行的 TimerTask 也不會再執(zhí)行了,新的任務(wù)也不能被調(diào)度。故如果 TimerTask 拋出未檢查的異常,Timer 將會產(chǎn)生無法預(yù)料的行為。
前面 Timer 在執(zhí)行定時任務(wù)時只會創(chuàng)建一個線程任務(wù),如果存在多個線程,若其中某個線程因為某種原因而導(dǎo)致線程任務(wù)執(zhí)行時間過長,超過了兩個任務(wù)的間隔時間,會發(fā)生一些缺陷:
public class TimerTest04 {
private Timer timer;
public long start;
public TimerTest04(){
this.timer = new Timer();
start = System.currentTimeMillis();
}
public void timerOne(){
timer.schedule(new TimerTask() {
public void run() {
System.out.println("timerOne invoked ,the time:" + (System.currentTimeMillis() - start));
try {
Thread.sleep(4000); //線程休眠3000
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, 1000);
}
public void timerTwo(){
timer.schedule(new TimerTask() {
public void run() {
System.out.println("timerOne invoked ,the time:" + (System.currentTimeMillis() - start));
}
}, 3000);
}
public static void main(String[] args) throws Exception {
TimerTest04 test = new TimerTest04();
test.timerOne();
test.timerTwo();
}
}
按照我們正常思路,timerTwo 應(yīng)該是在 3s 后執(zhí)行,其結(jié)果應(yīng)該是:
timerOne invoked ,the time:1001
timerOne invoked ,the time:3001
但是事與愿違,timerOne 由于 sleep(4000),休眠了 4S,同時 Timer 內(nèi)部是一個線程,導(dǎo)致 timeOne 所需的時間超過了間隔時間,結(jié)果:
timerOne invoked ,the time:1000
timerOne invoked ,the time:5000
如果 TimerTask 拋出 RuntimeException,Timer 會終止所有任務(wù)的運行。如下:
public class TimerTest04 {
private Timer timer;
public TimerTest04(){
this.timer = new Timer();
}
public void timerOne(){
timer.schedule(new TimerTask() {
public void run() {
throw new RuntimeException();
}
}, 1000);
}
public void timerTwo(){
timer.schedule(new TimerTask() {
public void run() {
System.out.println("我會不會執(zhí)行呢??");
}
}, 1000);
}
public static void main(String[] args) {
TimerTest04 test = new TimerTest04();
test.timerOne();
test.timerTwo();
}
}
運行結(jié)果:timerOne 拋出異常,導(dǎo)致 timerTwo 任務(wù)終止。
Exception in thread "Timer-0" java.lang.RuntimeException
at com.chenssy.timer.TimerTest04$1.run(TimerTest04.java:25)
at java.util.TimerThread.mainLoop(Timer.java:555)
at java.util.TimerThread.run(Timer.java:505)
對于 Timer 的缺陷,我們可以考慮 ScheduledThreadPoolExecutor 來替代。Timer 是基于絕對時間的,對系統(tǒng)時間比較敏感,而 ScheduledThreadPoolExecutor 則是基于相對時間;Timer 是內(nèi)部是單一線程,而 ScheduledThreadPoolExecutor 內(nèi)部是個線程池,所以可以支持多個任務(wù)并發(fā)執(zhí)行。
public class ScheduledExecutorTest {
private ScheduledExecutorService scheduExec;
public long start;
ScheduledExecutorTest(){
this.scheduExec = Executors.newScheduledThreadPool(2);
this.start = System.currentTimeMillis();
}
public void timerOne(){
scheduExec.schedule(new Runnable() {
public void run() {
System.out.println("timerOne,the time:" + (System.currentTimeMillis() - start));
try {
Thread.sleep(4000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},1000,TimeUnit.MILLISECONDS);
}
public void timerTwo(){
scheduExec.schedule(new Runnable() {
public void run() {
System.out.println("timerTwo,the time:" + (System.currentTimeMillis() - start));
}
},2000,TimeUnit.MILLISECONDS);
}
public static void main(String[] args) {
ScheduledExecutorTest test = new ScheduledExecutorTest();
test.timerOne();
test.timerTwo();
}
}
運行結(jié)果:
timerOne,the time:1003
timerTwo,the time:2005
public class ScheduledExecutorTest {
private ScheduledExecutorService scheduExec;
public long start;
ScheduledExecutorTest(){
this.scheduExec = Executors.newScheduledThreadPool(2);
this.start = System.currentTimeMillis();
}
public void timerOne(){
scheduExec.schedule(new Runnable() {
public void run() {
throw new RuntimeException();
}
},1000,TimeUnit.MILLISECONDS);
}
public void timerTwo(){
scheduExec.scheduleAtFixedRate(new Runnable() {
public void run() {
System.out.println("timerTwo invoked .....");
}
},2000,500,TimeUnit.MILLISECONDS);
}
public static void main(String[] args) {
ScheduledExecutorTest test = new ScheduledExecutorTest();
test.timerOne();
test.timerTwo();
}
}
運行結(jié)果:
timerTwo invoked .....
timerTwo invoked .....
timerTwo invoked .....
timerTwo invoked .....
timerTwo invoked .....
timerTwo invoked .....
timerTwo invoked .....
timerTwo invoked .....
timerTwo invoked .....
........................
參考文獻:http://blog.csdn.net/lmj623565791/article/details/27109467