并行设计模式-Master/Worker

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

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

其核心框架如下：

Master部分实现代码

[java]  view plain copy print ?

1. package com.yf.designpattern.masterworker;  
2.   
3. import java.util.HashMap;  
4. import java.util.Map;  
5. import java.util.Queue;  
6. import java.util.concurrent.ConcurrentHashMap;  
7. import java.util.concurrent.ConcurrentLinkedQueue;  
8.   
9. public class Master {  
10.     //任务队列，保存所有的任务  
11.     protected Queue<Object> workQueue = new ConcurrentLinkedQueue<Object>();  
12.     //Worker进程队列  
13.     protected Map<String,Thread> threadMap=new HashMap<String,Thread>();  
14.       
15.     //任务处理结果集  
16.     protected Map<String,Object> resultMap=new ConcurrentHashMap<String,Object>();  
17.       
18.     //判断是否所有子任务都完成了  
19.     public boolean isComplete(){  
20.         for(Map.Entry<String, Thread> entry:threadMap.entrySet()){  
21.             if(entry.getValue().getState()!=Thread.State.TERMINATED){  
22.                 return false;  
23.             }  
24.         }  
25.         return true;  
26.     }  
27.       
28.     //Master的构造，需要一个Worker进程实例，和需要的worker进程数量  
29.     public Master(Worker worker,int count){  
30.         worker.setResultMap(resultMap);  
31.         worker.setWorkQueue(workQueue);  
32.         for(int i=0;i<count;i++){  
33.             threadMap.put(Integer.toString(i),new Thread(worker,Integer.toString(i)));  
34.         }  
35.     }  
36.     //提交一个任务  
37.     public void submit(Object job){  
38.         workQueue.add(job);  
39.     }  
40.     //返回子任务结果集  
41.     public Map<String,Object> getResultMap(){  
42.         return resultMap;  
43.     }  
44.       
45.     //开始运行所有的Worker进程，进行处理  
46.     public void execute(){  
47.         for(Map.Entry<String, Thread> entry:threadMap.entrySet()){  
48.             entry.getValue().start();  
49.         }  
50.     }  
51. }  

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

Worker的主要结构如下：

[java]  view plain copy print ?

1. package com.yf.designpattern.masterworker;  
2.   
3. import java.util.Map;  
4. import java.util.Queue;  
5.   
6. public class Worker implements Runnable {  
7.     // 任务队列，用于取得子任务  
8.     protected Queue<Object> workQueue;  
9.     // 子任务处理结果集  
10.     protected Map<String, Object> resultMap;  
11.   
12.     public void setWorkQueue(Queue<Object> workQueue) {  
13.         this.workQueue = workQueue;  
14.     }  
15.   
16.     public void setResultMap(Map<String, Object> resultMap) {  
17.         this.resultMap = resultMap;  
18.     }  
19.   
20.     // 子类处理的业务逻辑，在子类中实现具体逻辑  
21.     public Object handle(Object input) {  
22.         return input;  
23.     }  
24.   
25.     @Override  
26.     public void run() {  
27.         while (true) {  
28.             //获取子任务  
29.             Object input = this.workQueue.poll();  
30.             if (input == null)  
31.                 break;  
32.             //处理子任务  
33.             Object re = this.handle(input);  
34.             //将处理结果写回结果集  
35.             this.resultMap.put(Integer.toString(input.hashCode()), re);  
36.         }  
37.   
38.     }  
39.   
40. }  

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 plain copy print ?

1. package com.yf.designpattern.masterworker;  
2.   
3. public class PlusWorker extends Worker {  
4.       
5.     @Override  
6.     public Object handle(Object input){  
7.         Integer i=(Integer)input;  
8.         return i*i*i;  
9.     }  
10. }  

测试代码如下：

[java]  view plain copy print ?

1. package com.yf.designpattern.masterworker;  
2.   
3. import java.util.Map;  
4. import java.util.Set;  
5.   
6. public class Main {  
7.   
8.     public static void main(String[] args) {  
9.         //实例化一个有5个Worker的Master  
10.         long start=System.currentTimeMillis();  
11.         Master m=new Master(new PlusWorker(),5);  
12.         for(int i=0;i<=1000;i++){  
13.             m.submit(i);  
14.         }  
15.         m.execute();  
16.         int re=0;  
17.         Map<String,Object> resultMap=m.getResultMap();  
18.         //只要有一个Worker计算完成，则开始计算  
19.         while(resultMap.size()>0||!m.isComplete()){  
20.             Set<String> keys=resultMap.keySet();  
21.             String key=null;  
22.             //每次获取一个结果  
23.             for(String k:keys){  
24.                 key=k;  
25.                 break;  
26.             }  
27.             Integer i=null;  
28.             if(key!=null){  
29.                 i=(Integer)resultMap.get(key);  
30.                 //将结果相加  
31.                 if(i!=null){  
32.                     re+=i;  
33.                 }  
34.                 //删除已经计算过的子结果  
35.                 resultMap.remove(key);  
36.             }  
37.         }  
38.         long time=System.currentTimeMillis()-start;  
39.         System.out.println("The result is:"+re+",time:"+time);  
40.     }  
41.