java 并发设计模式 Master 和Worker

package com.thread.test.masterworker;

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

public class Master {

    //存放全部工作任务队列
    protected ConcurrentLinkedQueue<Task> workerQueue = new ConcurrentLinkedQueue();

    //存放全部的工作对象
    protected Map<String, Thread> workers = new HashMap<String, Thread>();


    //接收每个工作者工作后的结果
    protected ConcurrentHashMap<String, Object> resultMap = new ConcurrentHashMap();


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

        //处理结果的引用 用于任务的提交
        worker.setResultMap(this.resultMap);
        //任务队列 需要有任务的引用 用于任务的领取
        worker.setWorkerQueue(this.workerQueue);

        for (int i = 0; i < workCounts; i++) {
            workers.put("任务" + i, new Thread(worker));
        }
    }

    //判断所有的子任务是否结束
    protected boolean isComplete() {

        for (Map.Entry<String, Thread> set : workers.entrySet()) {
            if (set.getValue().getState() != Thread.State.TERMINATED) {
                return false;
            }
        }
        return true;

    }

    //总共有多少个未完成工作
    protected int isNotCompletedCount() {
        int count = 0;
        for (Map.Entry<String, Thread> set : workers.entrySet()) {
            if (set.getValue().getState() != Thread.State.TERMINATED) {
                count++;
            }
        }
        return count;
    }

    //提交任务
    public void submit(Task task) {
        workerQueue.add(task);
    }

    //启动任务

    public void execute() {
        for (Map.Entry<String, Thread> set : workers.entrySet()) {
            set.getValue().start();
        }
    }


    public Integer getResult() {
        Integer result = 0;
        for (Map.Entry result_ : resultMap.entrySet()) {
            result += Integer.valueOf(result_.getValue().toString());
        }
        return result;
    }


}


package com.thread.test.masterworker;


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

public class Worker implements Runnable {


    //1.首先要实现runnble接口

    //Master 的引用

    //存放执行结果
    private Map<String, Object> resultMap = new HashMap<String, Object>();

    //工作着队列
    ConcurrentLinkedQueue<Task> workerQueue = new ConcurrentLinkedQueue<Task>();


    public void run() {


        while (true) {
            Task task = workerQueue.poll();
            if (task == null) {
                break;
            }

            Object object = hanlder(task);
            resultMap.put(String.valueOf(task.getId()), task.getPrice());
        }

    }

    public Object hanlder(Task task) {
        return null;
    }


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

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

    public void setWorkerQueue(ConcurrentLinkedQueue<Task> workerQueue) {
        this.workerQueue = workerQueue;
    }
}


package com.thread.test.masterworker;


public class Task {

    private int id;

    private String name;

    private long price;

    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 long getPrice() {
        return price;
    }

    public void setPrice(long price) {
        this.price = price;
    }
}

package com.thread.test.masterworker;


public class MyWorker extends Worker {

    @Override
    public Object hanlder(Task task) {

        return 0;
    }
}


package com.thread.test.masterworker;

import java.util.Random;


public class Main {

    public static void main(String[] args) {

        Master master = new Master(new MyWorker(), 10);

        Random random = new Random();
        for (int i = 0; i < 100; i++) {
            Task task = new Task();
            task.setId(i);
            task.setName("task_" + i);
            task.setPrice(random.nextInt());
            master.submit(task);
        }

        master.execute();
        while (true) {
            if (master.isComplete()) {
                System.out.println(master.getResult());
                break;

            } else
                System.out.println("还有" + master.isNotCompletedCount() + "个任务未完成");
        }
    }
}