生产者消费者问题

/**
 * 生产者消费者问题
 * @author Administrator
 *
 */
public class ProductorAndConsumerTest {
	/**
	 * 市场
	 * @author Administrator
	 */
	class Market {

		private int product;

		private static final int MAX_PRODUCT = 10;

		private static final int MIN_PRODUCT = 3;

		/**
		 * 生产者生产产品
		 */
		public synchronized void produce() {
			if (this.product >= MAX_PRODUCT) {
				try {
					System.out.println("生产者 " + Thread.currentThread().getName() + ": 产品已满,稍候再生产");
					wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				return;
			}
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			this.product++;
			System.out.println("生产者" + Thread.currentThread().getName() + ": 生产第" + this.product + "个产品.");
			notifyAll(); // 通知等待区的消费者可以取出产品了
		}

		/**
		 * 消费者从市场买产品
		 */
		public synchronized void consume() {
			if (this.product <= MIN_PRODUCT) {
				try {
					System.out.println("消费者 " + Thread.currentThread().getName() + ": 缺货,稍候再取");
					wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				return;
			}
			try {
				Thread.sleep(200);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("消费者 " + Thread.currentThread().getName() + " 取走了第" + this.product + "个产品.");
			this.product--;
			notifyAll(); // 通知等待去的生产者可以生产产品了
		}
	}

	/**
	 * 生产者
	 * @author Administrator
	 */
	class Producer implements Runnable {
		private Market product;

		public Producer(Market product) {
			this.product = product;
		}

		@Override
		public void run() {
			try {
				Thread.sleep(50);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			while (true) {
				product.produce();
			}
		}

	}
	
	/**
	 * 消费者
	 * @author Administrator
	 */
	class Consumer implements Runnable {
		private Market product;

		public Consumer(Market product) {
			this.product = product;
		}

		@Override
		public void run() {
			while (true) {
				try {
					Thread.sleep(50);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				product.consume();
			}
		}
	}

	public static void main(String[] args) {
		ProductorAndConsumerTest pt = new ProductorAndConsumerTest();
		Market p = pt.new Market();
		//3个工厂
		Thread pr = new Thread(pt.new Producer(p), "爆米花工厂");
		Thread pr2 = new Thread(pt.new Producer(p), "爆米花工厂2");
		Thread pr3 = new Thread(pt.new Producer(p), "爆米花工厂3");
		//4个消费者
		Thread cr = new Thread(pt.new Consumer(p), "小屁孩");
		Thread cr2 = new Thread(pt.new Consumer(p), "红孩儿");
		Thread cr3 = new Thread(pt.new Consumer(p), "雪鹰");
		Thread cr4 = new Thread(pt.new Consumer(p), "唐三");
		pr.start();
		pr2.start();
		pr3.start();
		cr.start();
		cr2.start();
		cr3.start();
		cr4.start();
	}
}

生产者爆米花工厂2: 生产第1个产品.
生产者爆米花工厂2: 生产第2个产品.
生产者爆米花工厂2: 生产第3个产品.
生产者爆米花工厂2: 生产第4个产品.
生产者爆米花工厂2: 生产第5个产品.
生产者爆米花工厂2: 生产第6个产品.
消费者 红孩儿 取走了第6个产品.
消费者 雪鹰 取走了第5个产品.
生产者爆米花工厂: 生产第5个产品.
生产者爆米花工厂: 生产第6个产品.
生产者爆米花工厂: 生产第7个产品.
消费者 唐三 取走了第7个产品.
消费者 小屁孩 取走了第6个产品.
生产者爆米花工厂3: 生产第6个产品.
消费者 小屁孩 取走了第6个产品.
消费者 唐三 取走了第5个产品.
生产者爆米花工厂: 生产第5个产品.
消费者 雪鹰 取走了第5个产品.
消费者 红孩儿 取走了第4个产品.
生产者爆米花工厂2: 生产第4个产品.
消费者 红孩儿 取走了第4个产品.
消费者 雪鹰: 缺货,稍候再取
生产者爆米花工厂: 生产第4个产品.
生产者爆米花工厂: 生产第5个产品.
生产者爆米花工厂: 生产第6个产品.
生产者爆米花工厂: 生产第7个产品.
生产者爆米花工厂: 生产第8个产品.
消费者 唐三 取走了第8个产品.
消费者 小屁孩 取走了第7个产品.
生产者爆米花工厂3: 生产第7个产品.