并行设计模式-Master/Worker

Master-Worker设计模式核心思想是将原来串行的逻辑并行化，并将逻辑拆分成很多独立模块并行执行,其中主要包含两个主要组件Master和Worker，Master主要讲逻辑进行查分，拆分为互相独立的部分，同时维护了Worker队列，将每个独立部分下发到多个Worker并行执行，Worker主要进行实际逻辑

计算，并将结果返回给Master。

其核心框架如下：

Master部分实现代码

package com.yf.designpattern.masterworker;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 Map<String,Object> resultMap=new ConcurrentHashMap<String,Object>();//判断是否所有子任务都完成了public boolean isComplete(){for(Map.Entry<String, Thread> entry:threadMap.entrySet()){if(entry.getValue().getState()!=Thread.State.TERMINATED){return false;}}return true;}//Master的构造，需要一个Worker进程实例，和需要的worker进程数量public Master(Worker worker,int count){worker.setResultMap(resultMap);worker.setWorkQueue(workQueue);for(int i=0;i<count;i++){threadMap.put(Integer.toString(i),new Thread(worker,Integer.toString(i)));}}//提交一个任务public void submit(Object job){workQueue.add(job);}//返回子任务结果集public Map<String,Object> getResultMap(){return resultMap;}//开始运行所有的Worker进程，进行处理public void execute(){for(Map.Entry<String, Thread> entry:threadMap.entrySet()){entry.getValue().start();}}}

Master主要维护了任务队列、Worker队列、结果队列和开启工作线程，添加任务等逻辑，可以通过Master添加任务，获取结果，具体任务执行过程在Worker

Worker的主要结构如下：

package com.yf.designpattern.masterworker;import java.util.Map;import java.util.Queue;public class Worker implements Runnable {// 任务队列，用于取得子任务protected Queue<Object> workQueue;// 子任务处理结果集protected Map<String, Object> resultMap;public void setWorkQueue(Queue<Object> workQueue) {this.workQueue = workQueue;}public void setResultMap(Map<String, Object> resultMap) {this.resultMap = resultMap;}// 子类处理的业务逻辑，在子类中实现具体逻辑public Object handle(Object input) {return input;}@Overridepublic void run() {while (true) {//获取子任务Object input = this.workQueue.poll();if (input == null)break;//处理子任务Object re = this.handle(input);//将处理结果写回结果集this.resultMap.put(Integer.toString(input.hashCode()), re);}}}

Worker主要是从Master的任务队列中获取一个任务，并且执行，将结果保存到Master的ResultMap中，每个Worker都持有Master的工作队列和ResultMap。

以上就是Master-Worker模式的核心框架，还可以将上述框架进行扩展，扩展为分布式结构，Master与Worker分布在不同机器，Master与Worker之间通过一定协议来进行通信，同时Worker还可以水平扩展为多台，能够支撑大压力、高并发需求。

例如现在需要计算1到100，每个数字的立方相加的结果

这里可以将计算立方的逻辑交个每个Worker去执行，Worker计算完成后，将结果保存到Master的ResultMap中，Master只需要检查ResultMap是否有元素，有就进行相加计算，而不用等待每个数字都计算完成，

Worker的具体实现如下：

package com.yf.designpattern.masterworker;public class PlusWorker extends Worker {@Overridepublic Object handle(Object input){Integer i=(Integer)input;return i*i*i;}}

测试代码如下：

package com.yf.designpattern.masterworker;import java.util.Map;import java.util.Set;public class Main {public static void main(String[] args) {//实例化一个有5个Worker的Masterlong start=System.currentTimeMillis();Master m=new Master(new PlusWorker(),5);for(int i=0;i<=1000;i++){m.submit(i);}m.execute();int re=0;Map<String,Object> resultMap=m.getResultMap();//只要有一个Worker计算完成，则开始计算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;}//删除已经计算过的子结果resultMap.remove(key);}}long time=System.currentTimeMillis()-start;System.out.println("The result is:"+re+",time:"+time);}}