多人干活效率更高 - （Master - worker 模式）

核心思想

• Master - worker 核心思想其实很简单，就是我有一堆活，我请了一个主管，主管将它分给几个人干，并且不影响我，我还可以去干其他的事情。主管就是这个master,其他人就是worker

场景复现

我现在有一个任务希望计算1,2,3，……100的立方和

1. 于是我请了一个主管，然后又请了5个工人，
2. 主管将任务分成了100份，每份任务是计算一个数的立方（算一个任务），每个任务交给一个工人干
3. 工人计算完一个任务后交给主管，然后主管又给他分配下一个任务
4. 同时主管跑我这里来报告已经计算完的数的结果，然后我将所有的数据加起来
5. 直到完成所有的任务

• 注意：记录任务集合是在多线程中完成的，所以集合必须为线程安全的

角色

• Master：相当于场景里面的“主管”，负责分配任务和收集结果
• Worker：工人的父类，他的子类才是真正的工人
• PlusWorker：这个真正工人，需要继承上面的Worker，并重写他干活的类（handle）
• main方法：场景中的“我”，负责创建主管和工人，并完成结果数据的相加

代码

• 主管先来

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<Object>(); //任务队列，这里使用线程安全的队列
    protected Map<String, Thread> threadMap = new HashMap<String, Thread>(); //线程集合
    protected Map<String, Object> resultMap = new ConcurrentHashMap<String,Object>(); //返回值集合

    //构造方法
    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 boolean isComplete(){
        for(Map.Entry<String,Thread> entry:threadMap.entrySet()){
            if(entry.getValue().getState() != Thread.State.TERMINATED){
                return false;
            }
        }
        return true;
    }

    public void submit(Object job){
        workQueue.add(job);
    }

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

    public void execute(){
        for(Map.Entry<String, Thread> entry:threadMap.entrySet()){
            entry.getValue().start();
        }
    }

• Worker 这个工人的父类，不是真正的工人

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

• 真正的工人：PlusWorker

import MasterWorker.Worker;

public class PlusWorker extends Worker {
    //处理任务,假设我是干活特别耗时的
    public Object handle(Object input){
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Integer i = (Integer)input;
        return i * i * i;
    }
}

• “我”，主类

        long begin = System.currentTimeMillis();
        Master m = new Master(new PlusWorker(), 5);//5个任务
        for(int i = 1; i< 101;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);
        long end = System.currentTimeMillis();
        System.out.println("总共消耗时间"  + (end - begin) + "ms");

为了模拟真正的耗时，每次计算我都停留了10ms

• 如果单线程计算，理论上至少需要1000ms的时间
• 这里每次停留了10ms，5个线程干活，应该只需要200ms多一点