并发编程：Master-Worker模式

一、Master-Worker模式

Master-Worker的工作机制就是Master接收到了一个任务,对任务进行拆分,并且分配给各个Worker,让各个Worker之间各自运行各自的子任务,最后Worker们的返回结果交给Master进行汇总并且最后返回给任务的发起方.

Master-Worker是一种并行模式,Master是主要进程,Master中有维护着一个Worker进程队列.Master把一个大的而且复杂的业务拆分成若干小的业务,只要是互不影响的都可以分而治之相互独立.可以通过多线程或多进程甚至多机联合计算,把拆分后的小业务交给更多的CPU或机器处理,通过并发/并行的方式提高整体业务的运算速度,压榨系统性能来提高效率.

二、Master-Worker模式Demo

 Master角色

package ConcurrentProgramming.middle.part3.MasterWorker;


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

/**
 * @Author: zdj
 * @Description: Master角色 接收和分配任务
 * @Date: 2019年03月15日 14:00
 */
public class Master {

    //定义一个容器 用来保存任务
    private ConcurrentLinkedQueue<Task> taskQueue = new ConcurrentLinkedQueue<Task>();

    //定义一个存放Worker的容器
    private HashMap<String,Thread> workers = new HashMap<String, Thread>();

    //定义一个容器存放执行结果
    private ConcurrentHashMap<String,Object> result = new ConcurrentHashMap<String, Object>();

    public Master(Worker worker,int workerCount){
        worker.setTaskQueue(this.taskQueue);
        worker.setResult(this.result);
        for (int i = 0; i <workerCount; i++){
            this.workers.put(Integer.toString(i),new Thread(worker));
        }
    }

    //提交任务的方法 将任务装到任务队列
    public void submit(Task task){
        this.taskQueue.add(task);
    }

    //启动线程去执行任务
    public void execute(){
        for (Map.Entry<String,Thread> me : workers.entrySet()){
            me.getValue().start();
        }
    }

    //判断是否运行结束
    public boolean isComplete(){
        for (Map.Entry<String,Thread> me : workers.entrySet()){
            if (me.getValue().getState() != Thread.State.TERMINATED){
                return false;
            }
        }
        return true;
    }

    //获取计算结果
    public String getResult(){
        String s = "";
        for (Map.Entry me:result.entrySet()){
            s += (String) me.getKey();
        }
        return s;
    }

}

worker角色

package ConcurrentProgramming.middle.part3.MasterWorker;

import lombok.Data;

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

/**
 * @Author: zdj
 * @Description: Worker角色 负责执行任务
 * @Date: 2019年03月15日 14:06
 */
@Data
public class Worker implements Runnable{

    //任务队列引用
    private ConcurrentLinkedQueue<Task> taskQueue;

    //结果引用
    private ConcurrentHashMap<String,Object> result;

    public void run() {
        while (true){
            //从任务队列中取任务
            Task task = this.taskQueue.poll();
            if (task == null){
                break;
            }
            //处理
            Object output = handle(task);
            //将结果放到结果队列
            this.result.put(task.getId().toString(),output);
        }
    }
    
    //模拟处理任务
    private Object handle(Task task){
        Object output = null;
        try {
            //模拟处理耗时任务
            Thread.sleep(500);
            output = task.getName();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return output;
    }
}

任务Task

package ConcurrentProgramming.middle.part3.MasterWorker;

import lombok.Data;

/**
 * @Author: zdj
 * @Description: 任务
 * @Date: 2019年03月15日 14:01
 */
@Data
public class Task {
    private String id;
    private String name;
}

测试Main

package ConcurrentProgramming.middle.part3.MasterWorker;

/**
 * @Author: zdj
 * @Description: Master-Worker模式是常用的并行计算模式 Master负责接收和分配任务，Worker负责处理任务
 * @Date: 2019年03月15日 14:36
 */
public class Main {
    public static void main(String[] args) {

        //创建20个woker去执行任务
        Master master = new Master(new Worker(),20);

        //创建100个任务
        for (int i = 1; i <= 100 ;i++){
            Task task = new Task();
            task.setId("id" + Integer.toString(i));
            task.setName("name" + Integer.toString(i));
            master.submit(task);
        }
        master.execute();
        //记录下开始时间
        long start = System.currentTimeMillis();

        while (true){
            if (master.isComplete()){
                long end = System.currentTimeMillis()-start;
                String result = master.getResult();
                System.out.println("结果为" + result + "\n执行时间为:" + end);
                break;
            }
        }
    }
}

运行结果：

 

参考链接：https://blog.csdn.net/unscdf117/article/details/78888814