Master-Worker设计模式介绍

Master-Worker模式是常用的并行设计模式。核心思想是，系统由两个角色组成，Master和Worker，Master负责接收和分配任务，Worker负责处理子任务。任务处理过程中，Master还负责监督任务进展和Worker的健康状态；Master将接收Client提交的任务，并将任务的进展汇总反馈给Client。各角色关系如下图

Master-Worker模式满足于可以将大任务划分为小任务的场景，是一种分而治之的设计理念。通过多线程或者多进程多机器的模式，可以将小任务处理分发给更多的CPU处理，降低单个CPU的计算量，通过并发/并行提高任务的完成速度，提高系统的性能。

具体细节如上图，Master对任务进行切分，并放入任务队列；然后，触发Worker处理任务。实际操作中，任务的分配有多种形式，如Master主动拉起Workder进程池或线程池，并将任务分配给Worker；或者由Worker主动领取任务，这样的Worker一般是常驻进程；还有一种解耦的方式，即Master指做任务的接收、切分和结果统计，指定Worker的数量和性能指标，但不参与Worker的实际管理，而是交由第三方调度监控和调度Worker。

代码实现Master-Worker模式:

Master代码:

 package com.hjf.master_worker;

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

 /**
  * Master
  * @author huangjianfei
  */
 public class Master
 {
     //1:应该有一个承载任务的集合
     private ConcurrentLinkedQueue<Task> workQueue = new ConcurrentLinkedQueue<Task>();

     //2:使用hashmap去承载所有的worker对象 ThreadName------Worker
     private HashMap<String,Thread> workers = new HashMap<>();

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

     //4:构造方法
     public Master(Worker worker,int workerCount){
         //在worker中添加两个引用  workQueue用于任务的领取  resultMap用于任务的提交
         worker.setWorkerQueue(this.workQueue);
         worker.setResultMap(this.resultMap);

         for (int i = 0; i < workerCount; i++)
         {
             workers.put("子节点 "+i, new Thread(worker));
         }
     }

     //5:提交方法
     public void submit(Task task){
         workQueue.add(task);
     }

     //6:需要有一个执行的方法(启动应用程序 让所有的worker工作)
     public void execute(){
         //遍历workers 分别去执行每一个worker
         for (Map.Entry<String,Thread> me: workers.entrySet())
         {
             me.getValue().start();
         }
     }

     /**
      * 判断所有的worker是否执行完毕
      */
     public boolean isCompleted()
     {
         //遍历所有的worker 只要有一个没有停止 那么就代表没有结束
         for (Map.Entry<String,Thread> me: workers.entrySet())
         {
             if(me.getValue().getState() != Thread.State.TERMINATED){
                 return false;
             }
         }
         return true;
     }

     /**
      * 计算最终的结果集
      * @return
      */
     public int getResult(){
         int result = 0;
         for (Map.Entry<String,Object> me : resultMap.entrySet())
         {
             result += (Integer)me.getValue();
         }
         return result;
     }
 }

Worker代码实现:

 package com.hjf.master_worker;

 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentLinkedQueue;

 /**
  * Worker
  * @author huangjianfei
  */
 public class Worker implements Runnable
 {
     private ConcurrentLinkedQueue<Task> workQueue;

     private ConcurrentHashMap<String, Object> resultMap;

     public void setWorkerQueue(ConcurrentLinkedQueue<Task> workQueue)
     {
         this.workQueue = workQueue;
     }

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

     @Override
     public void run()
     {
         //处理一个个任务
         while(true){
             //从队列中取出一个元素
             Task input = this.workQueue.poll();
             if(null == input) break;
             //真正的去做业务处理
             Object outPut = handle(input);
             //存放任务的结果
             this.resultMap.put(String.valueOf(input.getId()), outPut);
         }
     }

     //单独抽出来 给子类重写，更加灵活
     public Object handle(Task input){
         return null;
     }

     /**
      * 处理业务 应该抽象出来 子类去具体实现业务逻辑
      * @param input
      */
 //    private Object handle(Task input)
 //    {
 //        Object outPut = null;
 //        if(null == input) return null;
 //        try
 //        {
 //            //表示处理task任务的耗时，可能是数据的加工，也可能是操作数据库
 //            Thread.sleep(5000);
 //            //模拟真实的业务场景
 //            outPut = input.getPrice();
 //        } catch (InterruptedException e)
 //        {
 //            e.printStackTrace();
 //        }
 //        return outPut;
 //    }

 }

Task代码实现:

 package com.hjf.master_worker;
 /**
  * 任务
  * @author huangjianfei
  */
 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;
     }

 }

Worker子类，在以后的开发中可以按照自己的需求去设计相关的Worker的子类:

 package com.hjf.master_worker;

 public class MyWorker1 extends Worker
 {
     @Override
     public Object handle(Task input)
     {
         Object outPut = null;
         if(null == input) return null;
         try
         {
             //表示处理task任务的耗时，可能是数据的加工，也可能是操作数据库
             Thread.sleep(5000);
             //模拟真实的业务场景
             outPut = input.getPrice();
         } catch (InterruptedException e)
         {
             e.printStackTrace();
         }
         return outPut;
     }
 }

Main测试类代码:

 package com.hjf.master_worker;

 import java.util.Random;
 /**
  * 主线程测试类
  * @author huangjianfei
  */
 public class Main
 {
     public static void main(String[] args)
     {
         System.out.println("我的机器可用的Processor数量:"+Runtime.getRuntime().availableProcessors());
         // 使用worker子类实现具体的业务,更加灵活
         Master master = new Master(new MyWorker1(), Runtime.getRuntime().availableProcessors());
         Random r = new Random();
         //提交100个任务
         for (int i = 0; i <= 100; i++)
         {
             Task t = new Task();
             t.setId(i);
             t.setName("任务 "+i);
             t.setPrice(r.nextInt(1000));
             master.submit(t);
         }

         //执行所有的worker
         master.execute();

         long start = System.currentTimeMillis();//记录时间

         while(true){
             //全部的worker执行结束的时候去计算最后的结果
             if(master.isCompleted()){
                 long end = System.currentTimeMillis() - start;//计算耗时
                 //计算结果集
                 int result = master.getResult();
                 System.out.println("执行最终结果: "+result + " 执行耗时 "+end);
                 break;
             }
         }

     }

 }