Master-Worker模式是常用并行模式之一,他的核心思想是==系统由两类进程协作工作:Master进程和Worker进程。Master进程负责接收和分配任务,Worker进程负责处理子任务。==当各个Worker进程将子任务处理完成后,将结果集返回给Master进程,由Master进程做归纳和汇总,从而得到系统的最终结果
好处
能够将一个大任务分解成若干个小任务,并行执行,从而提高系统的吞吐量。而对于系统请求者Client来说,任务一旦提交,Master进程会分配任务并立即返回,并不会等待系统全部处理完成后再返回,其处理方式是异步的,因此Client不会出现等待现象
Master-Worker模式结构
角色 | 作用 |
---|---|
Worker | 用于实际处理一个任务(处理逻辑在子类中实现) |
Master | 用于任务的分配和最终结果的合成 |
Main | 启动系统,调度开启Master |
注:Master-Worker模式是一种使用多线程进行数据处理的结构。多个Worker进程协作处理用户请求,Master进程负责维护Worker进程,并整合最终处理结果
使用Master-Worker模式计算1到100的立方和
// Master进程为主要进程,维护了一个Worker进程队列、子任务队列和子结果集
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>();
// 判断是否所有子任务都结束了
public boolean isComplete() {
for (Map.Entry<String, Thread> entry : threadMap.entrySet()) {
if (entry.getValue().getState() != Thread.State.TERMINATED) {
return false;
}
}
return true;
}
// 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 obj) {
workQueue.add(obj);
}
// 返回子任务结果集
public Map<String, Object> getResultMap() {
return resultMap;
}
// 开始运行所有的worker进程,进行处理
public void execute() {
for (Map.Entry<String, Thread> entry : threadMap.entrySet()) {
entry.getValue().start();
}
}
}
// Worker进程队列中的Worker进程,不停地从任务队列提取要处理的子任务,并将子任务的处理结果写入结果集
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);
}
}
}
// Worker的子类,实现了处理逻辑
public class PulsWorker extends Worker {
@Override
public Object handle(Object input) {
Integer i = (Integer) input;
return i * i * i;
}
}
public class Main {
public static void main(String[] args) {
Master m = new Master(new PulsWorker(), 5);
for (int i = 1; i <= 100; i++) {
m.submit(i);
}
m.execute();
int re = 0;
Map<String, Object> resultMap = m.getResultMap();
while (resultMap.size() > 0 || !m.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);
}
}
// 运行结果
25502500
分析
-
计算任务被分解为100个子任务,每个子任务仅用于计算单独的立方和
-
Master产生固定个数(该程序中为5个)的Worker来处理这些子任务
-
Master提交子任务
-
5个Worker同时不断从任务集合中获取计算立方和的子任务,并将计算结果返回给Master
-
Master将Worker每次返回的结果进行累加,当5个活跃的Worker进程全部终止,才会给出最终计算结果
注:整个计算过程中,Master和Work的运作是完全异步的,Master不必等到所有Worker都执行完毕后,就可以进行就和操作,即Master在获得部分子任务结果集时,就已经可以开始对最终结果进行计算,从而进一步提高系统的并行度和吞吐量