下面內容轉載自:
http://blog.csdn.net/xieyuooo/article/details/8607220
其實就Timer來講就是一個調度器,而TimerTask呢只是一個實現了run方法的一個類,而具體的TimerTask需要由你自己來實現,例如這樣:
1
2
3
4
5
6
|
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裏面的一些常見方法:
1
|
public void schedule(TimerTask
task, long delay) |
這個方法是調度一個task,經過delay(ms)後開始進行調度,僅僅調度一次。
1
|
public void schedule(TimerTask
task, Date time) |
在指定的時間點time上調度一次。
1
|
public void schedule(TimerTask
task, long delay, long period) |
這個方法是調度一個task,在delay(ms)後開始調度,每次調度完後,最少等待period(ms)後纔開始調度。
1
|
public void schedule(TimerTask
task, Date firstTime, long period) |
和上一個方法類似,唯一的區別就是傳入的第二個參數爲第一次調度的時間。
1
|
public void scheduleAtFixedRate(TimerTask
task, long delay, long period) |
調度一個task,在delay(ms)後開始調度,然後每經過period(ms)再次調度,貌似和方法:schedule是一樣的,其實不然,後面你會根據源碼看到,schedule在計算下一次執行的時間的時候,是通過當前時間(在任務執行前得到) + 時間片,而scheduleAtFixedRate方法是通過當前需要執行的時間(也就是計算出現在應該執行的時間)+ 時間片,前者是運行的實際時間,而後者是理論時間點,例如:schedule時間片是5s,那麼理論上會在5、10、15、20這些時間片被調度,但是如果由於某些CPU徵用導致未被調度,假如等到第8s才被第一次調度,那麼schedule方法計算出來的下一次時間應該是第13s而不是第10s,這樣有可能下次就越到20s後而被少調度一次或多次,而scheduleAtFixedRate方法就是每次理論計算出下一次需要調度的時間用以排序,若第8s被調度,那麼計算出應該是第10s,所以它距離當前時間是2s,那麼再調度隊列排序中,會被優先調度,那麼就儘量減少漏掉調度的情況。
1
|
public void scheduleAtFixedRate(TimerTask
task, Date firstTime, long period) |
方法同上,唯一的區別就是第一次調度時間設置爲一個Date時間,而不是當前時間的一個時間片,我們在源碼中會詳細說明這些內容。
接下來看源碼
首先看Timer的構造方法有幾種:
構造方法1:無參構造方法,簡單通過Tiemer爲前綴構造一個線程名稱:
1
2
3
|
public Timer()
{ this ( "Timer-" +
serialNumber()); } |
創建的線程不爲主線程,則主線程結束後,timer自動結束,而無需使用cancel來完成對timer的結束。
構造方法2:傳入了是否爲後臺線程,後臺線程當且僅當進程結束時,自動註銷掉。
1
2
3
|
public Timer( boolean isDaemon)
{ this ( "Timer-" +
serialNumber(), isDaemon); } |
另外兩個構造方法負責傳入名稱和將timer啓動:
1
2
3
4
5
|
public Timer(String
name, boolean isDaemon)
{ thread.setName(name); thread.setDaemon(isDaemon); thread.start(); } |
這裏有一個thread,這個thread很明顯是一個線程,被包裝在了Timer類中,我們看下這個thread的定義是:
1
|
private TimerThread
thread = new TimerThread(queue); |
而定義TimerThread部分的是:
1
|
class TimerThread extends Thread
{ |
看到這裏知道了,Timer內部包裝了一個線程,用來做獨立於外部線程的調度,而TimerThread是一個default類型的,默認情況下是引用不到的,是被Timer自己所使用的。
接下來看下有那些屬性
除了上面提到的thread,還有一個很重要的屬性是:
1
|
private TaskQueue
queue = new TaskQueue(); |
看名字就知道是一個隊列,隊列裏面可以先猜猜看是什麼,那麼大概應該是我要調度的任務吧,先記錄下了,接下來繼續向下看:
裏面還有一個屬性是:threadReaper,它是Object類型,只是重寫了finalize方法而已,是爲了垃圾回收的時候,將相應的信息回收掉,做GC的回補,也就是當timer線程由於某種原因死掉了,而未被cancel,裏面的隊列中的信息需要清空掉,不過我們通常是不會考慮這個方法的,所以知道java寫這個方法是幹什麼的就行了。
接下來看調度方法的實現:
對於上面6個調度方法,我們不做一一列舉,爲什麼等下你就知道了:
來看下方法:
1
|
public void schedule(TimerTask
task, long delay) |
的源碼如下:
1
2
3
4
5
|
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的內容我們不着急去看他,先看下重載的方法中是如何做的
再看看方法:
1
|
public void schedule(TimerTask
task, long delay, long period) |
源碼爲:
1
2
3
4
5
6
7
|
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,其實最終閱讀完源碼後你會發現這個算是老外對於一種數字的理解,而並非有什麼特殊的意義,所以閱讀源碼的時候也有這些困難所在。
最後再看個方法是:
1
|
public void scheduleAtFixedRate(TimerTasktask, long delay, long period) |
源碼爲:
1
2
3
4
5
6
7
|
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方法的實現體:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
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:
1
2
3
4
5
|
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的細節爲:
1
2
3
4
5
6
7
8
9
10
11
12
|
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後,順序被打亂後,此時將一半的區域做一次非常簡單的排序即可。
這些方法我們不在說源碼了,只需要知道它提供了類似於ArrayList的東西來管理,內部有很多排序之類的處理,我們繼續回到Timer,裏面還有兩個方法是:cancel()和方法purge()方法,其實就cancel方法來講,一個取消操作,在測試中你會發現,如果一旦執行了這個方法timer就會結束掉,看下源碼是什麼呢:
1
2
3
4
5
6
7
|
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方法來完成順序的重排,源碼如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
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。
另一個屬性定義了
1
|
private TaskQueue
queue; |
也就是我們所調用的queue了,這下聯通了吧,不過這裏是queue是通過構造方法傳入的,傳入後賦值用以操作,很明顯是Timer傳遞給這個線程的,我們知道它是一個線程,所以執行的中心自然是run方法了,所以看下run方法的body部分是:
1
2
3
4
5
6
7
8
9
10
|
public void run()
{ try { mainLoop(); } finally { synchronized (queue)
{ newTasksMayBeScheduled
= false ; queue.clear(); //
Eliminate obsolete references } } } |
try很簡單,就一個mainLoop,看名字知道是主循環程序,finally中也就是必然執行的程序爲將參數爲爲false,並將隊列清空掉。
那麼最核心的就是mainLoop了,是的,看懂了mainLoop一切都懂了:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
|
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纔會跳出,首先注意這段代碼:
1
2
|
while (queue.isEmpty()
&&newTasksMayBeScheduled) queue.wait(); |
循環體爲循環過程中,條件爲queue爲空且newTasksMayBeScheduled狀態爲true,可以看到這個狀態其關鍵作用,也就是跳出循環的條件就是要麼隊列不爲空,要麼是newTasksMayBeScheduled狀態設置爲false纔會跳出,而wait就是在等待其他地方對queue發生notify操作,從上面的代碼中可以發現,當發生add、cancel以及在threadReaper調用finalize方法的時候會被調用,第三個我們基本可以不考慮其實發生add的時候也就是當隊列還是空的時候,發生add使得隊列不爲空就跳出循環,而cancel是設置了狀態,否則不會進入這個循環,那麼看下面的代碼:
1
2
|
if (queue.isEmpty()) break ; |
當跳出上面的循環後,如果是設置了newTasksMayBeScheduled狀態爲false跳出,也就是調用了cancel,那麼queue就是空的,此時就直接跳出外部的死循環,所以cancel就是這樣實現的,如果下面的任務還在跑還沒運行到這裏來,cancel是不起作用的。
接下來是獲取一個當前系統時間和上次預計的執行時間,如果預計執行的時間小於當前系統時間,那麼就需要執行,此時判定時間片是否爲0,如果爲0,則調用removeMin方法將其移除,否則將task通過rescheduleMin設置最新時間並排序:
1
2
3
4
5
6
7
8
9
10
11
12
|
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接下來的部分:
1
2
|
if (!taskFired) //
Taskhasn't yet fired; wait queue.wait(executionTime-
currentTime); |
這裏是如果任務執行時間還未到,就等待一段時間,當然這個等待很可能會被其他的線程操作add和cancel的時候被喚醒,因爲內部有notify方法,所以這個時間並不是完全準確,在這裏大多數情況下是考慮Timer內部的task信息是穩定的,cancel方法喚醒的話是另一回事。
最後:
1
2
|
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上掛很多任務,在多線程的領域中我們更多是使用多線程中的:
1
|
Executors.newScheduledThreadPool |
來完成對調度隊列中的線程池的處理,內部通過new ScheduledThreadPoolExecutor來創建線程池的Executor的創建,當然也可以調用:
1
|
Executors.unconfigurableScheduledExecutorService |
方法來創建一個DelegatedScheduledExecutorService其實這個類就是包裝了下下scheduleExecutor,也就是這只是一個殼,英文理解就是被委派的意思,被託管的意思。