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