master--worker模式

  Master-Worker的工作机制就是Master接收到了一个任务,对任务进行拆分,并且分配给各个Worker,让各个Worker之间各自运行各自的子任务,最后Worker们的返回结果交给Master进行汇总并且最后返回给任务的发起方

master--worker模式：并行计算模式，两类进程协作工作，master负责接受和分配任务，worker负责处理子任务，当各个worker子进程处理完，返回结果给master。

将一个大任务分成若干个小任务，提高系统吞吐率

简单实现：

public class Main {

	public static void main(String[] args) {
		Worker worker = new Worker();
		//当前机器可用线程数
        Master master = new Master(worker,Runtime.getRuntime().availableProcessors());
        for(int i = 0 ; i< 100; i++){
        	Task temp = new Task();
        	temp.setId(i);
        	temp.setName("task" + i);
        	master.submitTask(temp);
        }
        master.execute();
        
        while(true){
        	if(master.isComplete()){
        		master.getResult();
        		break;
        	}
        }
	}

}

public class Master {
	
	//承装任务集合
	ConcurrentLinkedQueue taskQueue = new ConcurrentLinkedQueue();
	//worker线程集合
	HashMap<String,Thread> threads = new HashMap<String,Thread>();
	//结果集合
	ConcurrentHashMap<String,Object> results = new ConcurrentHashMap<String,Object>();

	public Master(Worker worker,int workCount){
		worker.setResults(results);
		worker.setTaskQueue(taskQueue);
		
		for(int i = 0 ; i< workCount; i++){
			threads.put(Integer.toString(i), new Thread(worker));
		}
	}
	
	//提交任务
	public void submitTask(Task task){
		taskQueue.add(task);
	}
	
	//开始执行所有任务
	public void execute(){
		for(String key : threads.keySet()){
			Thread temp = threads.get(key);
			temp.start();
		}
	}

	//判断任务是否结束
	public boolean isComplete() {
		for(String key : threads.keySet()){
			Thread temp = threads.get(key);
			if(temp.getState() != Thread.State.TERMINATED){
				return false;
			}
		}
		return true;
	}
	
	//任务汇总
	public Object getResult(){
		//对所有result进行处理
		return null;
	}
}

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;
	}		
}

public class Worker implements Runnable{
	
	//承装任务集合
	ConcurrentLinkedQueue taskQueue;
	//结果集合
	ConcurrentHashMap<String,Object> results;

	@Override
	public void run() {
		while(true){
			Task task = (Task) taskQueue.poll();
			if(task == null){
				break;
			}
			Object o = handler(task);
			results.put(Integer.toString(task.getId()), o);
		}
	}

	private Object handler(Task task) {
		//业务处理
		Object o = task.getName();
		return o;
	}

	public ConcurrentLinkedQueue getTaskQueue() {
		return taskQueue;
	}

	public void setTaskQueue(ConcurrentLinkedQueue taskQueue) {
		this.taskQueue = taskQueue;
	}

	public ConcurrentHashMap<String, Object> getResults() {
		return results;
	}

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