Java并行程序设计模式——Master-Worker模式

Master-Worker模式是常用并行模式之一，他的核心思想是==系统由两类进程协作工作：Master进程和Worker进程。Master进程负责接收和分配任务，Worker进程负责处理子任务。==当各个Worker进程将子任务处理完成后，将结果集返回给Master进程，由Master进程做归纳和汇总，从而得到系统的最终结果

好处

能够将一个大任务分解成若干个小任务，并行执行，从而提高系统的吞吐量。而对于系统请求者Client来说，任务一旦提交，Master进程会分配任务并立即返回，并不会等待系统全部处理完成后再返回，其处理方式是异步的，因此Client不会出现等待现象

Master-Worker模式结构

角色	作用
Worker	用于实际处理一个任务（处理逻辑在子类中实现）
Master	用于任务的分配和最终结果的合成
Main	启动系统，调度开启Master

注：Master-Worker模式是一种使用多线程进行数据处理的结构。多个Worker进程协作处理用户请求，Master进程负责维护Worker进程，并整合最终处理结果

使用Master-Worker模式计算1到100的立方和

// Master进程为主要进程，维护了一个Worker进程队列、子任务队列和子结果集
public class Master {
    // 任务队列
    protected Queue<Object> workQueue = new ConcurrentLinkedQueue<Object>();
    // Worker进程队列
    protected Map<String, Thread> threadMap = new HashMap<String, Thread>();
    // 子任务处理结果集
    protected Map<String, Object> resultMap = new ConcurrentHashMap<String, Object>();

    // 判断是否所有子任务都结束了
    public boolean isComplete() {
        for (Map.Entry<String, Thread> entry : threadMap.entrySet()) {
            if (entry.getValue().getState() != Thread.State.TERMINATED) {
                return  false;
            }
        }
        return true;
    }

    // Master的构造，需要一个Worker进程逻辑，和需要的Worker进程数量
    public Master(Worker worker, int countWorker) {
        worker.setWorkQueue(workQueue);
        worker.setResultMap(resultMap);
        for (int i = 0; i < countWorker; i++) {
            threadMap.put(Integer.toString(i), new Thread(worker, Integer.toString(i)));
        }
    }

    // 提交一个任务
    public void submit(Object obj) {
        workQueue.add(obj);
    }

    // 返回子任务结果集
    public Map<String, Object> getResultMap() {
        return resultMap;
    }

    // 开始运行所有的worker进程，进行处理
    public void execute() {
        for (Map.Entry<String, Thread> entry : threadMap.entrySet()) {
            entry.getValue().start();
        }
    }
}

// Worker进程队列中的Worker进程，不停地从任务队列提取要处理的子任务，并将子任务的处理结果写入结果集
public class Worker implements Runnable {
    // 任务队列，用于取得任务
    protected Queue<Object> workQueue;
    // 子任务处理结果集
    protected Map<String, Object> resultMap;

    public void setWorkQueue(Queue<Object> workQueue) {
        this.workQueue = workQueue;
    }

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

    // 子任务处理的逻辑，在子类中实现具体逻辑
    public Object handle(Object input) {
        return input;
    }

    @Override
    public void run() {
        while (true) {
            // 获取子任务
            Object input = workQueue.poll();
            if (input == null) {
                break;
            }
            // 处理子任务
            Object re = handle(input);
            // 将处理结果写入结果集
            resultMap.put(Integer.toString(input.hashCode()), re);
        }
    }
}

// Worker的子类，实现了处理逻辑
public class PulsWorker extends Worker {
    @Override
    public Object handle(Object input) {
        Integer i = (Integer) input;
        return i * i * i;
    }
}

public class Main {
    public static void main(String[] args) {
        Master m = new Master(new PulsWorker(), 5);
        for (int i = 1; i <= 100; i++) {
            m.submit(i);
        }
        m.execute();
        int re = 0;
        Map<String, Object> resultMap = m.getResultMap();
        while (resultMap.size() > 0 || !m.isComplete()) {
            Set<String> keys = resultMap.keySet();
            String key = null;
            for (String k : keys) {
                key = k;
                break;
            }
            Integer i = null;
            if (key != null) {
                i = (Integer)resultMap.get(key);
            }
            if (i != null) {
                re += i;
            }
            if (key != null) {
                resultMap.remove(key);
            }
        }
        System.out.println(re);
    }
}

// 运行结果
25502500

分析

• 计算任务被分解为100个子任务，每个子任务仅用于计算单独的立方和

• Master产生固定个数（该程序中为5个）的Worker来处理这些子任务

• Master提交子任务

• 5个Worker同时不断从任务集合中获取计算立方和的子任务，并将计算结果返回给Master

• Master将Worker每次返回的结果进行累加，当5个活跃的Worker进程全部终止，才会给出最终计算结果
  

注：整个计算过程中，Master和Work的运作是完全异步的，Master不必等到所有Worker都执行完毕后，就可以进行就和操作，即Master在获得部分子任务结果集时，就已经可以开始对最终结果进行计算，从而进一步提高系统的并行度和吞吐量