基于BlockingQueue的生产者消费者模式实现(即用型)

生产者消费者模式无疑是个重要的架构实现模式...

代码使用例子：

new DemoPC().startup();

//============================
import java.util.Arrays;
import java.util.List;

public class DemoPC extends ProducerConsumerSupport {

	static class ProductWrapper implements Product {
		String pid;

		public ProductWrapper(String pid) {
			this.pid = pid;
		}

	}

	@Override
	public void consume(Product product) {

		System.out.println("正在消费产品【" + product + "】!");

	}

	@Override
	public void handleConsumerException(Exception e, Product product) {
		System.err.println("消费产品【" + product + "】失败！原因：" + e.getMessage());

	}

	@Override
	public void handleProducerException(Exception e) {
		System.err.println("生产失败...");

	}

	@Override
	public List<Product> produce() {

		return Arrays.asList(new Product[] { new ProductWrapper("p1"),
				new ProductWrapper("p2"), new ProductWrapper("pn") });
	}

}

/**
 * 对生产者消费者模型的抽象
 * 
 * @author gzit-team
 * 
 */

public abstract class ProducerConsumerSupport {

	private int sleepIfEmptyProduct = 5 * 1000; // 没有取得产品时，休眠的时间
	private int sleepIfExceptionRaise = 60 * 1000;// 如果出现异常工作线程做适当的休眠
	private boolean sleepWhenExceptionRaise; // 出现异常时是否进行适当的休眠
	private int producerSize = 1;// 生产者个数
	private int consumerSize = 1;// 消费者个数
	private int queenSize = 10; // 等待队列的大小

	// 系统运行的几种状态
	public final int STATE_INIT = 0;
	public final int STATE_PAUSED = 1;
	public final int STATE_RUNNING = 2;
	public final int STATE_SHUTDOWN = 3;

	// 系统的状态
	private int state = STATE_INIT;

	// 空的对象列表,做占位用
	public static List<Product> EMPTY_PRODUCT_LIST = new ArrayList<Product>();

	// 产品队列
	private BlockingQueue<Product> produceQueen;

	// 生产者，消费者队列
	private List<Producer> produerList;
	private List<Consumer> consumerList;

	// 生产者
	class Producer extends PeriodicalTask {

		public Producer() {
			this(0);
		}

		public Producer(int period) {
			super(period);

		}

		// 可以在这里处理异常
		public void handleException(Exception e) {
			handleProducerException(e);
			if (sleepWhenExceptionRaise) {
				try {
					Thread.sleep(sleepIfExceptionRaise);
				} catch (InterruptedException e1) {
					// ignore
				}
			}
		}

		@Override
		protected void doWork() throws Exception {

			List<Product> products = produce();
			for (Product p : products) {

				// 有可能发生阻塞
				produceQueen.put(p);
			}

			// 如果生产者取得的数据为空，则适当进行休眠,以免出现狂操作
			if (products.isEmpty()) {
				Thread.sleep(sleepIfEmptyProduct);

			}

		}

	}

	// 消费者
	class Consumer extends PeriodicalTask {

		private Product curProduct;

		public Consumer() {
			this(0);
		}

		// 可以在这里处理异常
		public void handleException(Exception e) {
			handleConsumerException(e, this.curProduct);
			if (sleepWhenExceptionRaise) {
				try {
					Thread.sleep(sleepIfExceptionRaise);
				} catch (InterruptedException e1) {
					// ignore
				}
			}
		}

		public Consumer(int period) {
			super(period);

		}

		@Override
		protected void doWork() throws Exception {

			// 有可能发生阻塞
			Product product = produceQueen.take();
			curProduct = product;
			consume(product);

		}

	}

	// 由子类来实现生成和消费的具体逻辑
	public abstract List<Product> produce();

	public abstract void consume(Product product);

	public abstract void handleProducerException(Exception e);

	public abstract void handleConsumerException(Exception e, Product product);

	// 启动之前做的事情
	public void preStartup() {

	}

	public void startup() {

		if (state == STATE_RUNNING) {
			throw new IllegalStateException("系统已经处于运行状态，不能够再启动！state="
					+ this.state);
		}

		this.preStartup();

		// 创建相关的队列和线程
		produceQueen = new LinkedBlockingQueue<Product>(this.queenSize);
		produerList = new LinkedList<Producer>();
		consumerList = new LinkedList<Consumer>();
		for (int i = 0; i < this.producerSize; i++) {
			Producer producer = new Producer();
			produerList.add(producer);
			producer.start();
		}

		for (int i = 0; i < this.consumerSize; i++) {
			Consumer consumer = new Consumer();
			consumerList.add(consumer);
			consumer.start();
		}

		state = STATE_RUNNING;

	}

	// /几个管理接口/
	public void pause() {

		if (state != STATE_RUNNING) {
			throw new IllegalStateException("系统不处于运行状态，不能暂停！state="
					+ this.state);

		}

		for (Producer p : produerList) {
			p.pause();
		}

		for (Consumer c : consumerList) {
			c.pause();
		}

		state = STATE_PAUSED;

	}

	public void resume() {

		if (state != STATE_PAUSED) {
			throw new IllegalStateException("系统不处于暂停状态，不能恢复！state="
					+ this.state);
		}

		for (Producer p : produerList) {
			p.resume();
		}

		for (Consumer c : consumerList) {
			c.resume();
		}

		state = STATE_RUNNING;

	}

	public void shutdown() {

		if (state != STATE_RUNNING) {
			throw new IllegalStateException("系统不处于运行状态，不能关闭！state="
					+ this.state);

		}

		for (Producer p : produerList) {
			p.shutdown();
		}

		for (Consumer c : consumerList) {
			c.shutdown();
		}

		state = STATE_SHUTDOWN;

	}

	// //

	public int getProducerSize() {
		return producerSize;
	}

	public void setProducerSize(int producerSize) {
		this.producerSize = producerSize;
	}

	public int getConsumerSize() {
		return consumerSize;
	}

	public void setConsumerSize(int consumerSize) {
		this.consumerSize = consumerSize;
	}

	public int getQueenSize() {
		return queenSize;
	}

	public void setQueenSize(int queenSize) {
		this.queenSize = queenSize;
	}

	public BlockingQueue<Product> getProduceQueen() {
		return produceQueen;
	}

	public void setProduceQueen(BlockingQueue<Product> produceQueen) {
		this.produceQueen = produceQueen;
	}

	public List<Producer> getProduerList() {
		return produerList;
	}

	public void setProduerList(List<Producer> produerList) {
		this.produerList = produerList;
	}

	public List<Consumer> getConsumerList() {
		return consumerList;
	}

	public void setConsumerList(List<Consumer> consumerList) {
		this.consumerList = consumerList;
	}

	public int getSleepIfEmptyProduct() {
		return sleepIfEmptyProduct;
	}

	public void setSleepIfEmptyProduct(int sleepIfEmptyProduct) {
		this.sleepIfEmptyProduct = sleepIfEmptyProduct;
	}

	public int getSleepIfExceptionRaise() {
		return sleepIfExceptionRaise;
	}

	public void setSleepIfExceptionRaise(int sleepIfExceptionRaise) {
		this.sleepIfExceptionRaise = sleepIfExceptionRaise;
	}

	public boolean isSleepWhenExceptionRaise() {
		return sleepWhenExceptionRaise;
	}

	public void setSleepWhenExceptionRaise(boolean sleepWhenExceptionRaise) {
		this.sleepWhenExceptionRaise = sleepWhenExceptionRaise;
	}

}

/**
 * 定時处理任务
 * 
 * @author gzit-team
 * 
 */
public abstract class PeriodicalTask implements Runnable {
	protected int period;
	private AtomicBoolean running = new AtomicBoolean(false);
	private AtomicBoolean paused = new AtomicBoolean(false);

	// 定時寫統計結果的線程
	private Thread taskThread;
	private boolean daemon;

	public PeriodicalTask(int period) {
		this.period = period;
	}

	public void run() {


		while (running.get() && !paused.get()) {
			try {
				Thread.sleep(this.period);
				this.doWork();
			} catch (Exception e) {
				// 处理异常
				try {
					this.handleException(e);
				} catch (Exception e1) {
					// 异常处理再失败，则忽略掉
					// 线程不能死...

				}
			}
		}
	}

	public void shutdown() {
		running.set(false);
		try {
			this.shutdownHook();
			this.taskThread.interrupt();
		} catch (Exception e) {
			// ignore
			// 必须要关的掉

		}
	}

	protected void shutdownHook() {

	}

	public void pause() {
		this.paused.set(true);
	}

	public void resume() {
		this.paused.set(false);
	}

	public boolean isPaused() {
		return paused.get();
	}

	public void start() {
		this.running.set(true);
		this.taskThread = new Thread(this);
		this.taskThread.setDaemon(this.daemon);
		this.taskThread.setName(this.getClass().getSimpleName());
		this.taskThread.start();
	}

	// 可以在这里处理异常
	public void handleException(Exception e) {

	}

	// 子类进行的具体工作
	protected abstract void doWork() throws Exception;

	public boolean isDaemon() {
		return daemon;
	}

	public void setDaemon(boolean daemon) {
		this.daemon = daemon;
	}
}