生产消费模型-多生产者vs多消费者

使用场景：

      游戏中多个玩家生产任务，服务器多线程处理任务, Netty工作线程收到客户端传来数据，生成任务后，加入到任务队列中；

      游戏服启动后，创建多个消费线程，当有任务加入到队列中，其中某个消费者取得任务并处理，1000个玩家在线玩耍，只有10个线程处理任务。

public abstract class BaseTask {

	
	public abstract void run();
}

任务管理器

public class MutiTaskManager {

	private MutiTaskManager(){
		
	}
	
	private final static MutiTaskManager instance = new MutiTaskManager();
	
	public static MutiTaskManager getInstance(){
		return instance;
	}
	
	//线程池
	private ExecutorService executor = null;
	
	//任务队列
	private volatile Queue<BaseTask> taskQueue = new LinkedList<BaseTask>();
	
	//线程对象列表
	private List<MutiTaskExecutor> taskExecutors;
	
	//线程数量
	private int threadNum;
	
	private volatile Object signal = new Object();
	
	/**
	 * 初始化线程列表
	 * @param threadCnt
	 */
	public void init(int threadCnt){
		this.threadNum = threadCnt;
		taskExecutors = new ArrayList<MutiTaskExecutor>(threadNum);
		for(int i = 0; i < threadNum ; i ++){
			taskExecutors.add(new MutiTaskExecutor(signal));
		}
	}
	
	/**
	 * 添加任务
	 * @param task
	 */
	public void addTask(BaseTask task){
		synchronized(signal){
			taskQueue.add(task);
			signal.notify();
		}
	}
	
	/**
	 * 取出任务 
	 * @return
	 */
	public BaseTask popTask(){
		return taskQueue.poll();
	}
	
	public int getTaskSize(){
		return taskQueue.size();
	}
	
	/**
	 * 开启服务，启动线程池
	 */
	public void startService(){
		executor = Executors.newFixedThreadPool(threadNum);
		for(int i = 0; i < threadNum ; i ++){
			executor.execute(taskExecutors.get(i));
		}
	}
	
	public void stopService() throws Exception{
		for(int i = 0; i < threadNum ; i ++){
			taskExecutors.get(i).stopWork();
		}
		this.executor.shutdown();
	}
}

消费者

/**
 * 任务执行者
 * @author skymr
 *
 */
public class MutiTaskExecutor implements Runnable {

	private Object signal;
	private boolean isStarted = true;

	public MutiTaskExecutor(Object signal) {
		this.signal = signal;
	}

	@Override
	public void run() {
		BaseTask task = null;
		while (isStarted) {
			synchronized (signal) {
				task = MutiTaskManager.getInstance().popTask();
				if (task == null) {
					try {
						signal.wait();
					} catch (InterruptedException e) {
					}
					task = MutiTaskManager.getInstance().popTask();
				}
			}
			if (task != null) {
				try{
					task.run();
				}catch(Exception e){
					LogUtil.logException(e);
				}
			}
		}
	}
	
	public void stopWork(){
		this.isStarted = false;
	}
	
}

消息者的任务是一个无限循环中，判断是否有新任务加入，如果有，执行任务，消费；如果没有则进入等待(signal.wait())，直到接收到任务通知。