java workerqueue框架_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 workQueue = new ConcurrentLinkedQueue();

/**

* Worker进程队列

*/

protected Map threadMap = new HashMap();

/**

* 子任务处理结果集

*/

protected Map resultMap = new ConcurrentHashMap();

/**

* 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 getResultMap()

{

return resultMap;

}

/**

* 开始运行所有的Worker进程进行处理

*/

public void execute()

{

for(Map.Entry entry :threadMap.entrySet())

{

entry.getValue().start();

}

}

/**

* 是否所有的子任务都结束了

*/

public boolean isComplete()

{

for (Map.Entry 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 workerQueue;

/**

* 子任务处理结果集

*/

protected Map resultMap;

public void setResultMap(Map resultMap)

{

this.resultMap = resultMap;

}

public void setWorkQueue(Queue 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 resultMap = m.getResultMap();

String key = null;

Integer i = null;

Set 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进程全部终止，才给出最终计算结果。