轉自：https://blog.csdn.net/linchunquan/article/details/22382487

FutureTask可用於非同步獲取執行結果或取消執行任務的場景。通過傳入Runnable或者Callable的任務給FutureTask，直接呼叫其run方法或者放入執行緒池執行，之後可以在外部通過FutureTask的get方法非同步獲取執行結果，因此，FutureTask非常適合用於耗時的計算，主執行緒可以在完成自己的任務後，再去獲取結果。另外，FutureTask還可以確保即使呼叫了多次run方法，它都只會執行一次Runnable或者Callable任務，或者通過cancel取消FutureTask的執行等。

1. FutureTask執行多工計算的使用場景

利用FutureTask和ExecutorService，可以用多執行緒的方式提交計算任務，主執行緒繼續執行其他任務，當主執行緒需要子執行緒的計算結果時，在非同步獲取子執行緒的執行結果。

1. package futuretask;  
2. import java.util.ArrayList;  
3. import java.util.List;  
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.FutureTask;  
9. publicclass FutureTaskForMultiCompute {  
10.     publicstaticvoid main(String[] args) {  
11.         FutureTaskForMultiCompute inst=new FutureTaskForMultiCompute();  
12.         // 建立任務集合
13.         List<FutureTask<Integer>> taskList = new
     ArrayList<FutureTask<Integer>>();  
14.         // 建立執行緒池
15.         ExecutorService exec = Executors.newFixedThreadPool(5);  
16.         for (int i = 0; i < 10; i++) {  
17.             // 傳入Callable物件建立FutureTask物件
18.             FutureTask<Integer> ft = new FutureTask<Integer>(inst.new ComputeTask(i, ""+i));  
19.             taskList.add(ft);  
20.             // 提交給執行緒池執行任務，也可以通過exec.invokeAll(taskList)一次性提交所有任務;
21.             exec.submit(ft);  
22.         }  
23.         System.out.println("所有計算任務提交完畢, 主執行緒接著幹其他事情！");  
24.         // 開始統計各計算執行緒計算結果
25.         Integer totalResult = 0;  
26.         for (FutureTask<Integer> ft : taskList) {  
27.             try {  
28.                 //FutureTask的get方法會自動阻塞,直到獲取計算結果為止
29.                 totalResult = totalResult + ft.get();  
30.             } catch (InterruptedException e) {  
31.                 e.printStackTrace();  
32.             } catch (ExecutionException e) {  
33.                 e.printStackTrace();  
34.             }  
35.         }  
36.         // 關閉執行緒池
37.         exec.shutdown();  
38.         System.out.println("多工計算後的總結果是:" + totalResult);  
39.     }  
40.     privateclass ComputeTask implements Callable<Integer> {  
41.         private Integer result = 0;  
42.         private String taskName = "";  
43.         public ComputeTask(Integer iniResult, String taskName){  
44.             result = iniResult;  
45.             this.taskName = taskName;  
46.             System.out.println("生成子執行緒計算任務: "+taskName);  
47.         }  
48.         public String getTaskName(){  
49.             returnthis.taskName;  
50.         }  
51.         @Override
52.         public Integer call() throws Exception {  
53.             // TODO Auto-generated method stub
54.             for (int i = 0; i < 100; i++) {  
55.                 result =+ i;  
56.             }  
57.             // 休眠5秒鐘，觀察主執行緒行為，預期的結果是主執行緒會繼續執行，到要取得FutureTask的結果是等待直至完成。
58.             Thread.sleep(5000);  
59.             System.out.println("子執行緒計算任務: "+taskName+" 執行完成!");  
60.             return result;  
61.         }  
62.     }  
63. }  

2. FutureTask在高併發環境下確保任務只執行一次

在很多高併發的環境下，往往我們只需要某些任務只執行一次。這種使用情景FutureTask的特性恰能勝任。舉一個例子，假設有一個帶key的連線池，當key存在時，即直接返回key對應的物件；當key不存在時，則建立連線。對於這樣的應用場景，通常採用的方法為使用一個Map物件來儲存key和連線池對應的對應關係，典型的程式碼如下面所示：

1. private Map<String, Connection> connectionPool = new HashMap<String, Connection>();  
2. private ReentrantLock lock = new ReentrantLock();  
3. public Connection getConnection(String key){  
4.     try{  
5.         lock.lock();  
6.         if(connectionPool.containsKey(key)){  
7.             return connectionPool.get(key);  
8.         }  
9.         else{  
10.             //建立 Connection
11.             Connection conn = createConnection();  
12.             connectionPool.put(key, conn);  
13.             return conn;  
14.         }  
15.     }  
16.     finally{  
17.         lock.unlock();  
18.     }  
19. }  
20. //建立Connection
21. private Connection createConnection(){  
22.     returnnull;  
23. }  

1. private ConcurrentHashMap<String,FutureTask<Connection>>connectionPool = new ConcurrentHashMap<String, FutureTask<Connection>>();  
2. public Connection getConnection(String key) throws Exception{  
3.     FutureTask<Connection>connectionTask=connectionPool.get(key);  
4.     if(connectionTask!=null){  
5.         return connectionTask.get();  
6.     }  
7.     else{  
8.         Callable<Connection> callable = new Callable<Connection>(){  
9.             @Override
10.             public Connection call() throws Exception {  
11.                 // TODO Auto-generated method stub
12.                 return createConnection();  
13.             }  
14.         };  
15.         FutureTask<Connection>newTask = new FutureTask<Connection>(callable);  
16.         connectionTask = connectionPool.putIfAbsent(key, newTask);  
17.         if(connectionTask==null){  
18.             connectionTask = newTask;  
19.             connectionTask.run();  
20.         }  
21.         return connectionTask.get();  
22.     }  
23. }