java多线程之Master-Worker模式

简述
核心思想：系统由两类进程相互协作

• Master进程：负责接收和分配任务
• Worker进程：负责处理子任务，待子任务处理完成后，将结果返回Master进程。

优点：能够将一个大任务分解成若干小任务，并行执行，从而提高系统吞吐量。

代码实现
Master.java

package com.x.www;

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

/**
 * @description:
 * @author: lbYue
 * @date: Created in 16:12 2018/1/9
 */
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 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();
        }
    }

}

Worker.java

package com.x.www;

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

/**
 * @description:
 * @author: lbYue
 * @date: Created in 16:25 2018/1/9
 */
public class Worker implements Runnable {

    /**
     * 任务队列，用于取得子任务
     */
    protected Queue<Object> workQueue;

    /**
     * 子任务处理结果集
     */
    protected Map<String,Object> 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);
        }
    }


    public Queue<Object> getWorkQueue() {
        return workQueue;
    }

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

    public Map<String, Object> getResultMap() {
        return resultMap;
    }

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

PlushWorker.java

package com.x.www;

/**
 * @description:
 * @author: lbYue
 * @date: Created in 16:55 2018/1/9
 */
public class PlusWorker extends Worker {

    @Override
    public Object handle(Object input) {
        Integer i = (Integer) input;
        return i * i * i;
    }
}

Main.java

package com.x.www;

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

/**
 * @description:
 * @author: lbYue
 * @date: Created in 16:54 2018/1/9
 */
public class Main {

    public static void main(String[] args) {
        Master m = new Master(new PlusWorker(), 5);
        for (int i = 0; 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);
        System.exit(0);
    }
}