jdk并發(fā)部分，如果英文理解有點小難，可以參考http://www.yiibai.com/java6/java/util/concurrent/package-summary.html
本篇轉(zhuǎn)自：http://victorzhzh.iteye.com/blog/1011635

很多時候我們希望任務(wù)可以定時的周期性的執(zhí)行，在最初的JAVA工具類庫中，通過Timer可以實現(xiàn)定時的周期性的需求，但是有一定的缺陷，例如：Timer是基于絕對時間的而非支持相對時間，因此Timer對系統(tǒng)時鐘比較敏感。雖然有一定的問題，但是我們還是從這個最簡單的實現(xiàn)開始研究。

首先，我們準(zhǔn)備一些討論問題的類：TimerTask1和TimerLongTask，如下

Java代碼  

1. public class TimerTask1 extends TimerTask {  
2.   
3.     @Override  
4.     public void run() {  
5.         String base = "abcdefghijklmnopqrstuvwxyz0123456789";  
6.         Random random = new Random();  
7.         StringBuffer sb = new StringBuffer();  
8.         for (int i = 0; i < 10; i++) {  
9.             int number = random.nextInt(base.length());  
10.             sb.append(base.charAt(number));  
11.         }  
12.         System.out.println(new Date()+","+sb.toString());  
13.     }  
14.   
15. }  

 這個類負(fù)責(zé)生成一個含有10個字符的字符串，這里我們將輸出時間打印出來，近似認(rèn)為是任務(wù)執(zhí)行的時間。

Java代碼  

1. public class TimerLongTask extends TimerTask {  
2.   
3.     @Override  
4.     public void run() {  
5.         System.out.println("TimerLongTask: 開始沉睡");  
6.         try {  
7.             TimeUnit.SECONDS.sleep(10);  
8.         } catch (InterruptedException e) {  
9.             e.printStackTrace();  
10.         }  
11.         System.out.println("TimerLongTask: 已經(jīng)醒來");  
12.     }  
13.   
14. }  

 這個類啟動了一個長任務(wù)，即讓任務(wù)沉睡10秒。

下面我們來看一個定時任務(wù)執(zhí)行的例子：

Java代碼  

1. public static void main(String[] args) throws InterruptedException {  
2.     Timer timer = new Timer();  
3.     timer.schedule(new TimerTask1(), 1);  
4.     timer.schedule(new TimerLongTask(), 1);  
5.     timer.schedule(new TimerTask1(), 2);  
6.     TimeUnit.SECONDS.sleep(20);  
7.     timer.cancel();  
8. }  

 在這個例子中，我們先提交了一個TimerTask1任務(wù)，且讓它延遲1毫秒執(zhí)行，緊接著我們又提交了一個TimerLongTask長任務(wù)，且讓它也延遲1毫秒執(zhí)行，最后我們在提交一個TimerTask1任務(wù)，延遲2毫秒執(zhí)行。然后讓主線程沉睡20秒后關(guān)閉timer。我們看一下執(zhí)行結(jié)果：

Java代碼  

1. Thu Apr 21 11:04:31 CST 2011,utg3hn7u4r  
2. TimerLongTask: 開始沉睡  
3. TimerLongTask: 已經(jīng)醒來  
4. Thu Apr 21 11:04:41 CST 2011,4aac22sud1  

 這里我們看到第一次輸出10個字符的時間和第二次輸出10個字符的時間上相差了10秒，這10秒恰恰是長任務(wù)沉睡的時間，通過這個輸出我們可以分析出：Timer用來執(zhí)行任務(wù)的線程其實只有一個，且逐一被執(zhí)行。接下來我們查看一下源碼驗證一下，如下：

Java代碼  

1. private TaskQueue queue = new TaskQueue();  
2. private TimerThread thread = new TimerThread(queue);  

 這兩行代碼來自Timer源碼，我們可以看到在第一次創(chuàng)建了Timer時就已經(jīng)創(chuàng)建了一個thread和一個queue，因此只有一個線程來執(zhí)行我們的任務(wù)。

那么Timer是如何來執(zhí)行任務(wù)的？

首先我們調(diào)用timer.schedule方法，將任務(wù)提交到timer中，Timer中有很多重載的schedule方法，但它們都會調(diào)用同一個方法即sched方法。這個方法會將我們提交的任務(wù)添加到TaskQueue的隊列中(即queue)，在每次添加時都會根據(jù)nextExecutionTime大小來調(diào)整隊列中任務(wù)的順序，讓nextExecutionTime最小的排在隊列的最前端，nextExecutionTime最大的排在隊列的最后端。在創(chuàng)建Timer時，我們同時也創(chuàng)建了一個TimerThread即thread，并且啟動了這個線程，

Java代碼  

1. public Timer(String name) {  
2.         thread.setName(name);  
3.         thread.start();  
4. }  

 TimerThread中的mainLoop方法是核心，它會完成所有的任務(wù)執(zhí)行，在一開始我們的隊列為空，這時mainLoop方法將會使線程進(jìn)入等待狀態(tài)，當(dāng)我們使用schedule提交任務(wù)時會notify這個TimerThread線程，若任務(wù)的執(zhí)行未到則在wait相對的時間差。

我們調(diào)整一下上面的代碼，

Java代碼  

1. Timer timer = new Timer();  
2. timer.schedule(new TimerTask1(), 1);  
3. timer.schedule(new TimerTask1(), 5000);  
4. timer.schedule(new TimerLongTask(), 3000);  
5. TimeUnit.SECONDS.sleep(20);  
6. timer.cancel();  

 這樣先提交兩個輸出字符的任務(wù)最后提交長任務(wù)，在這里，我們讓第二個輸出字符的任務(wù)延遲5秒執(zhí)行，長任務(wù)延遲3秒執(zhí)行，這樣得到的結(jié)果如下：

Java代碼  

1. Thu Apr 21 13:07:44 CST 2011,2sstwluvgc  
2. TimerLongTask: 開始沉睡  
3. TimerLongTask: 已經(jīng)醒來  
4. Thu Apr 21 13:07:57 CST 2011,sh4fnkqqc8  

 雖然我們改變了提交順序，但是還是按照延遲時間遞增排序執(zhí)行的，兩個輸出字符串的時間之間相差13秒，這也是長任務(wù)等待執(zhí)行時間+長任務(wù)睡眠時間之和。

重復(fù)執(zhí)行scheduleAtFixedRate方法提交任務(wù)，主要是調(diào)用rescheduleMin方法對已經(jīng)調(diào)用的任務(wù)進(jìn)行重新設(shè)置調(diào)度延遲，并調(diào)用fixDown方法對隊列里的任務(wù)根據(jù)延遲時間重新排序。

Java代碼  

1. Timer timer = new Timer();  
2. timer.scheduleAtFixedRate(new TimerTask1(), 3000, 5000);  

 3000，代表第一次執(zhí)行時等待的時間，5000代表每次執(zhí)行任務(wù)之間的時間間隔，運(yùn)行結(jié)果：

Java代碼  

1. Thu Apr 21 13:14:55 CST 2011,izf536esrg  
2. Thu Apr 21 13:15:00 CST 2011,2khzm7e09v  
3. Thu Apr 21 13:15:05 CST 2011,jc3dvt2m8q  

 基本是每5秒運(yùn)行一次。

由于Timer只使用一個線程運(yùn)行所有的任務(wù)，那么當(dāng)一個任務(wù)拋出運(yùn)行時異常后會有什么樣的情形呢？其他的任務(wù)是否可以繼續(xù)？我們已經(jīng)有了前面的知識可以先猜想一個結(jié)果：因為Timer只使用一個線程運(yùn)行所有的任務(wù)，所以當(dāng)一個線程拋出運(yùn)行時異常時，這個線程就基本掛了，不會在執(zhí)行后續(xù)的任何代碼，因此我們可以斷言，當(dāng)一個任務(wù)拋出運(yùn)行時異常時，后續(xù)任務(wù)都不可以執(zhí)行。為了證明這個猜想，我們需要一個可以拋出異常的任務(wù)，如下：

Java代碼  

1. public class TimerExceptionTask extends TimerTask {  
2.   
3.     @Override  
4.     public void run() {  
5.         System.out.println("TimerExceptionTask: "+new Date());  
6.         throw new RuntimeException();  
7.     }  
8.   
9. }  

 這個任務(wù)拋出一個運(yùn)行時異常。接著我們需要定義一下我們?nèi)蝿?wù)執(zhí)行的順序：先執(zhí)行一個正常的任務(wù)，然后在執(zhí)行一個拋出異常的任務(wù)，最后在執(zhí)行一個正常的任務(wù)，如下：

Java代碼  

1. Timer timer = new Timer();  
2. timer.schedule(new TimerTask1(), 1000);  
3. timer.schedule(new TimerExceptionTask(), 3000);  
4. timer.schedule(new TimerTask1(), 5000);  
5. TimeUnit.SECONDS.sleep(6);  
6. timer.cancel();  

 延遲1秒執(zhí)行正常輸出字符串的任務(wù)，延遲3秒執(zhí)行拋出異常的任務(wù)，延遲5秒執(zhí)行正常輸出字符串的任務(wù)，看一下結(jié)果：

Java代碼  

1. Thu Apr 21 13:40:23 CST 2011,lk7fjneyyu  
2. TimerExceptionTask: Thu Apr 21 13:40:25 CST 2011  
3. Exception in thread "Timer-0" java.lang.RuntimeException  
4.     at org.victorzhzh.concurrency.TimerExceptionTask.run(TimerExceptionTask.java:11)  
5.     at java.util.TimerThread.mainLoop(Timer.java:512)  
6.     at java.util.TimerThread.run(Timer.java:462)  

 并沒有輸出兩個字符串，只執(zhí)行了第一次的輸出字符串任務(wù)，說明當(dāng)拋出運(yùn)行時異常時，其后續(xù)任務(wù)不可能被執(zhí)行。

鑒于Timer的缺陷，所以對它的使用還是要謹(jǐn)慎的，還好并發(fā)包中為我們提供了相應(yīng)的替代品：

為了研究方便我們需要兩個類：

Java代碼  

1. public class Task1 implements Callable<String> {  
2.   
3.     @Override  
4.     public String call() throws Exception {  
5.         String base = "abcdefghijklmnopqrstuvwxyz0123456789";  
6.         Random random = new Random();  
7.         StringBuffer sb = new StringBuffer();  
8.         for (int i = 0; i < 10; i++) {  
9.             int number = random.nextInt(base.length());  
10.             sb.append(base.charAt(number));  
11.         }  
12.         System.out.println("Task1 running: " + new Date());  
13.         return sb.toString();  
14.     }  
15.   
16. }  

 生成含有10個字符的字符串，使用Callable接口目的是我們不再任務(wù)中直接輸出結(jié)果，而主動取獲取任務(wù)的結(jié)果

Java代碼  

1. public class LongTask implements Callable<String> {  
2.   
3.     @Override  
4.     public String call() throws Exception {  
5.         System.out.println("LongTask running: "+new Date());  
6.         TimeUnit.SECONDS.sleep(10);  
7.         return "success";  
8.     }  
9.   
10. }  

長任務(wù)類，這里我們讓任務(wù)沉睡10秒然后返回一個“success”

下面我們來分析一下ScheduledThreadPoolExecutor：

1、Timer中單線程問題是否在ScheduledThreadPoolExecutor中存在？

我們先來看一下面的程序：

Java代碼  

1. public class ScheduledThreadPoolExec {  
2.     public static void main(String[] args) throws InterruptedException,  
3.             ExecutionException {  
4.         <strong><span style="color: #ff0000;">ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(  
5.                 2);</span>  
6. </strong>  
7.   
8.   
9.         ScheduledFuture future1 = executor.schedule(new Task1(), 5,  
10.                 TimeUnit.SECONDS);  
11.         ScheduledFuture future2 = executor.schedule(new LongTask(), 3,  
12.                 TimeUnit.SECONDS);  
13.   
14.         BlockingQueue<ScheduledFuture> blockingQueue = new ArrayBlockingQueue<ScheduledFuture>(  
15.                 2, true);  
16.         blockingQueue.add(future2);  
17.         blockingQueue.add(future1);  
18.   
19.         System.out.println(new Date());  
20.         while (!blockingQueue.isEmpty()) {  
21.             ScheduledFuture future = blockingQueue.poll();  
22.             if (!future.isDone())  
23.                 blockingQueue.add(future);  
24.             else  
25.                 System.out.println(future.get());  
26.         }  
27.         System.out.println(new Date());  
28.         executor.shutdown();  
29.     }  
30.   
31. }  

 首先，我們定義了一個ScheduledThreadPoolExecutor它的池長度是2。接著提交了兩個任務(wù)：第一個任務(wù)將延遲5秒執(zhí)行，第二個任務(wù)將延遲3秒執(zhí)行。我們建立了一個BlockingQueue，用它來存儲了ScheduledFuture，使用ScheduledFuture可以獲得任務(wù)的執(zhí)行結(jié)果。在一個while循環(huán)中，我們每次將一個ScheduledFuture從隊列中彈出，驗證它是否被執(zhí)行，如果沒有被執(zhí)行則再次將它加入隊列中，如果被執(zhí)行了，這使用ScheduledFuture的get方法獲取任務(wù)執(zhí)行的結(jié)果。看一下執(zhí)行結(jié)果：

Java代碼  

1. Thu Apr 21 19:23:02 CST 2011  
2. LongTask running: Thu Apr 21 19:23:05 CST 2011  
3. Task1 running: Thu Apr 21 19:23:07 CST 2011  
4. h1o2wd942e  
5. success  
6. Thu Apr 21 19:23:15 CST 2011  

 我們看到長任務(wù)先運(yùn)行，因為長任務(wù)只等待了3秒，然后是輸出字符串的任務(wù)運(yùn)行，兩個任務(wù)開始時間相差2秒，而先輸出了字符串而后才是長任務(wù)運(yùn)行的結(jié)果success，最后我們查看一下整體的開始和結(jié)束時間相差了13秒。

這說明在ScheduledThreadPoolExecutor中它不是以一個線程運(yùn)行任務(wù)的，而是以多個線程，如果用一個線程運(yùn)行任務(wù)，那么長任務(wù)運(yùn)行完之前是不會運(yùn)行輸出字符串任務(wù)的。其實這個“多個任務(wù)“是我們自己指定的注意一下標(biāo)紅的代碼，如果我們把這行代碼改為：

Java代碼  

1. ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(1);  

 那么運(yùn)行結(jié)果就會發(fā)生變化，

Java代碼  

1. Thu Apr 21 19:36:56 CST 2011  
2. LongTask running: Thu Apr 21 19:36:59 CST 2011  
3. success  
4. Task1 running: Thu Apr 21 19:37:09 CST 2011  
5. y981iqd0or  
6. Thu Apr 21 19:37:09 CST 2011  

 這時其實和使用Timer運(yùn)行結(jié)果是一樣的。任務(wù)是在一個線程里順序執(zhí)行的。

2、Timer中一但有運(yùn)行時異常報出后續(xù)任務(wù)是否還會正常運(yùn)行？

為了研究這個問題，我們還是需要一個能夠拋出異常的任務(wù)，如下：

Java代碼  

1. public class TimerExceptionTask extends TimerTask {  
2.   
3.     @Override  
4.     public void run() {  
5.         System.out.println("TimerExceptionTask: "+new Date());  
6.         throw new RuntimeException();  
7.     }  
8.   
9. }  

 我們對上面運(yùn)行任務(wù)的代碼做一點點小小的修改，先運(yùn)行兩個拋出異常的任務(wù)，如下：

Java代碼  

1. public class ScheduledThreadPoolExec {  
2.     public static void main(String[] args) throws InterruptedException,  
3.             ExecutionException {  
4.         ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(  
5.                 2);  
6.         ScheduledFuture future1 = executor.schedule(new Task1(), 5,  
7.                 TimeUnit.SECONDS);  
8.         ScheduledFuture future2 = executor.schedule(new LongTask(), 3,  
9.                 TimeUnit.SECONDS);  
10.         <strong><span style="color: #ff0000;">executor.schedule(new TimerExceptionTask(), 1, TimeUnit.SECONDS);  
11.         executor.schedule(new TimerExceptionTask(), 2, TimeUnit.SECONDS);</span>  
12. </strong>  
13.   
14.   
15.   
16.         BlockingQueue<ScheduledFuture> blockingQueue = new ArrayBlockingQueue<ScheduledFuture>(  
17.                 2, true);  
18.         blockingQueue.add(future2);  
19.         blockingQueue.add(future1);  
20.   
21.         System.out.println(new Date());  
22.         while (!blockingQueue.isEmpty()) {  
23.             ScheduledFuture future = blockingQueue.poll();  
24.             if (!future.isDone())  
25.                 blockingQueue.add(future);  
26.             else  
27.                 System.out.println(future.get());  
28.         }  
29.         System.out.println(new Date());  
30.         executor.shutdown();  
31.     }  
32.   
33. }  

 注意，標(biāo)紅的代碼，如果這兩個代碼拋出錯誤后會影響后續(xù)任務(wù)，那么就應(yīng)該在此終止，但是看一下結(jié)果，

Java代碼  

1. Thu Apr 21 19:40:15 CST 2011  
2. TimerExceptionTask: Thu Apr 21 19:40:16 CST 2011  
3. TimerExceptionTask: Thu Apr 21 19:40:17 CST 2011  
4. LongTask running: Thu Apr 21 19:40:18 CST 2011  
5. Task1 running: Thu Apr 21 19:40:20 CST 2011  
6. v5gcf01iiz  
7. success  
8. Thu Apr 21 19:40:28 CST 2011  

 后續(xù)任務(wù)仍然執(zhí)行，可能會有朋友說：“你上面的池設(shè)置的是2，所以很有可能是那兩個拋出異常的任務(wù)都在同一個線程中執(zhí)行，而另一個線程執(zhí)行了后續(xù)的任務(wù)”。那我們就把ScheduledThreadPoolExecutor設(shè)置成1看看，結(jié)果如下：

Java代碼  

1. Thu Apr 21 19:43:00 CST 2011  
2. TimerExceptionTask: Thu Apr 21 19:43:01 CST 2011  
3. TimerExceptionTask: Thu Apr 21 19:43:02 CST 2011  
4. LongTask running: Thu Apr 21 19:43:03 CST 2011  
5. success  
6. Task1 running: Thu Apr 21 19:43:13 CST 2011  
7. 33kgv8onnd  
8. Thu Apr 21 19:43:13 CST 2011  

后續(xù)任務(wù)也執(zhí)行了，所以說ScheduledThreadPoolExecutor不會像Timer那樣有線程泄漏現(xiàn)象。

對于周期性執(zhí)行和Timer很類似這里就不再舉例了。