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

一、什么是Master-Worker模式：

该模式的结构图：

  结构图：

 

Worker：用于实际处理一个任务；

Master：任务的分配和最终结果的合成；

Main：启动程序，调度开启Master。

 

二、代码实现：

    下面的是一个简易的Master-Worker框架实现。

（1）Master部分：

 
package com.neu.cms.service.thread;

import java.util.HashMap;
import java.util.Map;
import java.util.Queue;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;

/**
 * @author 
 * @version V2.0
 * @description
 * @since 2016-05-10 14:27
 */
public class Master {
    //任务队列
    protected Queue<Object> workQueue = new ConcurrentLinkedQueue<>();
    //Worker进程队列
    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;
    }

    //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();
        }
    }
}

（2）Worker进程实现：

 
package com.neu.cms.service.thread;

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

/**
 * @author 
 * @version V2.0
 * @description
 * @since 2016-05-10 14:28
 */
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);
        }
    }

}

 

（3）运用这个小框架计算1——50的立方和，PlusWorker的实现：

 
package com.neu.cms.service.thread;

/**
 * @author 
 * @version V2.0
 * @description
 * @since 2016-05-10 14:29
 */
public class PlusWorker extends Worker {
    @Override
    public Object handle(Object input) {
        Integer i =(Integer)input;
        return i*i*i;
    }
}

 

（4）进行计算的Main函数：

 
package com.dmall.cms.service.thread;

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

/**
 * @author 
 * @version V2.0
 * @description
 * @since 2016-05-10 14:30
 */
public class Main {
    public static void main(String[] args) {
        Long start = System.currentTimeMillis();
        //固定使用5个Worker，并指定Worker
        Master m = new Master(new PlusWorker(), 5);
        //提交100个子任务
        for (int i = 1; i <= 100; i++) {
            m.submit(i);
        }
        //开始计算
        m.execute();
        int re = 0;
        //保存最终结算结果

        Map<String, Object> resultMap = m.getResultMap();
        //不需要等待所有Worker都执行完成，即可开始计算最终结果
        if (resultMap.size() > 0 || !m.isComplete()) {
            for (Map.Entry entry : resultMap.entrySet()) {
                re += (Integer)entry.getValue();
            }
        }
        System.out.println(resultMap.size());
        System.out.println(re);
        System.out.println(System.currentTimeMillis() - start);
    }

}

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