Timer與TimerTask

其實就Timer來講就是一個調度器,而TimerTask呢只是一個實現(xiàn)了run方法的一個類,而具體的TimerTask需要由你自己來實現(xiàn),例如這樣:

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

這里直接實現(xiàn)一個TimerTask(當然，你可以實現(xiàn)多個TimerTask，多個TimerTask可以被一個Timer會被分配到多個Timer中被調度，后面會說到Timer的實現(xiàn)機制就是說內部的調度機制)，然后編寫run方法，20s后開始執(zhí)行，每秒執(zhí)行一次，當然你通過一個timer對象來操作多個timerTask，其實timerTask本身沒什么意義，只是和timer集合操作的一個對象，實現(xiàn)它就必然有對應的run方法，以被調用，他甚至于根本不需要實現(xiàn)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)

和上一個方法類似，唯一的區(qū)別就是傳入的第二個參數(shù)為第一次調度的時間。

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

調度一個task，在delay(ms)后開始調度，然后每經過period(ms)再次調度

貌似和方法：schedule是一樣的，其實不然，后面你會根據源碼看到，schedule在計算下一次執(zhí)行的時間的時候，是通過當前時間（在任務執(zhí)行前得到） + 時間片

而scheduleAtFixedRate方法是通過當前需要執(zhí)行的時間（也就是計算出現(xiàn)在應該執(zhí)行的時間）+ 時間片，前者是運行的實際時間，而后者是理論時間點

例如：schedule時間片是5s，那么理論上會在5、10、15、20這些時間片被調度，但是如果由于某些CPU征用導致未被調度，假如等到第8s才被第一次調度，那么schedule方法計算出來的下一次時間應該是第13s而不是第10s，這樣有可能下次就越到20s后而被少調度一次或多次

而scheduleAtFixedRate方法就是每次理論計算出下一次需要調度的時間用以排序，若第8s被調度，那么計算出應該是第10s

所以它距離當前時間是2s，那么再調度隊列排序中，會被優(yōu)先調度，那么就盡量減少漏掉調度的情況。

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

方法同上，唯一的區(qū)別就是第一次調度時間設置為一個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 {<!--{C}%3C!%2D%2D%20%2D%2D%3E-->

看到這里知道了，Timer內部包裝了一個線程，用來做獨立于外部線程的調度，而TimerThread是一個default類型的，默認情況下是引用不到的，是被Timer自己所使用的。

接下來看下有那些屬性

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

private TaskQueue queue = new TaskQueue();

看名字就知道是一個隊列，隊列里面可以先猜猜看是什么，那么大概應該是我要調度的任務吧，先記錄下了，接下來繼續(xù)向下看：

里面還有一個屬性是：threadReaper，它是Object類型，只是重寫了finalize方法而已，是為了垃圾回收的時候，將相應的信息回收掉，做GC的回補，也就是當timer線程由于某種原因死掉了，而未被cancel，里面的隊列中的信息需要清空掉，不過我們通常是不會考慮這個方法的，所以知道java寫這個方法是干什么的就行了。

接下來看調度方法的實現(xiàn)：

對于上面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傳入，第一個參數(shù)傳入System.currentTimeMillis()+delay可見為第一次需要執(zhí)行的時間的時間點了（如果傳入Date，就是對象.getTime()即可，所以傳入Date的幾個方法就不用多說了），而第三個參數(shù)傳入了0，這里可以猜下要么是時間片，要么是次數(shù)啥的，不過等會就知道是什么了；另外關于方法：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來完成調度，和上面的方法唯一的調度時候的區(qū)別是增加了傳入的period，而第一個傳入的是0，所以確定這個參數(shù)為時間片，而不是次數(shù)

注意這個里的period加了一個負數(shù)，也就是取反，也就是我們開始傳入1000，在調用sched的時候會變成-1000

其實最終閱讀完源碼后你會發(fā)現(xiàn)這個算是老外對于一種數(shù)字的理解，而并非有什么特殊的意義，所以閱讀源碼的時候也有這些困難所在。

最后再看個方法是：

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

唯一的區(qū)別就是在period沒有取反，其實你最終閱讀完源碼，上面的取反沒有什么特殊的意義，老外不想增加一個參數(shù)來表示scheduleAtFixedRate，而scheduleAtFixedRate和schedule的大部分邏輯代碼一致，因此用了參數(shù)的范圍來作為區(qū)分方法，也就是當你傳入的參數(shù)不是正數(shù)的時候

你調用schedule方法正好是得到scheduleAtFixedRate的功能，而調用scheduleAtFixedRate方法的時候得到的正好是schedule方法的功能，呵呵，這些討論沒什么意義

討論實質和重點：

來看sched方法的實現(xiàn)體：

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為一個隊列，我們先不看他數(shù)據結構，看到他在做這個操作的時候，發(fā)生了同步，所以在timer級別，這個是線程安全的，最后將task相關的參數(shù)賦值，主要包含nextExecutionTime（下一次執(zhí)行時間），period（時間片），state（狀態(tài)），然后將它放入queue隊列中，做一次notify操作，為什么要做notify操作呢？看了后面的代碼你就知道了。

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

class TaskQueue { private TimerTask[] queue = new TimerTask[128]; private int size = 0;

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

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

• add(TimerTaskt)為增加一個任務
• size()任務隊列的長度
• getMin()獲取當前排序后最近需要執(zhí)行的一個任務，下標為1，隊列頭部0是不做任何操作的。
• get(inti)獲取指定下標的數(shù)據，當然包括下標0.
• removeMin()為刪除當前最近執(zhí)行的任務，也就是第一個元素，通常只調度一次的任務，在執(zhí)行完后，調用此方法，就可以將TimerTask從隊列中移除。
• quickRmove(inti)刪除指定的元素，一般來說是不會調用這個方法的，這個方法只有在Timer發(fā)生purge的時候，并且當對應的TimerTask調用了cancel方法的時候，才會被調用這個方法，也就是取消某個TimerTask，然后就會從隊列中移除（注意如果任務在執(zhí)行中是，還是仍然在執(zhí)行中的，雖然在隊列中被移除了），還有就是這個cancel方法并不是Timer的cancel方法而是TimerTask，一個是調度器的，一個是單個任務的，最后注意，這個quickRmove完成后，是將隊列最后一個元素補充到這個位置，所以此時會造成順序不一致的問題，后面會有方法進行回補。
• rescheduleMin(long newTime)是重新設置當前執(zhí)行的任務的下一次執(zhí)行時間，并在隊列中將其從新排序到合適的位置，而調用的是后面說的fixDown方法。

對于fixUp和fixDown方法來講，前者是當新增一個task的時候，首先將元素放在隊列的尾部，然后向前找是否有比自己還要晚執(zhí)行的任務，如果有，就將兩個任務的順序進行交換一下。而fixDown正好相反，執(zhí)行完第一個任務后，需要加上一個時間片得到下一次執(zhí)行時間，從而需要將其順序與后面的任務進行對比下。

其次可以看下fixDown的細節(jié)為：

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的時候，接下來就是2、4、8、16這些位置，找到合適的位置放下即可，順序未必是完全有序的，它只需要看到距離調度部分的越近的是有序性越強的時候就可以了，這樣即可以保證一定的順序性，達到較好的性能。

最后一個方法是heapify，其實就是將隊列的后半截，全部做一次fixeDown的操作，這個操作主要是為了回補quickRemove方法，當大量的quickRmove后，順序被打亂后，此時將一半的區(qū)域做一次非常簡單的排序即可。

這些方法我們不在說源碼了，只需要知道它提供了類似于ArrayList的東西來管理，內部有很多排序之類的處理，我們繼續(xù)回到Timer，里面還有兩個方法是：cancel()和方法purge()方法，其實就cancel方法來講，一個取消操作，在測試中你會發(fā)現(xiàn)，如果一旦執(zhí)行了這個方法timer就會結束掉，看下源碼是什么呢：

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

貌似僅僅將隊列清空掉，然后設置了newTasksMayBeScheduled狀態(tài)為false，最后讓隊列也調用了下notify操作，但是沒有任何地方讓線程結束掉，那么就要回到我們開始說的Timer中包含的thread為：TimerThread類了，在看這個類之前，再看下Timer中最后一個purge()類，當你對很多Task做了cancel操作后，此時通過調用purge方法實現(xiàn)對這些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，也就是我們開始所提及的那個參數(shù)在cancel的時候會被設置為false。

另一個屬性定義了

    private TaskQueue queue;

也就是我們所調用的queue了，這下聯(lián)通了吧，不過這里是queue是通過構造方法傳入的，傳入后賦值用以操作，很明顯是Timer傳遞給這個線程的，我們知道它是一個線程，所以執(zhí)行的中心自然是run方法了，所以看下run方法的body部分是：

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

try很簡單，就一個mainLoop，看名字知道是主循環(huán)程序，finally中也就是必然執(zhí)行的程序為將參數(shù)為為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) { } } }

可以發(fā)現(xiàn)這個timer是一個死循環(huán)程序，除非遇到不能捕獲的異常或break才會跳出，首先注意這段代碼：

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

循環(huán)體為循環(huán)過程中，條件為queue為空且newTasksMayBeScheduled狀態(tài)為true，可以看到這個狀態(tài)其關鍵作用，也就是跳出循環(huán)的條件就是要么隊列不為空，要么是newTasksMayBeScheduled狀態(tài)設置為false才會跳出，而wait就是在等待其他地方對queue發(fā)生notify操作，從上面的代碼中可以發(fā)現(xiàn)，當發(fā)生add、cancel以及在threadReaper調用finalize方法的時候會被調用，第三個我們基本可以不考慮其實發(fā)生add的時候也就是當隊列還是空的時候，發(fā)生add使得隊列不為空就跳出循環(huán)，而cancel是設置了狀態(tài)，否則不會進入這個循環(huán)，那么看下面的代碼：

if (queue.isEmpty()) ?????????break;

當跳出上面的循環(huán)后，如果是設置了newTasksMayBeScheduled狀態(tài)為false跳出，也就是調用了cancel，那么queue就是空的，此時就直接跳出外部的死循環(huán)，所以cancel就是這樣實現(xiàn)的，如果下面的任務還在跑還沒運行到這里來，cancel是不起作用的。

接下來是獲取一個當前系統(tǒng)時間和上次預計的執(zhí)行時間，如果預計執(zhí)行的時間小于當前系統(tǒng)時間，那么就需要執(zhí)行，此時判定時間片是否為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為負數(shù)的時候，就會被認為是按照按照當前系統(tǒng)時間+一個時間片來計算下一次時間，就是前面說的schedule和scheduleAtFixedRate的區(qū)別了，其實內部是通過正負數(shù)來判定的，也許java是不想增加參數(shù)，而又想增加程序的可讀性，才這樣做，其實通過正負判定是有些詭異的，也就是你如果在schedule方法傳入負數(shù)達到的功能和scheduleAtFixedRate的功能是一樣的，相反在scheduleAtFixedRate方法中傳入負數(shù)功能和schedule方法是一樣的。

同時你可以看到period為0，就是只執(zhí)行一次，所以時間片正負0都用上了，呵呵，然后再看看mainLoop接下來的部分：

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

這里是如果任務執(zhí)行時間還未到，就等待一段時間，當然這個等待很可能會被其他的線程操作add和cancel的時候被喚醒，因為內部有notify方法，所以這個時間并不是完全準確，在這里大多數(shù)情況下是考慮Timer內部的task信息是穩(wěn)定的，cancel方法喚醒的話是另一回事。

最后：

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

如果線程需要執(zhí)行，那么調用它的run方法，而并非啟動一個新的線程或從線程池中獲取一個線程來執(zhí)行，所以TimerTask的run方法并不是多線程的run方法，雖然實現(xiàn)了Runnable，但是僅僅是為了表示它是可執(zhí)行的，并不代表它必須通過線程的方式來執(zhí)行的。

總結

Timer和TimerTask的簡單組合是多線程的嘛？

不是，一個Timer內部包裝了“一個Thread”和“一個Task”隊列，這個隊列按照一定的方式將任務排隊處理，包含的線程在Timer的構造方法調用時被啟動，這個Thread的run方法無限循環(huán)這個Task隊列，若隊列為空且沒發(fā)生cancel操作，此時會一直等待，如果等待完成后，隊列還是為空，則認為發(fā)生了cancel從而跳出死循環(huán)，結束任務；

循環(huán)中如果發(fā)現(xiàn)任務需要執(zhí)行的時間小于系統(tǒng)時間，則需要執(zhí)行，那么根據任務的時間片從新計算下次執(zhí)行時間，若時間片為0代表只執(zhí)行一次，則直接移除隊列即可。

但是是否能實現(xiàn)多線程呢？

可以，任何東西是否是多線程完全看個人意愿，多個Timer自然就是多線程的，每個Timer都有自己的線程處理邏輯，當然Timer從這里來看并不是很適合很多任務在短時間內的快速調度，至少不是很適合同一個timer上掛很多任務，在多線程的領域中我們更多是使用多線程中的：

Executors.newScheduledThreadPool

來完成對調度隊列中的線程池的處理，內部通過new ScheduledThreadPoolExecutor來創(chuàng)建線程池的Executor的創(chuàng)建，當然也可以調用：

Executors.unconfigurableScheduledExecutorService

方法來創(chuàng)建一個DelegatedScheduledExecutorService其實這個類就是包裝了下下scheduleExecutor，也就是這只是一個殼，英文理解就是被委派的意思，被托管的意思。

到此這篇關于Java中的Timer與TimerTask原理詳解的文章就介紹到這了,更多相關Timer與TimerTask原理內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

最新評論