Java并行编程:从并行任务集获取反馈

开发 后端
要实现多线程的这种反馈,我们可以使用Callable接口。此接口的工作方式基本上与Runnable相同,但是执行方法(call())会返回一个值,该值反映了执行计算的结果。详细请看下文

在并行任务启动后,强制性地从并行任务得到反馈。

假想有一个程序,可以发送批邮件,还使用了多线程机制。你想知道有多少邮件成功发送吗?你想知道在实际发送过程期间,这个批处理工作的实时进展吗?

要实现多线程的这种反馈,我们可以使用Callable接口。此接口的工作方式基本上与Runnable相同,但是执行方法(call())会返回一个值,该值反映了执行计算的结果。

  1. package com.ricardozuasti;  
  2.  
  3. import java.util.concurrent.Callable;  
  4.  
  5. public class FictionalEmailSender implements Callable<Boolean>{  
  6.     private String to;  
  7.     private String subject;  
  8.     private String body;  
  9.     public FictionalEmailSender(String to, String subject, String body){  
  10.         this.to = to;  
  11.         this.subject = subject;  
  12.         this.body = body;  
  13.     }  
  14.  
  15.     @Override 
  16.     public Boolean call() throws InterruptedException {  
  17.         // 在0~0.5秒间模拟发送邮件  
  18.         Thread.sleep(Math.round(Math.random()*0.5*1000));  
  19.         // 假设我们有80%的几率成功发送邮件  
  20.         if(Math.random()>0.2){  
  21.             return true;  
  22.         }else{  
  23.             return false;  
  24.         }  
  25.     }  
  26.       
  27. }  

注意:Callable接口可用于返回任意数据类型,因此我们的任务可以返回我们需要的任何信息。

现在,我们使用一个线程池ExecutorService来发送邮件,由于我们的任务是以Callable接口实现的,我们提交执行的每个新任务,都会得到一个Future引用。注意我们要使用直接的构造器创建ExecutorService,而不是使用来自Executors的工具方法创建。这是因为使用指定类ThreadPoolExecutor提供了一些方法可以派上用场。

  1. package com.ricardozuasti;  
  2.  
  3. import java.util.concurrent.Future;  
  4. import java.util.concurrent.LinkedBlockingQueue;  
  5. import java.util.concurrent.ThreadPoolExecutor;  
  6. import java.util.concurrent.TimeUnit;  
  7. import java.util.ArrayList;  
  8. import java.util.List;  
  9.  
  10. public class Concurrency2 {  
  11.     public static void main(String[] args){  
  12.         try{  
  13.             ThreadPoolExecutor executor = new ThreadPoolExecutor(30301,  
  14.      TimeUnit.SECONDS, new LinkedBlockingQueue());  
  15.             List<Future<Boolean>> futures = new ArrayList<Future<Boolean>>(9000);  
  16.             // 发送垃圾邮件, 用户名假设为4位数字  
  17.             for(int i=1000; i<10000; i++){  
  18.                 futures.add(executor.submit(new FictionalEmailSender(i+"@sina.com",  
  19.                         "Knock, knock, Neo""The Matrix has you...")));  
  20.             }  
  21.             // 提交所有的任务后,关闭executor  
  22.             System.out.println("Starting shutdown...");  
  23.             executor.shutdown();  
  24.               
  25.             // 每秒钟打印执行进度  
  26.             while(!executor.isTerminated()){  
  27.                 executor.awaitTermination(1, TimeUnit.SECONDS);  
  28.                 int progress = Math.round((executor.getCompletedTaskCount()  
  29. *100)/executor.getTaskCount());  
  30.                 System.out.println(progress + "% done (" +   
  31. executor.getCompletedTaskCount() + " emails have been sent).");  
  32.             }  
  33.             // 现在所有邮件已发送完, 检查futures, 看成功发送的邮件有多少  
  34.             int errorCount = 0;  
  35.             int successCount = 0;  
  36.             for(Future<Boolean> future : futures){  
  37.                 if(future.get()){  
  38.                     successCount++;  
  39.                 }else{  
  40.                     errorCount++;  
  41.                 }  
  42.             }  
  43.             System.out.println(successCount + " emails were successfully sent, but " +  
  44.                     errorCount + " failed.");  
  45.         }catch(Exception ex){  
  46.             ex.printStackTrace();  
  47.         }  
  48.     }  
  49. }  

执行这个类,输出结果如下:

  1. Starting shutdown...  
  2. 1% done (118 emails have been sent).  
  3. 2% done (232 emails have been sent).  
  4. 3% done (358 emails have been sent).  
  5. 5% done (478 emails have been sent).  
  6. 6% done (587 emails have been sent).  
  7. 7% done (718 emails have been sent).  
  8. 9% done (850 emails have been sent).  
  9. 10% done (969 emails have been sent).  
  10. ……  

所有的任务都由ExecutorService提交,我们开始它的关闭(防止提交新任务)并使用一个循环(实时场景,可能你会继续做其它的事情)来等待,直至所有任务都被执行完成、计算和打印当前每次迭代的进度。

注意,你可以存储executor引用,也可以在任意时间从其它线程查询它的计算结果和报告进程进度。

最后,使用Future集合引用,我们得到ExecutorService提交的每个Callable接口,通知成功发送的邮件数量和发送失败的邮件数量。

此结构不但易于使用,还使得相关性得到清晰的隔离,在调度程序和实际任务之间提供了一个预定义的通信机制。

原文链接:http://blog.csdn.net/chszs/article/details/7418880

【编辑推荐】

  1. Java反射机制初探
  2. 不再纠结Java中的String类
  3. Java中常见IO的读写效率对比
  4. 栈的Java实现和栈的应用举例
  5. 实战是硬道理:记Java技术面试
责任编辑:林师授 来源: chszs的博客
相关推荐

2014-02-12 13:43:50

代码并行任务

2010-06-02 08:53:51

.NET 4并行编程

2012-04-10 10:04:26

并行编程

2009-05-13 15:38:45

微软并行语言Axum

2017-04-13 19:20:18

Python代码并行任务

2023-11-08 09:36:01

Java编程

2010-03-26 19:03:19

F#异步并行模式

2021-09-09 07:16:00

C#多线程开发

2015-10-13 09:18:00

.Net编程教程

2010-06-04 09:11:10

.NET并行编程

2011-09-22 09:41:16

JavaScript

2022-04-26 08:41:38

Swift并发系统iOS

2023-11-01 20:10:53

分布式并行技术

2010-06-08 08:41:08

.NET 4并行编程

2018-06-14 09:38:53

Linux多核编程

2010-06-07 08:43:46

.NET 4并行编程

2012-10-10 09:14:50

PHPRPCPHP框架

2022-10-20 23:15:10

PostgreSQL算法机制

2012-02-01 09:28:02

Java

2013-07-09 09:20:23

JPPFJava并行处理框架
点赞
收藏

51CTO技术栈公众号