Master-Worker模式

Master-Worker模式

　　将某一部分的功能的系统分成两个角色Master、Worker来处理请求。

　　Master它的职能是负责客户端发送过来的请求、反馈回处理的结果以及分配任务。Worker它的职能就是处理子任务并把结果反馈给Master。这一模式和古代的分封制度有点类似。

　　

　　　　就如上图Master对任务进行切分，并放入任务队列；然后，触发Worker处理任务。Master只做任务的接收、切分和结果统计，指定Worker的数量和性能指标，但不参与Worker的实际管理，而是交由第三方调度监控和调度Worker。这样我们就可以将一个比较大的任务分成一个个小任务来处理，大大提高了系统的性能。在上述的图片中，我们不一定要使用上述的容器，自己可以根据情况而选择。

public class MasterMain {

    public static void main(String[] args) {

        Master master=new Master(new Worker(),10);

        for (int i=10;i<=100;i++){
            Task task=new Task();
            task.setId(i);
            task.setName("task"+i);
            task.setPrice(i);
            master.submit(task);
        }
        master.execute();

        long start=System.currentTimeMillis();
        while(true){
            if(master.isExist()){
                long end=System.currentTimeMillis()-start;
                long result=master.getResult();
                System.out.println("任务执行时间为："+end+"====结果集为："+result);
                break;
            }
        }
    }
}

public class Master {

    //1.承接任务的集合
    ConcurrentLinkedQueue<Object> workqueue=new ConcurrentLinkedQueue<Object>();

    //2.使用hashmap去承装所有的worker对象
    private HashMap<String ,Thread> workers=new HashMap<>();

    //3.使用一个容器承装每一个workers并发执行任务的结果集
    private ConcurrentHashMap<String,Object> resultMap=new ConcurrentHashMap<>();

    //4.构造方法
    public  Master(Worker worker,int workerCount){
        //每个worker对象都需要有Master的引用，workqueue用于任务的领取，resultMap用于任务的提交
         worker.setWorkerQueue(workqueue);
         worker.setResultMap(resultMap);

        for(int i=0;i<workerCount;i++){
            //key表示每一个worker的名字，value表示线程执行对象
            workers.put("任务"+Integer.toString(i),new Thread(worker));
        }
    }

    //5.提交任务
    public void submit(Object object){
        this.workqueue.add(object);
    }

    //6.执行所有的worker工作
    public void execute(){
        for(Map.Entry<String,Thread> work:workers.entrySet()){
            work.getValue().start();
        }
    }

    //判断是否结束
    public boolean isExist(){
        for(Map.Entry<String,Thread>exist: workers.entrySet()){
            if(exist.getValue().getState() !=Thread.State.TERMINATED){
                    return false;
            }
        }
        return true;
    }
    //返回结果集
    public long getResult(){
        long result=0L;
        for (Map.Entry<String,Object> re:resultMap.entrySet()){
            result+=(Integer) re.getValue();
        }

        return result;
    }
}

public class Worker implements Runnable {

    private ConcurrentLinkedQueue<Object> workerQueue;

    private  ConcurrentHashMap<String,Object> resultMap;

    public void setWorkerQueue(ConcurrentLinkedQueue<Object> workerQueue){
            this.workerQueue=workerQueue;
    }
     public void setResultMap(ConcurrentHashMap<String,Object> resultMap){
         this.resultMap=resultMap;
     }

    @Override
    public void run() {

         while(true){

             Task task= (Task) workerQueue.poll();
             if(task==null) break;//说明没有任务了

             //处理业务
            Object result = handle(task);

            //将结果集放到resultMap中
            resultMap.put(Integer.toString(task.getId()),result);

         }
    }
    private Object handle(Task task){
         Object result=null;
        try {
            Thread.sleep(500);
            result=task.getPrice();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return result;
    }
}

public class Task {

    private  int id;
    private  String name;
    private  int price;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }
}