ExecutorService的execute和submit方法

由於以前一直是用的execute方法，最近有個狀況須要用到submit方法，因此研究了下。

三個區別：

一、接收的參數不同

二、submit有返回值，而execute沒有

Method submit extends base method Executor.execute by creating and returning a Future that can be used to cancel execution and/or wait for completion. 

用到返回值的例子，好比說我有不少個作validation的task，我但願全部的task執行完，而後每一個task告訴我它的執行結果，是成功仍是失敗，若是是失敗，緣由是什麼。而後我就能夠把全部失敗的緣由綜合起來發給調用者。

我的以爲cancel execution這個用處不大，不多有須要去取消執行的。

而最大的用處應該是第二點。

三、submit方便Exception處理

There is a difference when looking at exception handling. If your tasks throws an exception and if it was submitted with execute this exception will go to the uncaught exception handler (when you don't have provided one explicitly, the default one will just print the stack trace to System.err). If you submitted the task with submit any thrown exception, checked or not, is then part of the task's return status. For a task that was submitted with submit and that terminates with an exception, the Future.get will rethrow this exception, wrapped in an ExecutionException.

意思就是若是你在你的task裏會拋出checked或者unchecked exception，而你又但願外面的調用者可以感知這些exception並作出及時的處理，那麼就須要用到submit，經過捕獲Future.get拋出的異常。

好比說，我有不少更新各類數據的task，我但願若是其中一個task失敗，其它的task就不須要執行了。那我就須要catch Future.get拋出的異常，而後終止其它task的執行，代碼以下：

51cto上有一篇很是好的文章「Java5併發學習」（http://lavasoft.blog.51cto.com/62575/115112），下面的代碼是基於它之上修改的。

[java]  view plain copy

1. import java.util.ArrayList;  
2. import java.util.List;  
3. import java.util.Random;  
4. import java.util.concurrent.Callable;  
5. import java.util.concurrent.ExecutionException;  
6. import java.util.concurrent.ExecutorService;  
7. import java.util.concurrent.Executors;  
8. import java.util.concurrent.Future;  
9.   
10. public class ExecutorServiceTest {  
11.     public static void main(String[] args) {  
12.         ExecutorService executorService = Executors.newCachedThreadPool();  
13.         List<Future<String>> resultList = new ArrayList<Future<String>>();  
14.   
15.         // 建立10個任務並執行  
16.         for (int i = 0; i < 10; i++) {  
17.             // 使用ExecutorService執行Callable類型的任務，並將結果保存在future變量中  
18.             Future<String> future = executorService.submit(new TaskWithResult(i));  
19.             // 將任務執行結果存儲到List中  
20.             resultList.add(future);  
21.         }  
22.         executorService.shutdown();  
23.   
24.         // 遍歷任務的結果  
25.         for (Future<String> fs : resultList) {  
26.             try {  
27.                 System.out.println(fs.get()); // 打印各個線程（任務）執行的結果  
28.             } catch (InterruptedException e) {  
29.                 e.printStackTrace();  
30.             } catch (ExecutionException e) {  
31.                 executorService.shutdownNow();  
32.                 e.printStackTrace();  
33.                 return;  
34.             }  
35.         }  
36.     }  
37. }  
38.   
39. class TaskWithResult implements Callable<String> {  
40.     private int id;  
41.   
42.     public TaskWithResult(int id) {  
43.         this.id = id;  
44.     }  
45.   
46.     /** 
47.      * 任務的具體過程，一旦任務傳給ExecutorService的submit方法，則該方法自動在一個線程上執行。 
48.      *  
49.      * @return  
50.      * @throws Exception 
51.      */  
52.     public String call() throws Exception {  
53.         System.out.println("call()方法被自動調用,幹活！！！             " + Thread.currentThread().getName());  
54.         if (new Random().nextBoolean())  
55.             throw new TaskException("Meet error in task." + Thread.currentThread().getName());  
56.         // 一個模擬耗時的操做  
57.         for (int i = 999999999; i > 0; i--)  
58.             ;  
59.         return "call()方法被自動調用，任務的結果是：" + id + "    " + Thread.currentThread().getName();  
60.     }  
61. }  
62.   
63. class TaskException extends Exception {  
64.     public TaskException(String message) {  
65.         super(message);  
66.     }  
67. }  

執行的結果相似於：

[java]  view plain copy

1. call()方法被自動調用,幹活！！！             pool-1-thread-1  
2. call()方法被自動調用,幹活！！！             pool-1-thread-2  
3. call()方法被自動調用,幹活！！！             pool-1-thread-3  
4. call()方法被自動調用,幹活！！！             pool-1-thread-5  
5. call()方法被自動調用,幹活！！！             pool-1-thread-7  
6. call()方法被自動調用,幹活！！！             pool-1-thread-4  
7. call()方法被自動調用,幹活！！！             pool-1-thread-6  
8. call()方法被自動調用,幹活！！！             pool-1-thread-7  
9. call()方法被自動調用,幹活！！！             pool-1-thread-5  
10. call()方法被自動調用,幹活！！！             pool-1-thread-8  
11. call()方法被自動調用，任務的結果是：0    pool-1-thread-1  
12. call()方法被自動調用，任務的結果是：1    pool-1-thread-2  
13. java.util.concurrent.ExecutionException: com.cicc.pts.TaskException: Meet error in task.pool-1-thread-3  
14.     at java.util.concurrent.FutureTask$Sync.innerGet(FutureTask.java:222)  
15.     at java.util.concurrent.FutureTask.get(FutureTask.java:83)  
16.     at com.cicc.pts.ExecutorServiceTest.main(ExecutorServiceTest.java:29)  
17. Caused by: com.cicc.pts.TaskException: Meet error in task.pool-1-thread-3  
18.     at com.cicc.pts.TaskWithResult.call(ExecutorServiceTest.java:57)  
19.     at com.cicc.pts.TaskWithResult.call(ExecutorServiceTest.java:1)  
20.     at java.util.concurrent.FutureTask$Sync.innerRun(FutureTask.java:303)  
21.     at java.util.concurrent.FutureTask.run(FutureTask.java:138)  
22.     at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:886)  
23.     at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:908)  
24.     at java.lang.Thread.run(Thread.java:619)  

能夠看見一旦某個task出錯，其它的task就中止執行。