Master-Worker模式

Master-Worker模式

        Master-Worker模式是一种并行计算模式。核心思想是由两个类协同工作：Master负责接收和分配任务，Worker负责处理子任务。当所有的Worker处理完后，由Master归纳总结。好处是可以将一个大任务分成小任务，并行执行，提高系统吞吐量。

        Task:

public class Task {

    private String id;

    private String name;

    private Integer value;

    public Task(String id, String name, Integer value) {
        this.id = id;
        this.name = name;
        this.value = value;
    }

//省略get/set
}

        Master:

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.stream.Collectors;

public class Master {

    //承装任务的队列
    private ConcurrentLinkedQueue<Task> tasksQueue = new ConcurrentLinkedQueue<>();

    //承装worker对象
    private Map<String, Thread> workersMap = new HashMap<>();

    //承装任务结果
    private ConcurrentHashMap<String, Integer> resultMap = new ConcurrentHashMap<>();

    public Master(Worker worker,int workerCount){
        //worker从tasksQueue中取任务，结果存到resultMap中
        worker.setTasksQueue(this.tasksQueue);
        worker.setResultMap(this.resultMap);
        //创建指定数量的线程
        for(int i=0;i<workerCount;i++) {
            workersMap.put("worker-" + i,new Thread(worker));
        }
    }
    //提交任务方法
    public void submitTask(List<Task> tasks) {
        tasks.forEach(tasksQueue :: offer);
    }

    //执行任务方法
    public void execute() {
        workersMap.values().forEach(Thread::start);
    }

    //判断是否完成
    public boolean isComplete(){
        long count = workersMap.values().stream().filter(t -> t.getState() != Thread.State.TERMINATED).count();
        if (count == 0){
            return Boolean.TRUE;
        }else {
            return Boolean.FALSE;
        }
    }

    //获取结果
    public Integer getResult() {
        Long sum = resultMap.values().stream().collect(Collectors.summarizingInt(Integer::intValue)).getSum();
        return sum.intValue();
    }
}

Worker:

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

public class Worker implements Runnable {
    //承装任务的队列
    private ConcurrentLinkedQueue<Task> tasksQueue;

    //承装任务结果
    private ConcurrentHashMap<String, Integer> resultMap;

    public void setTasksQueue(ConcurrentLinkedQueue<Task> tasksQueue) {
        this.tasksQueue = tasksQueue;
    }

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

    @Override
    public void run() {

        while (true){
            //从队列中取任务
            Task task = this.tasksQueue.poll();
            if (task==null){break;}
            Integer ret = handler(task);
            //将结果存入resultMap
            this.resultMap.put(task.getId(),ret);
        }
    }

    private Integer handler(Task task) {
        //模拟处理任务耗时
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return task.getValue();
    }
}

    Main：

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class Main {
    public static void main(String[] args) {
        Master master = new Master(new Worker(),Runtime.getRuntime().availableProcessors());
        List<Task> tasks = new ArrayList<>();
        Random random = new Random();
        for (int i=0;i<10;i++) {
            tasks.add(new Task(i+"","任务" + i,random.nextInt(1000)));
        }
        //提交任务
        master.submitTask(tasks);
        //执行
        master.execute();
        long start = System.currentTimeMillis();
        while (true) {
            if (master.isComplete()) {
                long end = System.currentTimeMillis() - start;
                int ret = master.getResult();
                System.out.println("最终结果：" + ret + "， 执行耗时：" + end);
                break;
            }
        }
    }
}