多线程下的设计模式之Master-Worker模式

该模式可以简单理解为：首先client将任务交给Master，Master中使用一个并发集合类来承载所有任务，使用一个集合去承载所有的Worker对象，并且有一个并发集合类来承载每一个Worker并发处理任务的结果集；每一个Worker是一个工作线程，所以首先要实现Runnable接口，每一个Worker对象还有Master中承载任务集合的引用来获取任务，每一个Worker对象有一个Master中承载结果集的引用，使得工作线程执行完毕后将结果放到结果集中，三者之间的的关系如下所示：

 代码实现如下：

Task任务类

Master类

package masterworker;

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

public class Master {
    //1.承装任务的集合
    private ConcurrentLinkedQueue<Task> workQueue = new ConcurrentLinkedQueue<>();
    //2. 使用HaskMap承装worker对象
    private HashMap<String,Thread> workers = new HashMap<>();
    //3.结果集
    private ConcurrentHashMap<String, Object> resultMap =  new ConcurrentHashMap<>();
    //4.构造
    public Master(Worker worker, int workerCount){
        for (int i = 0; i < workerCount; i++) {
            //每一个worker对象都需要有master引用
            worker.setWorkerQueue(this.workQueue);
            worker.setResultMap(this.resultMap);
            //key表示worker名，value表示线程执行对象
            workers.put("子节点"+Integer.toString(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();
        }
    }
    
    
    //7. 判断是否执行完毕
    public boolean isComplete(){
        for(Map.Entry<String,Thread> me : workers.entrySet()){
            if(me.getValue().getState() != Thread.State.TERMINATED){
                return false;
            }
        }
        return true;
    }
    
    //8.返回结果集数据
    public int getResult(){
        int ret = 0;
        for(Map.Entry<String, Object> me: resultMap.entrySet()){
            ret += (Integer) me.getValue();
        }
        return ret;
    }
    
}

Worker类

package masterworker;

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;
        
    }
    @Override
    public void run() {
    
        while(true){
            Task input = this.workQueue.poll();
            if(input == null){
                break;
            }
            //真正做业务处理
            Object output = handle(input);
            this.resultMap.put(Integer.toString(input.getId()), output);
        }
        
    }
    
    private Object handle(Task input){
        Object output = null;
        try {
            //表示处理task任务耗时，数据加工，操作数据库等
            Thread.sleep(500);
            output = input.getPrice();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return output;
    }
}

 

测试类Main

public class Main {
    public static void main(String[] args) {
        Master master = new Master(new Worker(), 10);
        Random r = new Random();
        
        for (int i = 0; i < 100; i++) {
            Task t = new Task();
            t.setId(i);
            t.setName("任务" + i);
            t.setPrice(r.nextInt(1000));

            master.submit(t);
        }
        
        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;
            }
        }
    }

}