并发编程设计之Master-Worker模式

水深无声 2022-05-12 14:16 224阅读 0赞

## 简介 ##

**Master-Worker模式是常用的并行设计模式。它的核心思想是，系统有两个进程协议工作：Master进程和Worker进程。Master进程负责接收和分配任务，Worker进程负责处理子任务。当各个Worker进程将子任务处理完后，将结果返回给Master进程，由Master进行归纳和汇总，从而得到系统结果。处理过程如下图：**  
![在这里插入图片描述][70]

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

--------------------

#### Master-Worker模式结构 ####

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

![在这里插入图片描述][70 1]

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

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

--------------------

## Master-Worker模式代码实现 ##

**Master代码实现**：

import java.util.HashMap;
    import java.util.Map;
    import java.util.Queue;
    import java.util.concurrent.ConcurrentHashMap;
    import java.util.concurrent.ConcurrentLinkedQueue;
    
    public class Master { 
        //任务队列
        protected Queue<Object> workQueue = new ConcurrentLinkedQueue<Object>();
        //worker进程队列
        protected Map<String, Thread> threadMap = new HashMap<String, Thread>();
        //结果集(防止多线程同时读写出现线程安全问题)
        protected ConcurrentHashMap<String, Object> resultMap = new ConcurrentHashMap<String,Object>();
    
        
        /* 构造方法 */
        public Master(Worker worker,int countWorker) { 
            worker.setResultMap(resultMap);
            worker.setWorkQueue(workQueue);
            for (int i = 0; i < countWorker; i++) { 
                threadMap.put(Integer.toString(i), new Thread(worker,Integer.toString(i)));
            }
        }
    
        //提交任务
        public void submit(Object obj){ 
            workQueue.add(obj);
            //System.out.println(obj.toString());
        }
        
        //是否所有的子任务都结束
        public boolean isComplete(){ 
            for(Map.Entry<String, Thread> entry:threadMap.entrySet()){ 
                if(entry.getValue().getState()!=Thread.State.TERMINATED){ 
                    return false;
                }
            }
            return true;
        }
    
        //返回子任务结果集
        public Map<String, Object> getResultMap() { 
            return resultMap;
        }
    
        //开始运行所有worker进程，并进行处理
        public void execute(){ 
            for(Map.Entry<String, Thread> entry:threadMap.entrySet()){ 
                entry.getValue().start();
            }
        }
    
    }

**Worker代码实现：**  
**定义为抽象类，然后由不同的业务去实现其响应的handle()功能**

import java.util.Map;
    import java.util.Queue;
    import java.util.concurrent.ConcurrentHashMap;
    
    public abstract class Worker implements Runnable { 
        //任务队列
        protected Queue<Object> workQueue;
        //子任务结果集（防止线程安全问题）
        protected ConcurrentHashMap<String, Object> resultMap = new ConcurrentHashMap<String,Object>();
    
    
        public void setWorkQueue(Queue<Object> workQueue) { 
            this.workQueue = workQueue;
        }
        public void setResultMap(ConcurrentHashMap<String, Object> resultMap) { 
            this.resultMap = resultMap;
        }
    
        /* * run() */
        @Override
        public void run() { 
            while(true){ 
                Object input = workQueue.poll();
    
                if(null==input) break;
                //处理子任务
                Object re = handle(input);
                resultMap.put(Integer.toString(input.hashCode()),re);
            }
        }
    
        /* * 实际处理任务队列的方法 * 实际应用中，可以用不同业务逻辑的类继承该类，实现自己的handle方法 * */
        public abstract Object handle(Object input);
    
    }

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

--------------------

#### 需求案例： ####

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

计算子任务的实现如下：

public class PlusWorker extends Worker { 
     
         @Override
         public Object handle(Object input) { 
             Integer i = (Integer) input;
             return i*i*i;
         }
         
     }

客户端代码如下：

import java.util.Set;
    import java.util.concurrent.ConcurrentHashMap;
    
    public class Client { 
        public static void main(String[] args) { 
            /* 启动五个线程并行处理 */
            Master m = new Master(new PlusWorker(), 5);
            for (int i = 0; i < 100; i++) { 
                m.submit(i);
            }
            m.execute();
            int re = 0;
            ConcurrentHashMap<String, Object> resultMap = m.getResultMap();
            while(resultMap.size()>0||!m.isComplete()){ 
                Set<String> keys = resultMap.keySet();
                String key =  null;
                for(String k:keys){ 
                    key=k;
                    break;
                }
                Integer i = null;
                if(key != null){ 
                    i = (Integer) resultMap.get(key);
                }
                if(i!=null){ 
                    re+=i;//并行计算结果集
                }
    
                if(key!=null){ 
                    resultMap.remove(key);//将计算完成的结果移除
                }
            }
    
            System.out.println(re);
        }
    }

通过`Master`创建5个`Worker`工作线程和`PlusWorker`工作实例。提交完100个任务后，就开始计算子任务。  
`这些子任务，由生成的5个`Worker`线程共同完成，其会循环去任务队列获取任务，直至取不到任务。`  
Master并不等所有的子任务都计算完成，就开始访问子结果集进行最终结果的计算，直到子结果集中所有的数据都被处理，并且5个活跃的Worker线程全部终止，才能求出最终结果。

原文地址：https://www.cnblogs.com/lcngu/p/5309101.html

[70]: /images/20220504/dcc1f08bb28744bba41f78884336b186.png
[70 1]: /images/20220504/5df3f2f6690c44669acf3ca7cf798be1.png