Java併發編程筆記之Timer源碼分析

timer在JDK裏面，是很早的一個API了。具備延時的，並具備週期性的任務，在newScheduledThreadPool出來以前咱們通常會用Timer和TimerTask來作，可是Timer存在一些缺陷，爲何這麼說呢？

　　Timer只建立惟一的線程來執行全部Timer任務。若是一個timer任務的執行很耗時，會致使其餘TimerTask的時效準確性出問題。例如一個TimerTask每10秒執行一次，而另一個TimerTask每40ms執行一次，重複出現的任務會在後來的任務完成後快速連續的被調用4次，要麼徹底「丟失」4次調用。Timer的另一個問題在於，若是TimerTask拋出未檢查的異常會終止timer線程。這種狀況下，Timer也不會從新回覆線程的執行了；它錯誤的認爲整個Timer都被取消了。此時已經被安排但還沒有執行的TimerTask永遠不會再執行了，新的任務也不能被調度了。

 

這裏作了一個小的 demo 來複現問題，代碼以下：

package com.hjc;

import java.util.Timer;
import java.util.TimerTask;

/**
 * Created by cong on 2018/7/12.
 */
public class TimerTest {
    //建立定時器對象
    static Timer timer = new Timer();

    public static void main(String[] args) {
        //添加任務1,延遲500ms執行
        timer.schedule(new TimerTask() {

            @Override
            public void run() {
                System.out.println("---one Task---");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                throw new RuntimeException("error ");
            }
        }, 500);
        //添加任務2，延遲1000ms執行
        timer.schedule(new TimerTask() {

            @Override
            public void run() {
                for (;;) {
                    System.out.println("---two Task---");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        }, 1000);

    }
}

如上代碼先添加了一個任務在 500ms 後執行，而後添加了第二個任務在 1s 後執行，咱們指望的是當第一個任務輸出 ---one Task--- 後等待 1s 後第二個任務會輸出 ---two Task---，

可是執行完畢代碼後輸出結果以下所示：

 

例子2，

 

public class Shedule {
    private static long start;

    public static void main(String[] args) {
        TimerTask task = new TimerTask() {
            public void run() {
                System.out.println(System.currentTimeMillis()-start);
                try{
                    Thread.sleep(3000);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        };

        TimerTask task1 = new TimerTask() {
            @Override
            public void run() {
                System.out.println(System.currentTimeMillis()-start);
            }
        };

        Timer timer = new Timer();
        start = System.currentTimeMillis();
        //啓動一個調度任務，1S鍾後執行
        timer.schedule(task,1000);
        //啓動一個調度任務，3S鍾後執行
        timer.schedule(task1,3000);


    }

}

上面程序咱們預想是第一個任務執行後，第二個任務3S後執行的，即輸出一個1000，一個3000.

實際運行結果以下：

實際運行結果並不如咱們所願。世界結果，是過了4S後才輸出第二個任務，即4001約等於4秒。那部分時間時間到哪裏去了呢？那個時間是被咱們第一個任務的sleep所佔用了。

如今咱們在第一個任務中去掉Thread.sleep（）；這一行代碼，運行是否正確了呢？運行結果以下：

能夠看到確實是第一個任務過了1S後執行，第二個任務在第一個任務執行完後過3S執行了。

這就說明了Timer只建立惟一的線程來執行全部Timer任務。若是一個timer任務的執行很耗時，會致使其餘TimerTask的時效準確性出問題。

 

Timer 實現原理分析

下面簡單介紹下 Timer 的原理，以下圖是 Timer 的原理模型介紹：

1.其中 TaskQueue 是一個平衡二叉樹堆實現的優先級隊列，每一個 Timer 對象內部有惟一一個 TaskQueue 隊列。用戶線程調用 timer 的 schedule 方法就是把 TimerTask 任務添加到 TaskQueue 隊列，在調用 schedule 的方法時候 long delay 參數用來講明該任務延遲多少時間執行。

2.TimerThread 是具體執行任務的線程，它從 TaskQueue 隊列裏面獲取優先級最小的任務進行執行，須要注意的是隻有執行完了當前的任務纔會從隊列裏面獲取下一個任務而無論隊列裏面是否有已經到了設置的 delay 時間，一個 Timer 只有一個 TimerThread 線程，因此可知 Timer 的內部實現是一個多生產者單消費者模型。

 

從實現模型能夠知道要探究上面的問題只需看 TimerThread 的實現就能夠了，TimerThread 的 run 方法主要邏輯源碼以下：

public void run() {
   try {
       mainLoop();
   } finally {
       // 有人殺死了這個線程，表現得好像Timer已取消
       synchronized(queue) {
           newTasksMayBeScheduled = false;
           queue.clear();  // 消除過期的引用
       }
   }
}
 private void mainLoop() {
        while (true) {
            try {
                TimerTask task;
                boolean taskFired;
                //從隊列裏面獲取任務時候要加鎖
                synchronized(queue) {
                    ......
                }
                if (taskFired)  
                    task.run();//執行任務
            } catch(InterruptedException e) {
            }
        }
 }

可知當任務執行過程當中拋出了除 InterruptedException 以外的異常後，惟一的消費線程就會由於拋出異常而終止，那麼隊列裏面的其餘待執行的任務就會被清除。因此 TimerTask 的 run 方法內最好使用 try-catch 結構 catch 主可能的異常，不要把異常拋出到 run 方法外。

其實要實現相似 Timer 的功能使用 ScheduledThreadPoolExecutor 的 schedule 是比較好的選擇。ScheduledThreadPoolExecutor 中的一個任務拋出了異常，其餘任務不受影響的。

ScheduledThreadPoolExecutor 例子以下：

/**
 * Created by cong on 2018/7/12.
 */
public class ScheduledThreadPoolExecutorTest {
    static ScheduledThreadPoolExecutor scheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(1);

    public static void main(String[] args) {

        scheduledThreadPoolExecutor.schedule(new Runnable() {

            public void run()  {
                System.out.println("---one Task---");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                throw new RuntimeException("error ");
            }

        }, 500, TimeUnit.MICROSECONDS);

        scheduledThreadPoolExecutor.schedule(new Runnable() {

            public void run() {
                for (int i =0;i<5;++i) {
                    System.out.println("---two Task---");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

            }

        }, 1000, TimeUnit.MICROSECONDS);

        scheduledThreadPoolExecutor.shutdown();
    }
}

運行結果以下：

之因此 ScheduledThreadPoolExecutor 的其餘任務不受拋出異常的任務的影響是由於 ScheduledThreadPoolExecutor 中的 ScheduledFutureTask 任務中 catch 掉了異常，可是在線程池任務的 run 方法內使用 catch 捕獲異常並打印日誌是最佳實踐。