自己动手写Master-Worker例子

自己动手写Master-Worker例子

Master-worker简介

Master-worker是一种可以把大任务分解，并行处理的一种设计模式。举个简单例子说明：有一个任务，可能要从几个地方取数据，然后再把这些数据汇总起来处理。如果按平时的串行方式，先取一个再取另一个，这样总的取数时间就是3个加起来的时间；如果我开几个线程，3个取数任务分别同时进行，从不同地方取数，那取数的时间就是3个中最久的那个。这样的开多个线程同时执行子任务，然后再回到主线程去汇总处理的方式就是master-worker。

代码演示

下面模拟写一个master-worker例子。
场景是：我有1000个任务，每个任务都需要执行100ms，执行完就返回一个字符串。最后我要把这1000个字符串拼起来。
思路：Master把1000个任务放到队列里，然后开4个线程并发去取任务执行，每执行完一个就把结果放到结果集合里，直到执行完所有任务为止。在执行的过程中，调用Master的获取结果方法是取不到结果的，会一直阻塞，要执行完才能返回结果。

这个例子总共有4个类：

1. Master：主线程，用于接收任务，汇总结果。
2. Worker：实现了Runnable接口，用于从任务队列里取出任务执行。
3. MyTask：任务类，用于提供具体要做的工作。正式项目中我觉得最好用接口来代替，这样才能执行不同的工作。
4. TestMasterWorker：测试验证类，提供main方法。

package top.usjava.learn.javaarchitecturelearn.design.masterworker;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.*;

/**
 * Master线程
 *
 * @author Owen
 * create time:2018/9/26 12:07
 */
public class Master {

    /**
     * 装载任务队列的容器
     */
    BlockingQueue<MyTask> taskQueue = new LinkedBlockingQueue<>();

    /**
     * 装载Worker线程的容器
     */
    Map<String, Thread> workerMap = new HashMap<>();

    /**
     * 结果集
     */
    ConcurrentHashMap resultMap = new ConcurrentHashMap();

    /**
     * worker停止通知标记，用于所有worker停止后，通知master线程
     */
    CountDownLatch countDownLatch;

    /**
     * 构造方法，在初始化Master时，就同时把worker初始化，并设置countDownLatch作为停止标记
     */
    public Master(Worker worker, int workerAmount) {
        countDownLatch = new CountDownLatch(workerAmount);
        worker.setTaskQueue(taskQueue);
        worker.setResultMap(resultMap);
        worker.setCountDownLatch(countDownLatch);
        for (int i = 0; i < workerAmount; i++) {
            workerMap.put(Integer.toString(i), new Thread(worker));
        }
    }

    /**
     * 提交任务方法
     */
    public void submit(MyTask task) {
        this.taskQueue.add(task);
    }

    /**
     * 启动所有线程
     */
    public void execute() {
        workerMap.forEach((k, v) -> v.start());
    }

    /**
     * 获取结果
     */
    public String getResult() {
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            System.err.println("master is interrupted:" + e.getMessage());
        }
        StringBuffer names = new StringBuffer();
        resultMap.forEach((k, v) -> names.append(",").append(v));
        return names.substring(1);
    }
}

package top.usjava.learn.javaarchitecturelearn.design.masterworker;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

/**
 * todo:描述
 *
 * @author Owen
 * create time:2018/9/26 12:07
 */
public class Worker implements Runnable{
    /**
     * 是否要工作
     * */
    private boolean isWorking = true;
    /**
     * 装载任务队列的容器,这里的指向Master的taskQueue
     */
    private BlockingQueue<MyTask> taskQueue;
    /**
     * 结果集
     * */
    private ConcurrentHashMap<Integer,Object> resultMap;

    /**
     * 停止通知标记
     *
     * */
    CountDownLatch countDownLatch;

    public BlockingQueue<MyTask> getTaskQueue() {
        return taskQueue;
    }

    public void setTaskQueue(BlockingQueue<MyTask> taskQueue) {
        this.taskQueue = taskQueue;
    }

    public ConcurrentHashMap getResultMap() {
        return resultMap;
    }

    public void setResultMap(ConcurrentHashMap resultMap) {
        this.resultMap = resultMap;
    }

    public boolean isWorking() {
        return isWorking;
    }

    public void setWorking(boolean working) {
        isWorking = working;
    }

    public CountDownLatch getCountDownLatch() {
        return countDownLatch;
    }

    public void setCountDownLatch(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }

    @Override
    public void run() {
        while (isWorking){
            try {
                MyTask task = this.taskQueue.poll(1, TimeUnit.SECONDS);
                if(task != null){
                    Object r = task.run();
                    resultMap.put(task.getId(),r);
                }else {
                    //如果1秒都没有任务了，则通知master此worker线程完成工作了。
                    countDownLatch.countDown();
                    break;
                }

            } catch (InterruptedException e) {
                System.err.println("worker poll interrupted:"+e.getMessage());
            }
        }
    }
}

package top.usjava.learn.javaarchitecturelearn.design.masterworker;

/**
 * 简单定义一个任务类
 *
 * @author Owen
 * create time:2018/9/26 12:09
 */
public class MyTask {
    private int id;
    private String name;

    public MyTask(int id, String name) {
        this.id = id;
        this.name = name;
    }

    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 Object run(){
        try {
            Thread.sleep(100L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return name;
    }
}

package top.usjava.learn.javaarchitecturelearn.unitlearn;

import top.usjava.learn.javaarchitecturelearn.design.masterworker.Master;
import top.usjava.learn.javaarchitecturelearn.design.masterworker.MyTask;
import top.usjava.learn.javaarchitecturelearn.design.masterworker.Worker;

/**
 * 测试自己实现的master-worker
 *
 * @author Owen
 * create time:2018/9/26 11:57
 */
public class TestMasterWorker {
    public static void main(String[] args) {
        Master master = new Master(new Worker(),4);
        for(int i=0;i<1000;i++){
            master.submit(new MyTask(i,"hi"+i));
        }
        long t1 = System.currentTimeMillis();
        master.execute();
        String result = master.getResult();
        long t2 = System.currentTimeMillis();
        System.out.println("完成任务："+result);
        System.out.println(" 用时："+(t2-t1));
    }
}

代码说明一下：

1. Master有任务队列、结果map、worker集合引用、还有用于之别是否执行完的CountDownLatch变量。
2. Master在构造函数就把worker线程初始化好，放到worker集合里。Worker对象里有任务队列、结果集合的引用，用于取任务和存放结果。
3. Master的getResult()方法里使用了CountDownLatch来监听是否已经执行完（CountDownLatch的使用如果不会的可以查看其他资料）。用CountDownLatch来监听比用while循环监听起码有一个好处就是好看。。。性能应该也会好一些，这个有待验证。
   如果还没执行完，就一直等待，直到执行完才返回结果。
4. Worker线程就调用worker的run方法来不断地从任务队列取任务处理，直到没有任务了，就调用CountDownLatch的方法来通知执行完毕。

运行结果：

从结果看出，总共花了26秒多一点。如果串行的话，得要至少100秒。看来性能提升是有目共睹的。不过需要注意的是，cpu得支持多个线程，不然效果可能不太好。不过现在的cpu一般都是多核多线程，所以以后只要遇到类似的场景，就可以使用一下master-worker来提升速度了。