Master-Worker模式

    Master-Worker模式设计思想是，系统由两类进程协作工作：Master进程和Worker进程。Master进程负责接收和分配任务，Worker进程负责处理子任务。当各个worker进程将任务处理完成后，将结果返回给Master进程，由Master进程做归纳和汇总，从而得到系统最终结果。

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

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




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 job){
		workQueue.add(job);
	}
	
	//返回子任务结果集
	public Map<String,Object>  getResultMap(){
		return resultMap;
	}
	
	//开始运行所有的Worker进程，进行处理
	public void execute(){
		for(Map.Entry<String, Thread> entry:threadMap.entrySet()){
			entry.getValue().start();
		}
	}
}

import java.util.Map;
import java.util.Queue;


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;
	}
	
	@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);
		}
	}
	
	//子任务处理的逻辑，在子类中实现具体逻辑
	public Object handle(Object input){
		return input;
	}
}

案例：计算1~100的立方和

import java.util.Map;
import java.util.Set;


public class TestMasterWorker {

    public class PlusWorker extends Worker {
        public Object handle(Object input) {
            Integer i = (Integer) input;
            return i * i * i;
        }
    }

    public static void main(String[] args) {
        new TestMasterWorker().testMasterWorker();
        new TestMasterWorker().testPlus();
    }

    public void testMasterWorker() {
        Master m = new Master(new PlusWorker(), 5);
        for (int i = 0; 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("testMasterWorker:" + re);
    }


    public void testPlus() {
        int re = 0;
        try {
            for (int i = 0; i < 100; i++) {
                re += i * i * i;
            }
            System.out.println("testPlus:" + re);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

}

输出结果

testMasterWorker:24502500
testPlus:24502500

参考：Java程序性能优化