• 并行程序设计模式--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 
    20     public Master(Worker worker,int countWorker) {
    21         worker.setResultMap(resultMap);
    22         worker.setWorkQueue(workQueue);
    23         for (int i = 0; i < countWorker; i++) {
    24             threadMap.put(Integer.toString(i), new Thread(worker,Integer.toString(i)));
    25         }
    26     }
    27     
    28     //提交任务
    29     
    30     public void submit(Object obj){
    31         workQueue.add(obj);
    32         //System.out.println(obj.toString());
    33     }
    34 
    35     
    36     
    37     //返回子任务结果集
    38     public Map<String, Object> getResultMap() {
    39         return resultMap;
    40     }
    41     
    42     //开始运行所有worker进程,并进行处理
    43     
    44     public void execute(){
    45         for(Map.Entry<String, Thread> entry:threadMap.entrySet()){
    46             entry.getValue().start();
    47         }
    48     }
    49     
    50 }

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

      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 
    3     @Override
    4     public Object handle(Object input) {
    5         Integer i = (Integer) input;
    6         return i*i*i;
    7     }
    8     
    9 }

      客户端代码如下:

     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线程全部终止,才能求出最终结果。

  • 相关阅读:
    js获取对象的最后一个
    vue UI框架
    从前端和后端两个角度分析jsonp跨域访问(完整实例)
    Ajax跨域访问解决方案
    js中将字符串转换成json的三种方式
    【转载】COM 组件设计与应用(九)——IDispatch 接口 for VC6.0
    【转载】COM 组件设计与应用(八)——实现多接口
    【转载】COM 组件设计与应用(七)——编译、注册、调用
    【转载】COM 组件设计与应用(六)——用 ATL 写第一个组件
    【转载】COM 组件设计与应用(五)——用 ATL 写第一个组件
  • 原文地址:https://www.cnblogs.com/lcngu/p/5309101.html
Copyright © 2020-2023  润新知