并行设计模式-Master/Worker

来源：互联网发布：迪杰斯特拉算法步骤编辑：程序博客网时间：2024/06/09 18:21

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

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

其核心框架如下：

Master部分实现代码

[java] view plaincopyprint?
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的主要结构如下：

[java] view plaincopyprint?
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;  
    }  
  
    @Override  
    public 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的具体实现如下：

[java] view plaincopyprint?
package com.yf.designpattern.masterworker;  
  
public class PlusWorker extends Worker {  
      
    @Override  
    public Object handle(Object input){  
        Integer i=(Integer)input;  
        return i*i*i;  
    }  
}  

测试代码如下：

[java] view plaincopyprint?
package com.yf.designpattern.masterworker;  
  
import java.util.Map;  
import java.util.Set;  
  
public class Main {  
  
    public static void main(String[] args) {  
        //实例化一个有5个Worker的Master  
        long 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);  
    }  
  

0 0