通过多线程模拟实现Master-Worker模式

package com.xwt.desiginPattern.master_worker;
/**
 * 任务实体类
 * @author xwt
 * 2016年11月27日   新增
 */
public class Task {
	private int id;
	private String name;
	private int 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 int getPrice() {
		return price;
	}
	public void setPrice(int price) {
		this.price = price;
	}
	
	
}

package com.xwt.desiginPattern.master_worker;

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

/**
 *	通过多线程模拟worker节点 
 * 
 * @author xwt
 *
 * 2016年11月27日   新增
 */
public abstract class Worker implements Runnable {
	//由于任务执行时需要从tasks中获取任务，并将放回结果放入results中，所以声明这两个变量
	private ConcurrentLinkedQueue<Task> tasks;
	private ConcurrentHashMap<String, Object> results;
	
	public void setTasks(ConcurrentLinkedQueue<Task> tasks) {
		this.tasks = tasks;
	}
	public void setResults(ConcurrentHashMap<String, Object> results) {
		this.results = results;
	}


	@Override
	public void run() {
		Object rst = null;
		Task task = this.tasks.poll();
		rst = handler(task);
		this.results.put(String.valueOf(task.getId()), rst);
	}

	/**
	 * 真正的业务处理方法，之所以使用abstract修饰，是为了让子类去实现，体现了多态的设计思想
	 * @param task
	 * @return
	 * @return Object
	 * 2016年11月27日 xwt 新增
	 */
	public abstract Object handler(Task task);
}

package com.xwt.desiginPattern.master_worker;

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

/**
 *	模拟master节点 
 * @author xwt
 *
 * 2016年11月27日   新增
 */
public class Master {
	
	//声明一个容器用以存储任务 由于是高并发添加任务，所以使用ConcurrentLinkedQueue容器
	private ConcurrentLinkedQueue<Task> tasks = new ConcurrentLinkedQueue<Task>();
	//声明一个容器存储worker
	private Map<String, Thread> workers = new HashMap<String,Thread>();
	//声明一个容器用以存放worker执行的返回结果
	private ConcurrentHashMap<String, Object> results = new ConcurrentHashMap<String, Object>(); 
	
	/**
	 * 构造master实例，
	 * @param worker 工作器
	 * @param count	 需要启动的工作器个数
	 */
	public Master(Worker worker,int count){
		worker.setTasks(tasks);
		worker.setResults(results);
		for (int i = 1; i <= count; i++) {
			workers.put("节点"+i, new Thread(worker));
		}
	}
	/**
	 * 提交任务
	 * @param task
	 * @return void
	 * 2016年11月27日 xwt 新增
	 */
	public void submitJob(Task task){
		this.tasks.add(task);
	}
	/**
	 * 启动工作器，执行任务
	 * @return void
	 * 2016年11月27日 xwt 新增
	 */
	public void excute(){
		for (Map.Entry<String, Thread> me: workers.entrySet()) {
			me.getValue().start();
		}
	}
	/**
	 * 判断所有线程是否都执行完成
	 * @return
	 * @return boolean
	 * 2016年11月27日 xwt 新增
	 */
	public boolean isComplete(){
		for (Map.Entry<String, Thread> me: workers.entrySet()) {
			if(me.getValue().getState() != Thread.State.TERMINATED)
				return false;
		}
		return true;
	}
	/**
	 * Master汇总结果
	 * @return
	 * @return Integer
	 * 2016年11月27日 xwt 新增
	 */
	public Integer getResult(){
		Integer rst = 0;
		for (Map.Entry<String, Object> me: results.entrySet()) {
			rst += (Integer)me.getValue();
		}
		return rst;
	}
	
}

package com.xwt.desiginPattern.master_worker;


public class PriceWorker extends Worker {


	@Override
	public Object handler(Task task) {
		Object o = null;
		try {
			//休眠500ms 模拟业务处理
			Thread.sleep(500);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		o = task.getPrice();
		return o;
	}

}

package com.xwt.desiginPattern.master_worker;

import java.util.Random;

public class Main {

	
	public static void main(String[] args) {
		Worker worker = new PriceWorker();
		int count = Runtime.getRuntime().availableProcessors();
		System.out.println(count);
		Master master = new Master(worker, 5);
		Random random = new Random();
		for(int i = 1; i <= 100; i++){
			Task task = new Task();
			task.setId(i);
			task.setName("任务"+i);
			task.setPrice(random.nextInt(1000));
			master.submitJob(task);
		}
		master.excute();
		long begin = System.currentTimeMillis();
		while(true){
			if(master.isComplete()){
				int rst = master.getResult();
				long end = System.currentTimeMillis();
				System.out.println("结果："+rst + ", 耗时："+(end-begin));
				break;
			}
		}
		
	}
}