Java 并发模式之Master-Worker

   注：本文摘记于《Java程序性能优化》一书，转载请注明出处。

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

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

---

---

   1.Master-Worker模式结构

    Master-Worker模式的结构相对比较简单，此处将给出一个简明的实现方式。如下图，Master进程为主要进程，它维护了一个Worker进程队列、子任务队列和子结果集。Worker进程队列中的Worker进程，不停地从人物队列中提取要处理的子任务，并将子任务的处理结构写入结果集。

  注意：Master-Worker模式是一种使用多线程进行数据处理的结构。多个Worker进程协作处理用户请求，Master进程负责维护Worker进程，并整合最终处理结果。

Master-Worker模式的主要参与者如下图表4.2所示：

---

     2.Master-Worker的代码实现

    基于以上所述的设计思路，这里给出一个简易的Master-Worker框架。其中Master部分的实现代码如下：

package com.roc.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>();

	/**
	 * Master的构造，需要一个Worker进程逻辑，和需要的Worker进程数量
	 */
	public Master(Worker worker, int countWorker)
	{
		worker.setWorkQueue(workQueue);
		worker.setResultMap(resultMap);
		for (int i = 0; i < countWorker; 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();
		}
	}

	/**
	 * 是否所有的子任务都结束了
	 */
	public boolean isComplete()
	{
		for (Map.Entry<String, Thread> entry : threadMap.entrySet())
		{
			if (entry.getValue().getState() != Thread.State.TERMINATED)
			{
				return false;
			}
		}
		return true;
	}
}

    对应的Worker进程实现如下：

package com.roc.masterworker;

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

public class Worker implements Runnable
{
	/**
	 * 任务队列，用于取得子任务
	 */
	protected Queue<Object> workerQueue;
	/**
	 * 子任务处理结果集
	 */
	protected Map<String, Object> resultMap;

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

	public void setWorkQueue(Queue<Object> workeQueue)
	{
		this.workerQueue = workeQueue;
	}

	/**
	 * 子任务的处理逻辑，在子类中实现具体逻辑
	 */
	public Object handle(Object input)
	{
		return input;
	}

	@Override
	public void run()
	{
		while (true)
		{
			// 获取子任务
			Object input = workerQueue.poll();
			if (input == null)
			{
				break;
			}
			// 处理子任务
			Object result = handle(input);
			// 将处理结果写入结果集
			resultMap.put(Integer.toString(input.hashCode()), result);
		}
	}

}

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

     注意：Master-Worker模式是一种将串行化任务并行化的方法，被分解的子任务在系统中可以被并行处理。同时，如果有需要，Master进程不需要等待所有子任务都完成计算，就可以根据已有的部分结果集计算最终结果。

---

---

     3.应用举例

    现应用这个Master-Worker框架，实现一个计算立方体和的应用并计算1~100的立方体和。即1 3 +2 3 +······+100 3 。任务分解图如图4.7所示。

    计算任务被分解为100个子任务，每个子任务仅用于计算单独的立方和。Master产生固定个数的Worker，来处理所有这些子任务。Worker不断地从任务集合中取得这些计算立方和的子任务，并将计算结果返回给Master。Master负责将所有Worker的任务结果进行累加，从而产生最终的立方和。在整个计算过程中，Master与Worker的运行也是完全异步的，Master不必等到所有的Worker都执行完后，就可以进行求和操作，即，Master在获得部分子任务结果集时，就已经可以开始对最终结果进行计算，从而进一步提高系统的并发度和吞吐量。

    Worker对象在应用层的代码实现如下：

package com.roc.masterworker.test;

import java.util.Map;
import java.util.Set;

import com.roc.masterworker.Master;

public class Test
{
	public static void main(String[] args)
	{
		// 使用5个Worker，并指定Worker
		Master m = new Master(new PlusWorker(), 5);
		// 提交100个子任务
		for (int i = 0; i < 100; i++)
		{
			m.submit(i);
		}
		// 开始计算
		m.execute();
		// 最终计算结果保存于此
		int result = 0;

		Map<String, Object> resultMap = m.getResultMap();

		String key = null;
		Integer i = null;
		Set<String> keys = null;
		while (resultMap.size() > 0 || !m.isComplete())
		{
			// 不需要等待所有Worker都执行完，即可开始计算最终结果
			keys = resultMap.keySet();
			for (String k : keys)
			{
				key = k;
				break;
			}
			if (key != null)
			{
				i = (Integer) resultMap.get(key);
			}
			if (i != null)
			{
				// 最终结果
				result += i;
			}
			if (key != null)
			{
				// 移除已经被计算过得项
				resultMap.remove(key);
			}
		}
		System.out.println("-->result:" + result);;
	}
}

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

    源码下载地址：名字为Master-Worker