詳解java定時任務

在我們編程過程中如果需要執行一些簡單的定時任務，無須做複雜的控制，我們可以考慮使用JDK中的Timer定時任務來實現。下面LZ就其原理、實例以及Timer缺陷三個方面來解析java Timer定時器。

一、簡介

在java中一個完整定時任務需要由Timer、TimerTask兩個類來配合完成。 API中是這樣定義他們的，Timer：一種工具，線程用其安排以後在後臺線程中執行的任務。可安排任務執行一次，或者定期重複執行。由TimerTask：Timer 安排爲一次執行或重複執行的任務。我們可以這樣理解Timer是一種定時器工具，用來在一個後臺線程計劃執行指定任務，而TimerTask一個抽象類，它的子類代表一個可以被Timer計劃的任務。

Timer類

在工具類Timer中，提供了四個構造方法，每個構造方法都啓動了計時器線程，同時Timer類可以保證多個線程可以共享單個Timer對象而無需進行外部同步，所以Timer類是線程安全的。但是由於每一個Timer對象對應的是單個後臺線程，用於順序執行所有的計時器任務，一般情況下我們的線程任務執行所消耗的時間應該非常短，但是由於特殊情況導致某個定時器任務執行的時間太長，那麼他就會“獨佔”計時器的任務執行線程，其後的所有線程都必須等待它執行完，這就會延遲後續任務的執行，使這些任務堆積在一起，具體情況我們後面分析。

當程序初始化完成Timer後，定時任務就會按照我們設定的時間去執行，Timer提供了schedule方法，該方法有多中重載方式來適應不同的情況，如下：

schedule(TimerTask task, Date time)：安排在指定的時間執行指定的任務。

schedule(TimerTask task, Date firstTime, long period) ：安排指定的任務在指定的時間開始進行重複的固定延遲執行。

schedule(TimerTask task, long delay) ：安排在指定延遲後執行指定的任務。

schedule(TimerTask task, long delay, long period) ：安排指定的任務從指定的延遲後開始進行重複的固定延遲執行。

同時也重載了scheduleAtFixedRate方法，scheduleAtFixedRate方法與schedule相同，只不過他們的側重點不同，區別後面分析。

scheduleAtFixedRate(TimerTask task, Date firstTime, long period)：安排指定的任務在指定的時間開始進行重複的固定速率執行。

scheduleAtFixedRate(TimerTask task, long delay, long period)：安排指定的任務在指定的延遲後開始進行重複的固定速率執行。

TimerTask

TimerTask類是一個抽象類，由Timer 安排爲一次執行或重複執行的任務。它有一個抽象方法run()方法，該方法用於執行相應計時器任務要執行的操作。因此每一個具體的任務類都必須繼承TimerTask，然後重寫run()方法。

另外它還有兩個非抽象的方法：

boolean cancel()：取消此計時器任務。

long scheduledExecutionTime()：返回此任務最近實際執行的安排執行時間。

二、實例

2.1、指定延遲時間執行定時任務

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

 class TimerTaskTest01 extends TimerTask{

    public void run() {
        System.out.println("Time's up!!!!");
    }
}

運行結果：

首先打印：timer begin....

3秒後打印：Time's up!!!!

2.2、在指定時間執行定時任務

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

class TimerTaskTest02 extends TimerTask{

    @Override
    public void run() {
        System.out.println("指定時間執行線程任務...");
    }
}

當時間到達11:39:00時就會執行該線程任務，當然大於該時間也會執行！！執行結果爲：

指定時間time=Tue Jun 10 11:39:00 CST 2014
指定時間執行線程任務...

2.3、在延遲指定時間後以指定的間隔時間循環執行定時任務

public class TimerTest03 {
    Timer timer;
    
    public TimerTest03(){
        timer = new Timer();
        timer.schedule(new TimerTaskTest03(), 1000, 2000);
    }
    
    public static void main(String[] args) {
        new TimerTest03();
    }
}

class TimerTaskTest03 extends TimerTask{

    @Override
    public void run() {
        Date date = new Date(this.scheduledExecutionTime());
        System.out.println("本次執行該線程的時間爲：" + date);
    }
}

運行結果:

本次執行該線程的時間爲：Tue Jun 10 21:19:47 CST 2014
本次執行該線程的時間爲：Tue Jun 10 21:19:49 CST 2014
本次執行該線程的時間爲：Tue Jun 10 21:19:51 CST 2014
本次執行該線程的時間爲：Tue Jun 10 21:19:53 CST 2014
本次執行該線程的時間爲：Tue Jun 10 21:19:55 CST 2014
本次執行該線程的時間爲：Tue Jun 10 21:19:57 CST 2014
.................

對於這個線程任務,如果我們不將該任務停止,他會一直運行下去。

對於上面三個實例，LZ只是簡單的演示了一下，同時也沒有講解scheduleAtFixedRate方法的例子，其實該方法與schedule方法一樣！

2.4、分析schedule和scheduleAtFixedRate

1、schedule(TimerTask task, Date time)、schedule(TimerTask task, long delay)

對於這兩個方法而言，如果指定的計劃執行時間scheduledExecutionTime<= systemCurrentTime，則task會被立即執行。scheduledExecutionTime不會因爲某一個task的過度執行而改變。

2、schedule(TimerTask task, Date firstTime, long period)、schedule(TimerTask task, long delay, long period)

這兩個方法與上面兩個就有點兒不同的，前面提過Timer的計時器任務會因爲前一個任務執行時間較長而延時。在這兩個方法中，每一次執行的task的計劃時間會隨着前一個task的實際時間而發生改變，也就是scheduledExecutionTime(n+1)=realExecutionTime(n)+periodTime。也就是說如果第n個task由於某種情況導致這次的執行時間過程，最後導致systemCurrentTime>= scheduledExecutionTime(n+1)，這是第n+1個task並不會因爲到時了而執行，他會等待第n個task執行完之後再執行，那麼這樣勢必會導致n+2個的執行實現scheduledExecutionTime放生改變即scheduledExecutionTime(n+2) = realExecutionTime(n+1)+periodTime。所以這兩個方法更加註重保存間隔時間的穩定。

3、scheduleAtFixedRate(TimerTask task, Date firstTime, long period)、scheduleAtFixedRate(TimerTask task, long delay, long period)

在前面也提過scheduleAtFixedRate與schedule方法的側重點不同，schedule方法側重保存間隔時間的穩定，而scheduleAtFixedRate方法更加側重於保持執行頻率的穩定。爲什麼這麼說，原因如下。在schedule方法中會因爲前一個任務的延遲而導致其後面的定時任務延時，而scheduleAtFixedRate方法則不會，如果第n個task執行時間過長導致systemCurrentTime>= scheduledExecutionTime(n+1)，則不會做任何等待他會立即執行第n+1個task，所以scheduleAtFixedRate方法執行時間的計算方法不同於schedule，而是scheduledExecutionTime(n)=firstExecuteTime +n*periodTime，該計算方法永遠保持不變。所以scheduleAtFixedRate更加側重於保持執行頻率的穩定。

三、Timer的缺陷

3.1、Timer的缺陷

Timer計時器可以定時（指定時間執行任務）、延遲（延遲5秒執行任務）、週期性地執行任務（每隔個1秒執行任務），但是，Timer存在一些缺陷。首先Timer對調度的支持是基於絕對時間的，而不是相對時間，所以它對系統時間的改變非常敏感。其次Timer線程是不會捕獲異常的，如果TimerTask拋出的了未檢查異常則會導致Timer線程終止，同時Timer也不會重新恢復線程的執行，他會錯誤的認爲整個Timer線程都會取消。同時，已經被安排單尚未執行的TimerTask也不會再執行了，新的任務也不能被調度。故如果TimerTask拋出未檢查的異常，Timer將會產生無法預料的行爲。

1、Timer管理時間延遲缺陷

前面Timer在執行定時任務時只會創建一個線程任務，如果存在多個線程，若其中某個線程因爲某種原因而導致線程任務執行時間過長，超過了兩個任務的間隔時間，會發生一些缺陷：

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應該是在3s後執行，其結果應該是：

timerOne invoked ,the time:1001
timerOne invoked ,the time:3001

但是事與願違，timerOne由於sleep(4000)，休眠了4S，同時Timer內部是一個線程，導致timeOne所需的時間超過了間隔時間，結果：

timerOne invoked ,the time:1000
timerOne invoked ,the time:5000

2、Timer拋出異常缺陷

如果TimerTask拋出RuntimeException，Timer會終止所有任務的運行。如下：

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("我會不會執行呢？？");
            }
        }, 1000);
    }
    
    public static void main(String[] args) {
        TimerTest04 test = new TimerTest04();
        test.timerOne();
        test.timerTwo();
    }
}

運行結果：timerOne拋出異常，導致timerTwo任務終止。

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是基於絕對時間的，對系統時間比較敏感，而ScheduledThreadPoolExecutor 則是基於相對時間；Timer是內部是單一線程，而ScheduledThreadPoolExecutor內部是個線程池，所以可以支持多個任務併發執行。

3.2、用ScheduledExecutorService替代Timer

1、解決問題一：

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

運行結果：

timerOne,the time:1003
timerTwo,the time:2005

2、解決問題二

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

運行結果：

timerTwo invoked .....
timerTwo invoked .....
timerTwo invoked .....
timerTwo invoked .....
timerTwo invoked .....
timerTwo invoked .....
timerTwo invoked .....
timerTwo invoked .....
timerTwo invoked .....
........................

PS:如果你覺得文章對你有所幫助，別忘了推薦或者分享，因爲有你的支持，纔是我續寫下篇的動力和源泉！

作者： chenssy
出處： http://www.cnblogs.com/chenssy/
本文版權歸作者和博客園共有，歡迎轉載，但未經作者同意必須保留此段聲明，且在文章頁面明顯位置給出原文連接，否則保留追究法律責任的權利。

詳解java定時任務（轉）

詳解java定時任務

一、簡介

二、實例

2.1、指定延遲時間執行定時任務

2.2、在指定時間執行定時任務

2.3、在延遲指定時間後以指定的間隔時間循環執行定時任務

2.4、分析schedule和scheduleAtFixedRate

三、Timer的缺陷

3.1、Timer的缺陷

3.2、用ScheduledExecutorService替代Timer

PS:如果你覺得文章對你有所幫助，別忘了推薦或者分享，因爲有你的支持，纔是我續寫下篇的動力和源泉！

作者： chenssy
出處： http://www.cnblogs.com/chenssy/
本文版權歸作者和博客園共有，歡迎轉載，但未經作者同意必須保留此段聲明，且在文章頁面明顯位置給出原文連接，否則保留追究法律責任的權利。

釘釘打卡速度慢

Nginx R31 doc 官方文檔-01-nginx 如何安裝

Qt/C++音視頻開發74-合併標籤圖形/生成yolo運算結果圖形/文字和圖形合併成一個/水印濾鏡

挑戰程序設計競賽 2.2章習題 POJ - 3617 Best Cow Line 貪心

字節面試：MySQL什麼時候鎖表？如何防止鎖表？

.NET8連接SQL SERVER 2008 R2 報：證書鏈是由不受信任的頒發機構頒發的

golang開發環境搭建(win10)

python計算機視覺學習筆記——PIL庫的用法

Golang初學：獲取程序內存使用情況，std runtime

Nginx —— 分佈式session 之粘性Session實例

Redis —— linux安裝redis

Redis —— 分佈式session之 Redis集中式管理

Nginx —— linux下正向代理

linux —— linux安裝 ant

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

詳解java定時任務（轉）

一、簡介

二、實例

2.1、指定延遲時間執行定時任務

2.2、在指定時間執行定時任務

2.3、在延遲指定時間後以指定的間隔時間循環執行定時任務

2.4、分析schedule和scheduleAtFixedRate

三、Timer的缺陷

3.1、Timer的缺陷

3.2、用ScheduledExecutorService替代Timer

PS:如果你覺得文章對你有所幫助，別忘了推薦或者分享，因爲有你的支持，纔是我續寫下篇的動力和源泉！

作者： chenssy 出處： http://www.cnblogs.com/chenssy/ 本文版權歸作者和博客園共有，歡迎轉載，但未經作者同意必須保留此段聲明，且在文章頁面明顯位置給出原文連接，否則保留追究法律責任的權利。

作者： chenssy
出處： http://www.cnblogs.com/chenssy/
本文版權歸作者和博客園共有，歡迎轉載，但未經作者同意必須保留此段聲明，且在文章頁面明顯位置給出原文連接，否則保留追究法律責任的權利。