JAVA 并发编程-返回执行结果(Callable和Future)(九)
发布日期:2022-01-11 03:09:54 浏览次数:2 分类:技术文章

本文共 1744 字,大约阅读时间需要 5 分钟。

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

   public void run(){}

 

解决方案:

 

CallableFuture,一个产生结果,一个拿到结果。

 

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

[java]
  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要采用ExecutorServicesubmit方法提交,返回为future对象

 

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

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

 

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

[java]
  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

转载地址:https://yuki-ho.blog.csdn.net/article/details/52316409 如侵犯您的版权,请留言回复原文章的地址,我们会给您删除此文章,给您带来不便请您谅解!

上一篇:JAVA 并发编程-线程同步通信技术(Lock和Condition)(十)
下一篇:JAVA 并发编程-基于线程池设计的ScheduledExecutor(八)

发表评论

最新留言

不错!
[***.144.177.141]2024年04月21日 23时45分01秒