Master-Worker模式 多线程设计模式

Master-Worker模式 多线程设计模式

---

常用的并行计算模式。它的核心思想是系统由两类进程协作工作：Master-Worker进程。Master负责接收和分配任务，Worker负责处理子任务。当各个Worker子进程处理完成后，会将结果返回给Master,由master做归纳和总结。大任务分解小任务，并行执行。

public class Main {
    public static void main(String[] args) {
        Master master = new Master(new Worker(), 5);

        for(int i = 0; i<10; i++){
            Task task = new Task();
            task.setId(i);
            task.setName("任务"+i);
            master.submit(task);
        }

        master.execute();

        while(true){
            if (master.isComplete()) {
                break;
            }
        }

        ConcurrentHashMap<String, Object> resultMap = master.getResultMap();
        for(Map.Entry<String, Object> me : resultMap.entrySet()){
            System.out.println(me.getKey() + "   " + me.getValue());
        }

    }

}
public class Master {
    private ConcurrentLinkedQueue<Task> workQueue = new ConcurrentLinkedQueue<>();
    private Map<String, Thread> workers = new HashMap<>();
    private ConcurrentHashMap<String, Object> resultMap = new ConcurrentHashMap<>();



    public ConcurrentHashMap<String, Object> getResultMap() {
        return resultMap;
    }

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

    public Master(Worker worker, int workerCount) {
        worker.setWorkQueue(this.workQueue);
        worker.setResultMap(this.resultMap);

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

    public void submit(Task task){
        this.workQueue.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 class Worker implements Runnable{

    private ConcurrentLinkedQueue<Task> workQueue;
    private ConcurrentHashMap<String, Object> resultMap;

    public void setWorkQueue(ConcurrentLinkedQueue<Task> workQueue) {
        this.workQueue = workQueue;
    }

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

    @Override
    public void run() {
        while(true){
            Task input = this.workQueue.poll();
            if (null == input) break;

            Object output = handle(input);
            this.resultMap.put(Integer.toString(input.getId()), output);
        }

    }

    private Object handle(Task input) {
        Object output = null;

        try {
            Thread.sleep(500);
            output = input.getName();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return output;
    }


}
public class Task {
    private int id;
    private String 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;
    }


}