Java中的Callable和Future的使用和困惑

Java中還提供了可以返回值的線程池，例子如下：

1. import java.util.concurrent.Callable;  
2. import java.util.concurrent.ExecutionException;  
3. import java.util.concurrent.ExecutorService;  
4. import java.util.concurrent.Executors;  
5. import java.util.concurrent.Future;  
6.   
7. public class CallableAndFuture {  
8.   
9.     /** 
10.      * @param args 
11.      */  
12.     public static void main(String[] args) {  
13.         ExecutorService threadPool = Executors.newSingleThreadExecutor();  
14.         Future<String> future = threadPool.submit(new Callable<String>(){  
15.   
16.             @Override  
17.             public String call() throws Exception {  
18.                 Thread.sleep(3000);  
19.                 return "future";  
20.             }  
21.               
22.         });  
23.         try {  
24.             System.out.println("waiting...");  
25.             System.out.println(future.get());  
26.         } catch (InterruptedException e) {  
27.             e.printStackTrace();  
28.         } catch (ExecutionException e) {  
29.             e.printStackTrace();  
30.         }  
31.     }  
32.   
33. }  

future.get()結果出來之前，要等待一會

future.get(300, TimeUnit.MILLISECONDS);然而這個如果在規定的時間內沒有完成，則停止，並且跑出超時異常

還有需要注意的地方，Callable中的泛型和call方法的類型一直，並且還要和Future的泛型類型一致。

下面的例子是，可以返回多個Future對象

1. //創建線程池   
2.         ExecutorService pool = Executors.newFixedThreadPool(10);  
3.         //創建CompletionService實例   
4.         CompletionService<Integer> completionService = new ExecutorCompletionService<Integer>(pool);  
5.         //提交任務   
6.         for(int i = 0;i < 10; i++){  
7.             final int index = i;  
8.             completionService.submit(new Callable<Integer>(){  
9.   
10.                 @Override  
11.                 public Integer call() throws Exception {  
12.                     return index;  
13.                 }  
14.                   
15.             });  
16.         }  
17.         //獲得結果   
18.         for(int i = 0;i<10;i++){  
19.             try {  
20.                 Future<Integer> future2 = completionService.take();  
21.                 System.out.println(future2.get());  
22.             } catch (InterruptedException e) {  
23.                 e.printStackTrace();  
24.             } catch (ExecutionException e) {  
25.                 e.printStackTrace();  
26.             }  
27.         }  
28.     }  

不知道用在什麼地方，業務需求沒有碰到過這種情況