Master-Worker模式是常用的并行模式之一。它的核心思想是,系统由两类进程协作工作:Master进程和Worker进程。Master进程复杂接受和分配任务,Worker进程负责处理子任务。当各个Worker进程将子任务处理完成后,将结果返回给Master进程,由Master进程做归纳和汇总,从而得到系统的最终结果,其处理过程如图
Master-Worker模式的好处是,它能够将一个大任务分解成若干个小任务,并行执行,从而提高系统系统的吞吐量。而对于系统请求者Client来说,任务一旦提交,Master进程会分配任务并立即返回,并不会等待系统全部处理完成后再返回,其处理过程是异步的。因此Client不会出现等待现象
1.Master-Worker模式结构
Master-Worker模式的结构相对比较简单,这里给出一个简明的实现方式,如图
Master-Worker模式是一种使用多线程进行数据处理的结构。多个Worker进程协作处理请求,Master进程请求负责维护Worker进程,并整合最终处理结果
Master-Worker模式的主要参与者有:Worker、Master、Main
- Worker:用于实际处理一个任务
- Master:用于任务的分配和最终结果的合成
- Main:启动系统,调度开启Master
2. Master-Worker的代码实现
Worker的进程实现如下
package com.joyhwong;
import java.util.Map;
import java.util.Queue;
public class Worker implements Runnable {
protected Queue<Object> workQueue;
protected Map<String, Object> resultMap;
public void setWorkQueue(Queue<Object> workQueue) {
this.workQueue = workQueue;
}
public void setResultMap(Map<String, Object> resultMap) {
this.resultMap = resultMap;
}
public Object handle(Object input) {
return input;
}
@Override
public void run() {
while (true) {
Object input = workQueue.poll();
if (input == null) {
break;
}
Object re = handle(input);
resultMap.put(Integer.toString(input.hashCode()), re);
}
}
}
Master的实现代码如下
package com.joyhwong;
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<>();
protected Map<String, Thread> threadMap = new HashMap<>();
protected Map<String, Object> resultMap = new ConcurrentHashMap<>();
public boolean isComplete() {
for (Map.Entry<String, Thread> entry : threadMap.entrySet()) {
if (entry.getValue().getState() != Thread.State.TERMINATED) {
return false;
}
}
return true;
}
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 object) {
workQueue.add(object);
}
public Map<String, Object> getResultMap() {
return resultMap;
}
public void execute() {
for (Map.Entry<String, Thread> entry : threadMap.entrySet()){
entry.getValue().start();
}
}
}
以上两段代码展示了Master-Worker框架的全貌,应用程序通过重载Worker.handle()方法实现应用逻辑。
Master-Worker模式是一种将串行任务并行化的方法,被分解的子任务在系统中可以被并行处理。同时,如果有需要,Master进程不需要等待所有子任务都完成计算,就可以根据已有的部分结果集计算最终结果
用这个Master-Worker框架,实现一个计算立方和的应用,计算1^3 + 2^3 + ···· + 100^3
计算任务被分解为100个子任务,每个子任务仅用于计算立方和。Master产生固定个数的Worker,来处理所有这些子任务。Worker不断地从任务集合中取得这些计算立方和的子任务,并将结果返回给Master。Master复杂将所有Worker的任务结果进行累加,从而产生最终的立方和
Worker对象在应用层的代码实现如下
package com.joyhwong;
public class PlusWorker extends Worker {
@Override
public Object handle(Object input) {
Integer i = (Integer) input;
return i * i * i;
}
}
使用Master-Worker框架进行计算的主函数
package com.joyhwong;
import java.util.Map;
import java.util.Set;
public class Main {
public static void main(String[] args) {
Master master = new Master(new PlusWorker(), 5);
for (int i = 0; i < 100; i++) {
master.submit(i);
}
master.execute();
int re = 0;
Map<String, Object> resultMap = master.getResultMap();
while (resultMap.size() > 0 || !master.isComplete()) {
Set<String> 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;
}
if (key != null) {
resultMap.remove(key);
}
}
System.out.println(re);
}
}
在主函数中,首先通过Master类创建5个Worker工作进程和Worker工作实例PlusWorker,在提交了100个子任务后,便开始子任务的计算,这些子任务,由生成的5个Worker进程共同完成,Master并不等待所有的Worker执行完毕,就开始访问自结果集进行最终结果的计算,直到子结果集中所有的数据都被处理,并且5个活跃的Worker进程全部终止,才给出最终计算结果