多线程设计模式之Master-Worker模式

Master- Worker 模式是常用的并行计算模式。它的核心思想是系统由两类进程协作工 作： Master 进程和 Worker 进程。 Master 负责接收和分配任务，Worker 负责处理子任 务。当各个 Worker-子进程处理完成后，会将结果返回给 Master，由 Master 做归纳和总 结。其好处是能将一个大任务分解成若干个小任务，并行执行，从而提高系统的吞吐量。

 案例：Master类里有三个容器：ConcurrentLinkedQueue负责存储任务、Map负责保存Worker线程、ConcurrentHashMap负责存储处理的结果集。Master负责创建多条Worker线程去执行ConcurrentLinkedQueue存储的任务，然后将结果返回到ConcurrentHashMap里，由Master统一处理结果集返回给用户。

public class Master {

    //定义一个 承装所有任务 的容器
    ConcurrentLinkedQueue<Task> taskQueue = new ConcurrentLinkedQueue<>();

    //定义一个 承装所有worker对象 的容器
    Map<String,Thread> workersMap = new HashMap<>();

    //定义一个 承装每一个worker并发处理的结果集 容器
    ConcurrentHashMap<String,Object> resultQueue = new ConcurrentHashMap<>();

    //创建workers线程数 的构造
    public Master(Worker worker, int workderCount){
        worker.setTaskQueue(taskQueue);
        worker.setResultQueue(resultQueue);
        for (int i = 0; i < workderCount ; i++) {
            this.workersMap.put(Integer.toString(i),new Thread(worker));
        }
    }

    //提交任务方法
    public void conmitTask(Task task){
        taskQueue.add(task);
    }

    //启动所有的worker对象执行任务
    public void execute(){
        for(Map.Entry<String,Thread> map:workersMap.entrySet()){
            //启动worker线程
            map.getValue().start();
        }
    }

    //判断所有的 Worker 是否停止运行
    public boolean isStop(){
        for (Map.Entry<String,Thread> map:workersMap.entrySet()){
            if(map.getValue().getState() != Thread.State.TERMINATED){
                return false;
            }
        }
        return true;
    }

    //计算运行结果
    public int getRequest(){
        int priceResult = 0;
        for(ConcurrentHashMap.Entry<String,Object> map:resultQueue.entrySet()){
            priceResult += (int)map.getValue();
        }
        return priceResult;
    }

}

public class Worker implements Runnable {

    //领取任务的引用
    ConcurrentLinkedQueue<Task> taskQueue;
    //返回处理结果集的引用
    ConcurrentHashMap<String,Object> resultQueue;

    public void setTaskQueue(ConcurrentLinkedQueue<Task> taskQueue) {
        this.taskQueue = taskQueue;
    }

    public void setResultQueue(ConcurrentHashMap<String, Object> resultQueue) {
        this.resultQueue = resultQueue;
    }

    @Override
    public void run() {
        while(true){
            Task task = taskQueue.poll();
            if(task == null)
                break;
            Object result = handle(task);
            this.resultQueue.put(Integer.toString(task.getId()),result);
        }
    }

    private Object handle(Task task) {
        int result = 0;
        try {
            //模拟数据处理业务  05s 每次
            TimeUnit.MILLISECONDS.sleep(500);
            result = task.getPrice();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return result;
    }


}

public class Main {
    public static void main(String[] args) {
        Worker worker = new Worker();
        //创建10个worker去执行任务
        Master  master = new Master(worker,10);
        Random random = new Random();
        //添加任务
        for (int i = 0; i <100; i++) {
            master.conmitTask(new Task(i,"TaskName",random.nextInt(100)));
        }

        //执行任务
        master.execute();
        long start = System.currentTimeMillis();
        //打印结果
        while (true){
            //判断所有线程是否执行完毕
            if (master.isStop()){
                int request = master.getRequest();
                long end = System.currentTimeMillis();
                System.out.println("最终结果为："+request+",运行时间为："+(end-start));
                break;
            }
        }
    }
}