Java併發編程：Timer和TimerTask（轉載）

時間  2019-11-05
標籤 java 併發 編程 timer timertask 轉載 欄目 Java 简体版
原文   原文鏈接

Java併發編程：Timer和TimerTask（轉載）html

　　下面內容轉載自：java

　　http://blog.csdn.net/xieyuooo/article/details/8607220編程

　　其實就Timer來說就是一個調度器,而TimerTask呢只是一個實現了run方法的一個類,而具體的TimerTask須要由你本身來實現,例如這樣:api

Timer timer = new Timer();
timer.schedule(new TimerTask() {
		public void run() {
			System.out.println("abc");
		}
}, 200000 , 1000);

　　這裏直接實現一個TimerTask(固然，你能夠實現多個TimerTask，多個TimerTask能夠被一個Timer會被分配到多個Timer中被調度，後面會說到Timer的實現機制就是說內部的調度機制)，而後編寫run方法，20s後開始執行，每秒執行一次，固然你經過一個timer對象來操做多個timerTask，其實timerTask自己沒什麼意義，只是和timer集合操做的一個對象，實現它就必然有對應的run方法，以被調用，他甚至於根本不須要實現Runnable，由於這樣每每混淆視聽了，爲何呢？也是本文要說的重點。數組

　　在說到timer的原理時，咱們先看看Timer裏面的一些常見方法：安全

public void schedule(TimerTask task, long delay)

　　這個方法是調度一個task，通過delay(ms)後開始進行調度，僅僅調度一次。數據結構

public void schedule(TimerTask task, Date time)

　　在指定的時間點time上調度一次。多線程

public void schedule(TimerTask task, long delay, long period)

 　　這個方法是調度一個task，在delay（ms）後開始調度，每次調度完後，最少等待period（ms）後纔開始調度。併發

public void schedule(TimerTask task, Date firstTime, long period)

　　和上一個方法相似，惟一的區別就是傳入的第二個參數爲第一次調度的時間。oop

public void scheduleAtFixedRate(TimerTask task, long delay, long period)

 　　調度一個task，在delay(ms)後開始調度，而後每通過period(ms)再次調度，貌似和方法：schedule是同樣的，其實否則，後面你會根據源碼看到，schedule在計算下一次執行的時間的時候，是經過當前時間（在任務執行前獲得） + 時間片，而scheduleAtFixedRate方法是經過當前須要執行的時間（也就是計算出如今應該執行的時間）+ 時間片，前者是運行的實際時間，然後者是理論時間點，例如：schedule時間片是5s，那麼理論上會在五、十、1五、20這些時間片被調度，可是若是因爲某些CPU徵用致使未被調度，假如等到第8s才被第一次調度，那麼schedule方法計算出來的下一次時間應該是第13s而不是第10s，這樣有可能下次就越到20s後而被少調度一次或屢次，而scheduleAtFixedRate方法就是每次理論計算出下一次須要調度的時間用以排序，若第8s被調度，那麼計算出應該是第10s，因此它距離當前時間是2s，那麼再調度隊列排序中，會被優先調度，那麼就儘可能減小漏掉調度的狀況。

public void scheduleAtFixedRate(TimerTask task, Date firstTime,long period)

　　方法同上，惟一的區別就是第一次調度時間設置爲一個Date時間，而不是當前時間的一個時間片，咱們在源碼中會詳細說明這些內容。

　　接下來看源碼

　　首先看Timer的構造方法有幾種：

　　構造方法1：無參構造方法，簡單經過Tiemer爲前綴構造一個線程名稱：

public Timer() {
    this("Timer-" + serialNumber());
}

 　　建立的線程不爲主線程，則主線程結束後，timer自動結束，而無需使用cancel來完成對timer的結束。

　　構造方法2：傳入了是否爲後臺線程，後臺線程當且僅當進程結束時，自動註銷掉。 
public Timer(boolean isDaemon) {
    this("Timer-" + serialNumber(), isDaemon);
}

 　　另外兩個構造方法負責傳入名稱和將timer啓動：

  public Timer(String name, boolean isDaemon) {
        thread.setName(name);
        thread.setDaemon(isDaemon);
        thread.start();
    }

 　　這裏有一個thread，這個thread很明顯是一個線程，被包裝在了Timer類中，咱們看下這個thread的定義是：

private TimerThread thread = new TimerThread(queue);

　　而定義TimerThread部分的是：

class TimerThread extends Thread {

 　　看到這裏知道了，Timer內部包裝了一個線程，用來作獨立於外部線程的調度，而TimerThread是一個default類型的，默認狀況下是引用不到的，是被Timer本身所使用的。

　　接下來看下有那些屬性

　　除了上面提到的thread，還有一個很重要的屬性是：

private TaskQueue queue = new TaskQueue();

 　　看名字就知道是一個隊列，隊列裏面能夠先猜猜看是什麼，那麼大概應該是我要調度的任務吧，先記錄下了，接下來繼續向下看：

裏面還有一個屬性是：threadReaper，它是Object類型，只是重寫了finalize方法而已，是爲了垃圾回收的時候，將相應的信息回收掉，作GC的回補，也就是當timer線程因爲某種緣由死掉了，而未被cancel，裏面的隊列中的信息須要清空掉，不過咱們一般是不會考慮這個方法的，因此知道java寫這個方法是幹什麼的就好了。

　　接下來看調度方法的實現：

　　對於上面6個調度方法，咱們不作一一列舉，爲何等下你就知道了：

　　來看下方法：

public void schedule(TimerTask task, long delay)

　　的源碼以下：

 public void schedule(TimerTask task, long delay) {
        if (delay < 0)
            throw new IllegalArgumentException("Negative delay.");
        sched(task, System.currentTimeMillis()+delay, 0);
    }

　　這裏調用了另外一個方法，將task傳入，第一個參數傳入System.currentTimeMillis()+delay可見爲第一次須要執行的時間的時間點了（若是傳入Date，就是對象.getTime()便可，因此傳入Date的幾個方法就不用多說了），而第三個參數傳入了0，這裏能夠猜下要麼是時間片，要麼是次數啥的，不過等會就知道是什麼了；另外關於方法：sched的內容咱們不着急去看他，先看下重載的方法中是如何作的

　　再看看方法：

public void schedule(TimerTask task, long delay,long period)

　　源碼爲：

public void schedule(TimerTask task, long delay, long period) {
        if (delay < 0)
            throw new IllegalArgumentException("Negative delay.");
        if (period <= 0)
            throw new IllegalArgumentException("Non-positive period.");
        sched(task, System.currentTimeMillis()+delay, -period);
    }

　　看來也調用了方法sched來完成調度，和上面的方法惟一的調度時候的區別是增長了傳入的period，而第一個傳入的是0，因此肯定這個參數爲時間片，而不是次數，注意這個裏的period加了一個負數，也就是取反，也就是咱們開始傳入1000，在調用sched的時候會變成-1000，其實最終閱讀完源碼後你會發現這個算是老外對於一種數字的理解，而並不是有什麼特殊的意義，因此閱讀源碼的時候也有這些困難所在。

　　最後再看個方法是：

public void scheduleAtFixedRate(TimerTasktask,long delay,long period)

　　源碼爲：

 public void scheduleAtFixedRate(TimerTask task, long delay, long period) {
        if (delay < 0)
            throw new IllegalArgumentException("Negative delay.");
        if (period <= 0)
            throw new IllegalArgumentException("Non-positive period.");
        sched(task, System.currentTimeMillis()+delay, period);
    }

 　　惟一的區別就是在period沒有取反，其實你最終閱讀完源碼，上面的取反沒有什麼特殊的意義，老外不想增長一個參數來表示scheduleAtFixedRate，而scheduleAtFixedRate和schedule的大部分邏輯代碼一致，所以用了參數的範圍來做爲區分方法，也就是當你傳入的參數不是正數的時候，你調用schedule方法正好是獲得scheduleAtFixedRate的功能，而調用scheduleAtFixedRate方法的時候獲得的正好是schedule方法的功能，呵呵，這些討論沒什麼意義，討論實質和重點：

 　　來看sched方法的實現體：

private void sched(TimerTask task, long time, long period) {
        if (time < 0)
            throw new IllegalArgumentException("Illegal execution time.");

        synchronized(queue) {
            if (!thread.newTasksMayBeScheduled)
                throw new IllegalStateException("Timer already cancelled.");

            synchronized(task.lock) {
                if (task.state != TimerTask.VIRGIN)
                    throw new IllegalStateException(
                        "Task already scheduled or cancelled");
                task.nextExecutionTime = time;
                task.period = period;
                task.state = TimerTask.SCHEDULED;
            }

            queue.add(task);
            if (queue.getMin() == task)
                queue.notify();
        }
    }

　　queue爲一個隊列，咱們先不看他數據結構，看到他在作這個操做的時候，發生了同步，因此在timer級別，這個是線程安全的，最後將task相關的參數賦值，主要包含nextExecutionTime（下一次執行時間），period（時間片），state（狀態），而後將它放入queue隊列中，作一次notify操做，爲何要作notify操做呢？看了後面的代碼你就知道了。

 

　　簡言之，這裏就是講task放入隊列queue的過程，此時，你可能對queue的結構有些興趣，那麼咱們先來看看queue屬性的結構TaskQueue：

class TaskQueue {

    private TimerTask[] queue = new TimerTask[128];

    private int size = 0;

 　　可見，TaskQueue的結構很簡單，爲一個數組，加一個size，有點像ArrayList，是否是長度就128呢，固然不是，ArrayList能夠擴容，它能夠，只是會形成內存拷貝而已，因此一個Timer來說，只要內部的task個數不超過128是不會形成擴容的；內部提供了add(TimerTask)、size()、getMin()、get(int)、removeMin()、quickRemove(int)、rescheduleMin(long newTime)、isEmpty()、clear()、fixUp()、fixDown()、heapify()；

　　這裏面的方法大概意思是：

　　add(TimerTaskt)爲增長一個任務

　　size()任務隊列的長度

　　getMin()獲取當前排序後最近須要執行的一個任務，下標爲1，隊列頭部0是不作任何操做的。

　　get(inti)獲取指定下標的數據，固然包括下標0.

　　removeMin()爲刪除當前最近執行的任務，也就是第一個元素，一般只調度一次的任務，在執行完後，調用此方法，就能夠將TimerTask從隊列中移除。

　　quickRmove(inti)刪除指定的元素，通常來講是不會調用這個方法的，這個方法只有在Timer發生purge的時候，而且當對應的TimerTask調用了cancel方法的時候，纔會被調用這個方法，也就是取消某個TimerTask，而後就會從隊列中移除（注意若是任務在執行中是，仍是仍然在執行中的，雖然在隊列中被移除了），還有就是這個cancel方法並非Timer的cancel方法而是TimerTask，一個是調度器的，一個是單個任務的，最後注意，這個quickRmove完成後，是將隊列最後一個元素補充到這個位置，因此此時會形成順序不一致的問題，後面會有方法進行回補。

　　rescheduleMin(long newTime)是從新設置當前執行的任務的下一次執行時間，並在隊列中將其重新排序到合適的位置，而調用的是後面說的fixDown方法。

　　對於fixUp和fixDown方法來說，前者是當新增一個task的時候，首先將元素放在隊列的尾部，而後向前找是否有比本身還要晚執行的任務，若是有，就將兩個任務的順序進行交換一下。而fixDown正好相反，執行完第一個任務後，須要加上一個時間片獲得下一次執行時間，從而須要將其順序與後面的任務進行對比下。

　　其次能夠看下fixDown的細節爲：

 private void fixDown(int k) {
        int j;
        while ((j = k << 1) <= size && j > 0) {
            if (j < size &&
                queue[j].nextExecutionTime > queue[j+1].nextExecutionTime)
                j++; // j indexes smallest kid
            if (queue[k].nextExecutionTime <= queue[j].nextExecutionTime)
                break;
            TimerTask tmp = queue[j];  queue[j] = queue[k]; queue[k] = tmp;
            k = j;
        }
    }

 　　這種方式並不是排序，而是找到一個合適的位置來交換，由於並非經過隊列逐個找的，而是每次移動一個二進制爲，例如傳入1的時候，接下來就是二、四、八、16這些位置，找到合適的位置放下便可，順序未必是徹底有序的，它只須要看到距離調度部分的越近的是有序性越強的時候就能夠了，這樣便可以保證必定的順序性，達到較好的性能。

　　最後一個方法是heapify，其實就是將隊列的後半截，所有作一次fixeDown的操做，這個操做主要是爲了回補quickRemove方法，當大量的quickRmove後，順序被打亂後，此時將一半的區域作一次很是簡單的排序便可。

　　這些方法咱們不在說源碼了，只須要知道它提供了相似於ArrayList的東西來管理，內部有不少排序之類的處理，咱們繼續回到Timer，裏面還有兩個方法是：cancel()和方法purge()方法，其實就cancel方法來說，一個取消操做，在測試中你會發現，若是一旦執行了這個方法timer就會結束掉，看下源碼是什麼呢：

public void cancel() {
        synchronized(queue) {
            thread.newTasksMayBeScheduled = false;
            queue.clear();
            queue.notify();  // In case queue was already empty.
        }
    }

 　　貌似僅僅將隊列清空掉，而後設置了newTasksMayBeScheduled狀態爲false，最後讓隊列也調用了下notify操做，可是沒有任何地方讓線程結束掉，那麼就要回到咱們開始說的Timer中包含的thread爲：TimerThread類了，在看這個類以前，再看下Timer中最後一個purge()類，當你對不少Task作了cancel操做後，此時經過調用purge方法實現對這些cancel掉的類空間的回收，上面已經提到，此時會形成順序混亂，因此須要調用隊裏的heapify方法來完成順序的重排，源碼以下：

public int purge() {
         int result = 0;

         synchronized(queue) {
             for (int i = queue.size(); i > 0; i--) {
                 if (queue.get(i).state == TimerTask.CANCELLED) {
                     queue.quickRemove(i);
                     result++;
                 }
             }

             if (result != 0)
                 queue.heapify();
         }
         return result;
     }

　　那麼調度呢，是如何調度的呢，那些notify，和清空隊列是如何作到的呢？咱們就要看看TimerThread類了，內部有一個屬性是：newTasksMayBeScheduled，也就是咱們開始所說起的那個參數在cancel的時候會被設置爲false。

　　另外一個屬性定義了

private TaskQueue queue;

 　　也就是咱們所調用的queue了，這下聯通了吧，不過這裏是queue是經過構造方法傳入的，傳入後賦值用以操做，很明顯是Timer傳遞給這個線程的，咱們知道它是一個線程，因此執行的中心天然是run方法了，因此看下run方法的body部分是：

public void run() {
        try {
            mainLoop();
        } finally {
            synchronized(queue) {
                newTasksMayBeScheduled = false;
                queue.clear();  // Eliminate obsolete references
            }
        }
    }

　　try很簡單，就一個mainLoop，看名字知道是主循環程序，finally中也就是必然執行的程序爲將參數爲爲false，並將隊列清空掉。

那麼最核心的就是mainLoop了，是的，看懂了mainLoop一切都懂了：

private void mainLoop() {
        while (true) {
            try {
                TimerTask task;
                boolean taskFired;
                synchronized(queue) {
                    // Wait for queue to become non-empty
                    while (queue.isEmpty() && newTasksMayBeScheduled)
                        queue.wait();
                    if (queue.isEmpty())
                        break; // Queue is empty and will forever remain; die

                    // Queue nonempty; look at first evt and do the right thing
                    long currentTime, executionTime;
                    task = queue.getMin();
                    synchronized(task.lock) {
                        if (task.state == TimerTask.CANCELLED) {
                            queue.removeMin();
                            continue;  // No action required, poll queue again
                        }
                        currentTime = System.currentTimeMillis();
                        executionTime = task.nextExecutionTime;
                        if (taskFired = (executionTime<=currentTime)) {
                            if (task.period == 0) { // Non-repeating, remove
                                queue.removeMin();
                                task.state = TimerTask.EXECUTED;
                            } else { // Repeating task, reschedule
                                queue.rescheduleMin(
                                  task.period<0 ? currentTime   - task.period
                                                : executionTime + task.period);
                            }
                        }
                    }
                    if (!taskFired) // Task hasn't yet fired; wait
                        queue.wait(executionTime - currentTime);
                }
                if (taskFired)  // Task fired; run it, holding no locks
                    task.run();
            } catch(InterruptedException e) {
            }
        }
    }

 　　能夠發現這個timer是一個死循環程序，除非遇到不能捕獲的異常或break纔會跳出，首先注意這段代碼：

while (queue.isEmpty() &&newTasksMayBeScheduled)
                        queue.wait();

　　循環體爲循環過程當中，條件爲queue爲空且newTasksMayBeScheduled狀態爲true，能夠看到這個狀態其關鍵做用，也就是跳出循環的條件就是要麼隊列不爲空，要麼是newTasksMayBeScheduled狀態設置爲false纔會跳出，而wait就是在等待其餘地方對queue發生notify操做，從上面的代碼中能夠發現，當發生add、cancel以及在threadReaper調用finalize方法的時候會被調用，第三個咱們基本能夠不考慮其實發生add的時候也就是當隊列仍是空的時候，發生add使得隊列不爲空就跳出循環，而cancel是設置了狀態，不然不會進入這個循環，那麼看下面的代碼：

if (queue.isEmpty())
    break;

 　　當跳出上面的循環後，若是是設置了newTasksMayBeScheduled狀態爲false跳出，也就是調用了cancel，那麼queue就是空的，此時就直接跳出外部的死循環，因此cancel就是這樣實現的，若是下面的任務還在跑還沒運行到這裏來，cancel是不起做用的。

　　接下來是獲取一個當前系統時間和上次預計的執行時間，若是預計執行的時間小於當前系統時間，那麼就須要執行，此時斷定時間片是否爲0，若是爲0，則調用removeMin方法將其移除，不然將task經過rescheduleMin設置最新時間並排序：

currentTime = System.currentTimeMillis();
executionTime = task.nextExecutionTime;
if (taskFired = (executionTime<=currentTime)) {
      if (task.period == 0) { // Non-repeating, remove
           queue.removeMin();
           task.state = TimerTask.EXECUTED;
      } else { // Repeating task, reschedule
           queue.rescheduleMin(
           task.period<0 ? currentTime   - task.period
                              : executionTime + task.period);
     }
}

 　　這裏能夠看到，period爲負數的時候，就會被認爲是按照按照當前系統時間+一個時間片來計算下一次時間，就是前面說的schedule和scheduleAtFixedRate的區別了，其實內部是經過正負數來斷定的，也許java是不想增長參數，而又想增長程序的可讀性，才這樣作，其實經過正負斷定是有些詭異的，也就是你若是在schedule方法傳入負數達到的功能和scheduleAtFixedRate的功能是同樣的，相反在scheduleAtFixedRate方法中傳入負數功能和schedule方法是同樣的。

　　同時你能夠看到period爲0，就是隻執行一次，因此時間片正負0都用上了，呵呵，而後再看看mainLoop接下來的部分：

if (!taskFired)// Taskhasn't yet fired; wait
    queue.wait(executionTime- currentTime);

 　　這裏是若是任務執行時間還未到，就等待一段時間，固然這個等待極可能會被其餘的線程操做add和cancel的時候被喚醒，由於內部有notify方法，因此這個時間並非徹底準確，在這裏大多數狀況下是考慮Timer內部的task信息是穩定的，cancel方法喚醒的話是另外一回事。

　　最後：

if (taskFired) // Task fired; run it, holding no locks
    task.run();

 　　若是線程須要執行，那麼調用它的run方法，而並不是啓動一個新的線程或從線程池中獲取一個線程來執行，因此TimerTask的run方法並非多線程的run方法，雖然實現了Runnable，可是僅僅是爲了表示它是可執行的，並不表明它必須經過線程的方式來執行的。

 

　　回過頭來再看看：

　　Timer和TimerTask的簡單組合是多線程的嘛？不是，一個Timer內部包裝了「一個Thread」和「一個Task」隊列，這個隊列按照必定的方式將任務排隊處理，包含的線程在Timer的構造方法調用時被啓動，這個Thread的run方法無限循環這個Task隊列，若隊列爲空且沒發生cancel操做，此時會一直等待，若是等待完成後，隊列仍是爲空，則認爲發生了cancel從而跳出死循環，結束任務；循環中若是發現任務須要執行的時間小於系統時間，則須要執行，那麼根據任務的時間片重新計算下次執行時間，若時間片爲0表明只執行一次，則直接移除隊列便可。

　　可是是否能實現多線程呢？能夠，任何東西是不是多線程徹底看我的意願，多個Timer天然就是多線程的，每一個Timer都有本身的線程處理邏輯，固然Timer從這裏來看並非很適合不少任務在短期內的快速調度，至少不是很適合同一個timer上掛不少任務，在多線程的領域中咱們更可能是使用多線程中的：

Executors.newScheduledThreadPool

 來完成對調度隊列中的線程池的處理，內部經過new ScheduledThreadPoolExecutor來建立線程池的Executor的建立，固然也能夠調用：

Executors.unconfigurableScheduledExecutorService

 　　方法來建立一個DelegatedScheduledExecutorService其實這個類就是包裝了下下scheduleExecutor，也就是這只是一個殼，英文理解就是被委派的意思，被託管的意思。

　　

　　具體的使用例子能夠參考這篇博文：

　　http://www.bdqn.cn/news/201305/9303.shtml

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程