并发编程(12)-Master-Worker

Master-Worker模式是常用的并行计算模式。他的核心思想史系统由两类进程协作工作：master进程和worker进程。master负责接收和分配任务，worker负责处理子任务。当各个worker子进程处理完成后，会将结果返回给master，由master做归纳和总结。其好处是将一个大任务分解成若干个小任务，并行执行，从而提高系统的吞吐量。

举个例子，比如现在要计算1+2+3+….+100，每次相加看做是一次任务，每个任务耗时0.1秒，那么单进程执行的程序是：

1.单进程

public class Test2 {

    public static void main(String[] args) {
        int r = 0;
        long start = System.currentTimeMillis();
        for (int i = 1; i <= 100; i++) {

            try {
                r += i;
                Thread.sleep(100);//每一次运算需要耗时0.1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        long end = System.currentTimeMillis() - start;
        System.out.println("运行结果：" + r + "；耗时：" + end);
    }
}

执行结果：

运行结果：5050；耗时：10000

如果任务较多，每个执行任务耗时较长，那么想要获取到结果就需要花费很长很长的时间。
Master-Worker模式可以使用并行计算的模式，将1+2+3+…+100看做是相加的任务，每个任务耗时0.1秒。如果开启10个进程同时计算，最终将10个进程的结果合并得到最终结果，那么时间就可能缩短10倍。

2.多进程(Master-Worker)

java中万物皆对象，将每个任务看做是一个对象，创建对象：

public class Task {

    private int id;
    private int number;

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public int getNumber() {
        return number;
    }
    public void setNumber(int number) {
        this.number = number;
    }
}

创建Master和Worker

package com.thread.mythread.conn016;

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

public class Master {

    //1 创建一个盛装任务的容器
    private ConcurrentLinkedQueue<Task> workQueue = new ConcurrentLinkedQueue<Task>();

    //2 盛装所有的worker对象
    //master需要管理多个worker进程，所以master需要知道每一个worker进程，这些进程都需要有一块空间来存放
    private HashMap<String, Thread> workers = new LinkedHashMap<String, Thread>();

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

    //4 构造方法
    public Master(Worker worker, int workCount){

        //worker需要从master获取任务，于是在worker中建立对master任务的引用
        worker.setWorkerQueue(this.workQueue);
        //worker需要将结果返回给master，于是在worker中建立对master结果的引用
        worker.setResultMap(this.resultMap);

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

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

    //6 执行方法(启动应用程序，让所有的worker开始工作)
    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 int getResult(){
        int res = 0;
        for (Map.Entry<String, Object> me : resultMap.entrySet()) {
            res += (Integer)me.getValue();
        }
        return res;
    }

}

package com.thread.mythread.conn016;

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

public class Worker implements Runnable{

    private ConcurrentLinkedQueue<Task> workQueue;
    private ConcurrentHashMap<String, Object> resultMap;
    //在worker中创建对master任务队列的引用，领取master的任务
    public void setWorkerQueue(ConcurrentLinkedQueue<Task> workQueue) {
        this.workQueue = workQueue;
    }
    //在worker中创建对master结果集的引用，提交每次的运行结果到master
    public void setResultMap(ConcurrentHashMap<String, Object> resultMap) {
        this.resultMap = resultMap;
    }
    //开始执行任务的进程
    public void run() {
        while (true) {
            //每次从队列中取出一个任务
            Task input = this.workQueue.poll();
            //如果任务为空返回
            if(input == null) {
                break;
            }
            //处理任务，处理完之后将结果存入到resultMap中返回给master
            Object output = dealWorks(input);
            this.resultMap.put(Integer.toString(input.getId()), output);
        }
    }
    //真正处理任务的方法
    private Object dealWorks(Task input) {
        Object output = null;
        try {
            Thread.sleep(100);//假设处理业务耗时1秒中
            output = input.getNumber();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return output;
    }
}

测试并行计算：

package com.thread.mythread.conn016;

public class Test1 {

    public static void main(String[] args) {

        //master中有十个子线程worker
        Master master = new Master(new Worker(), 10);

        //将100个数相加的任务交给master
        for (int i = 1; i <= 100; i++) {
            Task t = new Task();
            t.setId(i);
            t.setNumber(i);
            master.submit(t);
        }

        //开启任务
        master.execute();

        long start = System.currentTimeMillis();

        while (true) {
            if(master.isComplete()){
                int a = master.getResult();
                long end = System.currentTimeMillis() - start;
                System.out.println("运行结果：" + a + "；耗时：" + end);
                break;
            }
        }
    }
}

运行结果：

运行结果：5050；耗时：1005

10个线程同时并行计算，运行结果是一样的，但是耗时减少了10倍。
真实情况下，并不是我们自己想指定多少线程就用多少线程，而是根据服务器的配置去获取合适的线程数量。
对上面的代码做一些修改：

//master中有十个子线程-worker
//Master master = new Master(new Worker(), 10);
    System.out.println("我的机器可用processors数量："+Runtime.getRuntime().availableProcessors());
    Master master = new Master(new Worker(), Runtime.getRuntime().availableProcessors());

上面的代码将处理任务的方法写死到Worker类中，如果还有其他的任务，同样还要往Worker，将方法独立出来：

独立的MyWorker：

package com.thread.mythread.conn016;

public class MyWorker extends Worker{

    public static Object dealWorks(Task input) {
        Object output = null;
        try {
            Thread.sleep(100);//假设处理业务耗时1秒中
            output = input.getNumber();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return output;
    }

}

Worker类瘦身为：

package com.thread.mythread.conn016;

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

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

    public void run() {
        while (true) {
            Task input = this.workQueue.poll();
            if(input == null) {
                break;
            }
            //处理业务，处理完之后将结果存入到resultMap中返回给master
            Object output = MyWorker.dealWorks(input);
            this.resultMap.put(Integer.toString(input.getId()), output);
        }
    }
}

测试：

package com.thread.mythread.conn016;

public class Test1 {

    public static void main(String[] args) {
        //master中有十个子线程-worker
//      Master master = new Master(new Worker(), 10);
        System.out.println("我的机器可用processors数量："+Runtime.getRuntime().availableProcessors());
        Master master = new Master(new MyWorker(), Runtime.getRuntime().availableProcessors());

        //添加任务
        for (int i = 1; i <= 100; i++) {
            Task t = new Task();
            t.setId(i);
            t.setNumber(i);
            master.submit(t);
        }

        //开启任务
        master.execute();

        long start = System.currentTimeMillis();

        while (true) {
            if(master.isComplete()){
                int a = master.getResult();
                long end = System.currentTimeMillis() - start;
                System.out.println("运行结果：" + a + "；耗时：" + end);
                break;
            }
        }
    }
}

输出结果：

我的机器可用processors数量：4
运行结果：5050；耗时：2503

于是泄露了我的低配置电脑。