java并发多线程-返回执行结果（Callable和Future）（9）

 启动一个线程不论使用Thread或者Runnable的时候，都是没有返回结果的。也就是说Thread和Runnable的run()方法必须没有返回值。

   public void run(){}

 

解决方案：

 

Callable和Future，一个产生结果，一个拿到结果。

 

简单的来一个实例demo帮助我们理解：

[java]  view plain  copy

 print ?

1. public class CallableAndFuture {  
2.   
3.     /** 
4.      * @param args 
5.      */  
6.     public static void main(String[] args) {  
7.         //单一线程的线程池  
8.         ExecutorService threadPool =  Executors.newSingleThreadExecutor();  
9.         Future<String> future =  
10.             threadPool.submit(  
11.                 new Callable<String>() {  
12.                     public String call() throws Exception {  
13.                         Thread.sleep(2000);  
14.                         return "hello";  
15.                     };  
16.                 }  
17.         );  
18.         System.out.println("等待结果");  
19.         try {  
20.             System.out.println("拿到结果" + future.get());  
21.         } catch (InterruptedException e) {  
22.             e.printStackTrace();  
23.         } catch (Exception e) {  
24.             e.printStackTrace();  
25.         }  
26.           
27.     }  
28.       
29.   
30. }  

执行结果：

 

等待结果

拿到结果hello 

 

使用场景：

 

假设有一个很耗时的返回值需要计算，并且这个返回值不是立刻需要的话，那么就可以使用以上这种方式，用另一个线程去计算返回值，而当前线程在使用这个返回值之前可以做其它的操作，等到需要这个返回值时，再通过Future得到！

 

说明：

 

Future取得的结果类型和Callable返回的结果类型必须一致，这是通过泛型来实现的

Callable要采用ExecutorService的submit方法提交，返回为future对象

 

CompletionService用于提交一组Callable任务，其take方法返回已完成的一个Callable任务对应的Future对象

好比我同时种了几块地的麦子，然后就等待收割，收割时，哪块先成熟，则先收割哪块

 

下面我们来针对CompletionService看一个小demo

[java]  view plain  copy

 print ?

1. public class CallableAndFuture {  
2.   
3.     /** 
4.      * @param args 
5.      */  
6.     public static void main(String[] args) {  
7.           
8.         ExecutorService threadPool2 =  Executors.newFixedThreadPool(10);  
9.         CompletionService<Integer> completionService = new ExecutorCompletionService<Integer>(threadPool2);  
10.         for(int i=1;i<=10;i++){  
11.             final int seq = i;  
12.             completionService.submit(new Callable<Integer>() {  
13.                 @Override  
14.                 public Integer call() throws Exception {  
15.                     Thread.sleep(new Random().nextInt(5000));  
16.                     return seq;  
17.                 }  
18.             });  
19.         }  
20.         for(int i=0;i<10;i++){  
21.             try {  
22.                 System.out.println(  
23.                         completionService.take().get());  
24.             } catch (InterruptedException e) {  
25.                 e.printStackTrace();  
26.             } catch (ExecutionException e) {  
27.                 e.printStackTrace();  
28.             }  
29.         }  
30.     }  
31.       
32. }  

执行结果：

 

8

6

5

7

2

1

3

10

9

4

 

总结：

 

      对于多线程执行返回结果这种需求在实际应用中还是很少见的，此文只是作为了解学习。