linux 并行 模式,并行设计模式-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 workQueue = new ConcurrentLinkedQueue();
//Worker进程队列
protected Map threadMap=new HashMap();
//任务处理结果集
protected Map resultMap=new ConcurrentHashMap();
//判断是否所有子任务都完成了
public boolean isComplete(){
for(Map.Entry 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
threadMap.put(Integer.toString(i),new Thread(worker,Integer.toString(i)));
}
}
//提交一个任务
public void submit(Object job){
workQueue.add(job);
}
//返回子任务结果集
public Map getResultMap(){
return resultMap;
}
//开始运行所有的Worker进程，进行处理
public void execute(){
for(Map.Entry 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 workQueue;
// 子任务处理结果集
protected Map resultMap;
public void setWorkQueue(Queue workQueue) {
this.workQueue = workQueue;
}
public void setResultMap(Map 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的具体实现如下：
package com.yf.designpattern.masterworker;
public class PlusWorker extends Worker {
@Override
public 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的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 resultMap=m.getResultMap();
//只要有一个Worker计算完成，则开始计算
while(resultMap.size()>0||!m.isComplete()){
Set 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);
}
}