Chinaunix首页 | 论坛 | 博客
  • 博客访问: 365648
  • 博文数量: 219
  • 博客积分: 0
  • 博客等级: 民兵
  • 技术积分: 2637
  • 用 户 组: 普通用户
  • 注册时间: 2013-02-03 17:32
文章分类

全部博文(219)

文章存档

2018年(8)

2017年(1)

2016年(26)

2015年(41)

2014年(15)

2013年(128)

我的朋友

分类: Java

2017-02-04 10:49:08

并行程序设计模式--Master-Worker模式

  • 简介

  Master-Worker模式是常用的并行设计模式。它的核心思想是,系统有两个进程协议工作:Master进程和Worker进程。Master进程负责接收和分配任务,Worker进程负责处理子任务。当各个Worker进程将子任务处理完后,将结果返回给Master进程,由Master进行归纳和汇总,从而得到系统结果。处理过程如下图:

Master-Worker模式的好处是,它能将大任务分解成若干个小任务,并发执行,从而提高系统性能。而对于系统请求者Client来说,任务一旦提交,Master进程就会立刻分配任务并立即返回,并不会等系统处理完全部任务再返回,其处理过程是异步的。

  • Master-Worker模式结构

  Master-Worker模式的主要结构如下图:

  如上图所示,Master进程是主要进程,它维护着一个Worker进程队列、子任务队列和子结果集,Worker进程中的Worker进程不断的从任务队列中提取要处理的子任务,并将子任务的处理结果放入到子结果集中。

  在上图中,Master:用于任务的分配和最终结果的合并;Worker:用于实际处理一个任务;客户端进程:用于启动系统,调度开启Master。

  • Master-Worker模式代码实现

  Master代码实现:

点击(此处)折叠或打开

  1. public class Master {
  2.     //任务队列
  3.     protected Queue<Object> workQueue = new ConcurrentLinkedQueue<Object>();
  4.     //worker进程队列
  5.     protected Map<String, Thread> threadMap = new HashMap<String, Thread>();
  6.     //结果集
  7.     protected Map<String, Object> resultMap = new HashMap<String,Object>();
  8.     
  9.     //是否所有的子任务都结束
  10.     
  11.     public boolean isComplete(){
  12.         for(Map.Entry<String, Thread> entry:threadMap.entrySet()){
  13.             if(entry.getValue().getState()!=Thread.State.TERMINATED){
  14.                 return false;
  15.             }
  16.         }
  17.         return true;
  18.     }

  19.     public Master(Worker worker,int countWorker) {
  20.         worker.setResultMap(resultMap);
  21.         worker.setWorkQueue(workQueue);
  22.         for (int i = 0; i < countWorker; i++) {
  23.             threadMap.put(Integer.toString(i), new Thread(worker,Integer.toString(i)));
  24.         }
  25.     }
  26.     
  27.     //提交任务
  28.     
  29.     public void submit(Object obj){
  30.         workQueue.add(obj);
  31.         //System.out.println(obj.toString());
  32.     }

  33.     
  34.     
  35.     //返回子任务结果集
  36.     public Map<String, Object> getResultMap() {
  37.         return resultMap;
  38.     }
  39.     
  40.     //开始运行所有worker进程,并进行处理
  41.     
  42.     public void execute(){
  43.         for(Map.Entry<String, Thread> entry:threadMap.entrySet()){
  44.             entry.getValue().start();
  45.         }
  46.     }
  47.     
  48. }

 Worker代码实现:

点击(此处)折叠或打开

  1. public class Worker implements Runnable {
  2.     //任务队列
  3.     protected Queue<Object> workQueue;
  4.     //子任务结果集
  5.     protected Map<String,Object> resultMap = new HashMap<String, Object>();
  6.     
  7.     
  8.     public void setWorkQueue(Queue<Object> workQueue) {
  9.         this.workQueue = workQueue;
  10.     }
  11.     public void setResultMap(Map<String, Object> resultMap) {
  12.         this.resultMap = resultMap;
  13.     }

  14.     public Object handle(Object input){
  15.         return input;
  16.     }
  17.     @Override
  18.     public void run() {
  19.         while(true){
  20.             Object input = workQueue.poll();
  21.             
  22.             if(null==input) break;
  23.             //处理子任务
  24.             Object re = handle(input);
  25.             resultMap.put(Integer.toString(input.hashCode()),re);
  26.             //System.out.println(re.toString());
  27.         }
  28.     }

  29. }

 Master-Worker模式是一种串行任务并行化的方法,被分解的子任务在系统中可以并行处理。同时,如果有需要,Master进程不需要所有子任务都执行完成,就可以根据已有的部分结果集计算最终的结果。

  现在以上面的Master-Worker实现为基础,来实现计算1-100的立方和。计算将被分解为100个子任务,每个子任务仅用于计算单独的立方和。Master产生固定数目Worker,来处理这些子任务。Worker不断的从任务集合中取出这些计算立方和的子任务,并将计算结果放入到Master的结果集中。Master负责将所有Worker的任务结果进行累加,从而产生最终的立方和。整个计算过程,Worker和Master的运算也是完全异步的,Master进程不必等所有的Worker进程都执行完成,就可以进行求和操作了。也就是所,Master在获取部分子任务的结果集时,就可以对最终结果进行计算了,从而提高了系统的并发性和吞吐量。

  计算子任务的实现如下:


点击(此处)折叠或打开

  1. public class PlusWorker extends Worker {

  2.     @Override
  3.     public Object handle(Object input) {
  4.         Integer i = (Integer) input;
  5.         return i*i*i;
  6.     }
  7.     
  8. }
客户端代码如下:

点击(此处)折叠或打开

  1. public class Client {
  2.     public static void main(String[] args) {
  3.         Master m = new Master(new PlusWorker(), 5);//启动五个线程处理
  4.         for (int i = 0; i < 100; i++) {
  5.             m.submit(i);
  6.         }
  7.         m.execute();
  8.         int re = 0;
  9.         Map<String, Object> resultMap = m.getResultMap();
  10.         while(resultMap.size()>0||!m.isComplete()){
  11.             Set<String> keys = resultMap.keySet();
  12.             String key = null;
  13.             for(String k:keys){
  14.                 key=k;
  15.                 break;
  16.             }
  17.             Integer i = null;
  18.             if(key != null){
  19.                 i = (Integer) resultMap.get(key);
  20.             }
  21.             if(i!=null){
  22.                 re+=i;//并行计算结果集
  23.             }
  24.             
  25.             if(key!=null){
  26.                 resultMap.remove(key);//将计算完成的结果移除
  27.             }
  28.         }
  29.         
  30.         System.out.println(re);
  31.     }
  32. }
通过Master创建5个Worker工作线程和PlusWorker工作实例。提交完100个任务后,就开始计算子任务。这些子任务,由生成的5个Worker线程共同完成。Master并不等所有的子任务都计算完成,就开始访问子结果集进行最终结果的计算,直到子结果集中所有的数据都被处理,并且5个活跃的Worker线程全部终止,才能求出最终结果。



阅读(150) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
评论热议
请登录后评论。

登录 注册