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

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.     }  

不知道用在什么地方，业务需求没有碰到过这种情况