生产者-消费者实现（缓冲池为1，用一个整数表示一个产品）

[u]转自http://www.riabook.cn/doc/designpattern/ProducerConsumer.htm[/u][size=medium]Producer Consumer模式与 Guarded Suspension 模式 是类似的，只不过Guarded Suspension模式并不限制缓冲区的长度，Producer Consumer模式假设所生产的产品放置在一个长度有限制的缓冲区（就像是一个产品桌，它可以摆放的空间是有限的），如果缓冲区满了，则生产者必须停止继续将产品放到缓冲区中，直到消费者取走了产品而有了空间，而如果缓冲区中没有产品，当然消费者必须等待，直到有新的产品放到缓冲区中。

以下是一个最简单的：生产者每次生产一个整数并放置在桌子上，而消费者消耗整数，桌子上一次只能放置一个整数，如果桌子上已有整数，则生产者等待消费者将整数消耗并通知生产者生产下一个整数，如果桌子上没有整数，则消费者等待生产者生产整数并通知消费者可以消耗整数。[/size]

package cache;
//生产者
public class Producer extends Thread {
	private ProductTable productTable;

	public Producer(ProductTable productTable) {
		this.productTable = productTable;
	}

	public void run() {
		System.out.println("Produce integer......");
		for (int product = 1; product <= 10; product++) {
			try { // wait for a random time
				Thread.sleep((int) Math.random() * 3000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			productTable.setIntProduct(product); //向桌面放置一个整数，代表生成了一个产品
		}
	}
}

package cache;
//消费者
public class Consumer extends Thread {
	private ProductTable productTable;

	public Consumer(ProductTable productTable) {
		this.productTable = productTable;
	}

	public void run() {
		System.out.println("Comsume integer......");
		for (int i = 1; i <= 10; i++) {
			try { // wait for a random time
				Thread.sleep((int) (Math.random() * 3000));
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			productTable.getProductInt(); //从桌面取出一个整数，代表消耗一个产品
		}
	}
}

package cache;

public class ProductTable { //充当缓冲池
	private int productInt = -1; // -1 for no product

	public synchronized void setIntProduct(int product) {
		if (productInt != -1) { //如果还有产品，先等待，说明一次只能生成一个，直到这个消耗完之后才能生成下一个
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		productInt = product;
		System.out.println("set (" + product + ")");
		notify(); //通知消费者已经生产了一个产品
	}

	public synchronized int getProductInt() {
		if (productInt == -1) { //如果没有产品，等待
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		int p = productInt;
		System.out.println("Get (" + productInt + ")");
		productInt = -1;  //消费完了，无产品了，
		notify(); //通知生产者
		return p;
	}
}

测试的客户端：

package cache;

public class Client {

//	生产者会生产10个整数，而消费者会消耗10个整数，由于桌上只能放置一个整数，所以每生产一个就消耗一个。

	public static void main(String[] args) {

		ProductTable table = new ProductTable();
		table.setIntProduct(-1);
		Consumer c= new Consumer(table);
		c.start();

		Producer p = new Producer(table);
		p.start();

	}

}

测试结果：
set (-1)
Comsume integer......
Produce integer......
set (1)
Get (1)
set (2)
Get (2)
set (3)
Get (3)
set (4)
Get (4)
set (5)
Get (5)
set (6)
Get (6)
set (7)
Get (7)
set (8)
Get (8)
set (9)
Get (9)
set (10)
Get (10)