Java多线程 - Master/Worker模式

1.什么是Master/Worker模式?

Master-Worker模式是常用的并行模式之一。它的核心思想是，系统由两类进程协作工作：Master进程和Worker进程。Master进程负责接收和分配任务，Worker进程负责处理子任务。当各个Worker进程将子任务处理完成后，将结果返回给Master进程，由Master进程做归纳和汇总，从而得到系统的最终结果，其处理过程如下图所示

Master-Worker模式的好处，它能够将一个大任务分解成若干个小任务，并且执行，从而提高系统的吞吐量。而对于系统请求者Client来说，任务一旦提交，Master进程会分配任务并立即返回，并不会等待系统全部处理完成后再返回，其处理过程是异步的。因此Client不会出现等待现象。

2.怎么学习Master/Worker模式？

2.1.Master-Worker的实现

首先Master类为主要进程，它维护了一个Worker进程队列、子任务队列和子结果集。Worker进程队列中的Worker进程，不停地从任务队列中提取要处理的子任务，并将子任务的处理结果写入结果集。

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 {
	//1.有一个盛放任务的容器
	private Queue<Object> taskQueue = new ConcurrentLinkedQueue<>();
	
	//2.盛放worker的集合
	private Map<String,Thread> workerThread = new HashMap<>();
	
	//3.任务处理结果集合
	private Map<String,Object> resultMap = new ConcurrentHashMap<>();
	
	//4.Master的构造,需要一个Worker进程逻辑，和需要的Worker进程数量
	public Master(Worker worker,int workerCount) {
		worker.setTaskQueue(taskQueue);
		worker.setResultMap(resultMap);
		
		for (int i = 0; i < workerCount; i++) {
			this.workerThread.put(Integer.toString(i), new Thread(worker,"MyWorker-"+i));
		}
	}
	
	//5.提交任务
	public void submit(Object task) {
		this.taskQueue.add(task);
	}
	
	//6.启动所有的worker进程
	public void execute() {
		for(Map.Entry<String, Thread> entry : this.workerThread.entrySet()) {
			entry.getValue().start();
		}
	}
	
	//7.是否所任务结束
	public boolean isComplete() {
		for(Map.Entry<String, Thread> entry : this.workerThread.entrySet()) {
			if(entry.getValue().getState() != Thread.State.TERMINATED) {
				return false;
			}	
		}
		return true;
	}
	
	//8.返回子任务结果
	public Map<String,Object> getResultMap() {
		return this.resultMap;
	}
}

对应的Worker进程的代码实现：

import java.util.Map;
import java.util.Queue;

public class Worker implements Runnable {
	
	//1.任务队列，用于取得子任务
	private Queue<Object> taskQueue;
	
	//2.子任务处理结果集
	private Map<String,Object> resultMap;
	
	public void setTaskQueue(Queue<Object> taskQueue) {
		this.taskQueue = taskQueue;
	}

	public void setResultMap(Map<String, Object> resultMap) {
		this.resultMap = resultMap;
	}

	//3.子任务处理逻辑,返回处理结果
	public Object handle(Object task) {
		Object result = null;
		try {
			//处理任务的耗时。。 比如说进行操作数据库。。。
			Thread.sleep(500);
			result = task;
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		return result;
	}

	@Override
	public void run() {
		while(true) {
			//获取子任务，poll()方法取出（并删除）队首的对象
			Object task = this.taskQueue.poll();
			if(null == task) {
				break;
			}
			Object result = handle(task);
			this.resultMap.put(Integer.toString(task.hashCode()), result);
		}
	}

}

以上两段代码已经展示了Master-Worker框架的全貌。应用程序通过重载 Worker.handle() 方法实现应用层逻辑。

例如，要实现计算1+2+..+100的立方和结果，代码如下：

puimport java.util.Map;

public class CubeWorker extends Worker {
	
	public Object handle(Object task) {
		Integer result = (Integer)task;
		
		return result*result*result;
	}
	public static void main(String[] args) {
		Master master = new Master(new CubeWorker(), 5);
		
		//产生100个任务
		for (int i = 1; i <= 100; i++) {
			master.submit(i);
		}
		master.execute();
		
		int result = 0;
		
		Map<String,Object> resultMap = master.getResultMap();
		while(resultMap.size()>0 || !master.isComplete()) {
			int re = 0;
			String key = null;
			for(Map.Entry<String, Object> entry : resultMap.entrySet()) {
				key = entry.getKey();
				//从结果集中获取结果
				re = (Integer)entry.getValue();
				if(re > 0) {
					//最终结果
					result += re;
					break;
				}
			}
			if(null != key) {
				//移除已经被计算过的项
				resultMap.remove(key);
			}
		}
		System.out.println("result: " + result);
	}
}

在应用层代码中，创建了5个Worker工作进程和Worker工作实例PlusWorker。在提交了100个子任务后，便开始子任务的计算。这些子任务中，由生成的5个Worker进程共同完成。Master并不等待所有的Worker执行完毕，就开始访问子结果集进行最终结果的计算，直到子结果集中所有的数据都被处理，并且5个活跃的Worker进程全部终止，才给出最终计算结果。 

2.2 Amino框架提供的Master-Worker模式

在Amino框架中为Master-Worker模式提供了较为完善的实现和便捷的操作接口。Amino实现了两套Master-Worker实现：一种是静态的Master-Worker实现，另一种是动态实现。静态实现不允许在任务开始时添加新的子任务，而动态的Master-Worker允许在任务执行过程中，由MasterWorker添加新的子任务。

在Amino框架中，MasterWorkerFactory.newStatic()用于创建静态的Master-Worker模式，MasterWorkerFactory.newDynamic()用于创建动态的Master-Worker模式；submit()方法用于提交应用层任务，execute()方法将执行所有任务。

Amino框架需要自行下载，下载地址：https://sourceforge.net/projects/amino-cbbs/files/cbbs/0.5.3/，找到cbbs-java-bin-0.5.3.tar.gz 下载即可。

下面用Amino框架演示计算1+2+..+100的立方和结果完整示例。

import java.util.List;
import java.util.Vector;

import org.amino.pattern.internal.Doable;
import org.amino.pattern.internal.MasterWorker;
import org.amino.pattern.internal.MasterWorkerFactory;

public class CubeStatic implements Doable<Integer, Integer> {

	@Override
	public Integer run(Integer task) {
		// TODO Auto-generated method stub
		return task*task*task;
	}
	
	public static void main(String[] args) {
		MasterWorker<Integer, Integer> mw = MasterWorkerFactory.newStatic(new CubeStatic(), 10);
		//存放所有task对应的key
		List<MasterWorker.ResultKey> resultKeys = new Vector<>();
		for (int i = 1; i <= 100; i++) {
			//提交task到master调度，并产生task对应的key
			resultKeys.add(mw.submit(i));
		}
		//执行所有任务
		mw.execute();
		
		//最终执行结果
		int result = 0;
		
		//不等待全部执行完成，就开始求立方和
		while(resultKeys.size()>0) {
			MasterWorker.ResultKey k = resultKeys.get(0);
			//获取完成了的结果
			Integer completeRs = mw.result(k);
			if(null != completeRs) {
				result += completeRs;
				resultKeys.remove(0);
			}
		}
		System.out.println("result: " + result);
		mw.shutdown();
	}
}

import java.util.List;
import java.util.Vector;

import org.amino.pattern.internal.DynamicWorker;
import org.amino.pattern.internal.MasterWorker;
import org.amino.pattern.internal.MasterWorkerFactory;
import org.amino.pattern.internal.WorkQueue;

public class CubeDyn implements DynamicWorker<Integer, Integer>{

	@Override
	public Integer run(Integer w, WorkQueue<Integer> wq) {
		// TODO Auto-generated method stub
		return w*w*w;
	}
	
	public static void main(String[] args) {
		MasterWorker<Integer,Integer> mw = MasterWorkerFactory.newDynamic(new CubeDyn());
		List<MasterWorker.ResultKey> resultKeys = new Vector<>();
		for (int i = 1; i <= 50; i++) {
			resultKeys.add(mw.submit(i));
		}
		mw.execute();
		for (int i = 51; i <= 100; i++) {
			resultKeys.add(mw.submit(i));
		}
		//最终执行结果
		int result = 0;
		
		//不等待全部执行完成，就开始求立方和
		while(resultKeys.size()>0) {
			MasterWorker.ResultKey k = resultKeys.get(0);
			//获取完成了的结果
			Integer completeRs = mw.result(k);
			if(null != completeRs) {
				result += completeRs;
				resultKeys.remove(0);
			}
		}
		System.out.println("result: " + result);
		mw.shutdown();
	}

}