多线程执行多类型任务（线程通信wait/notify(notifyAll)）：生产者消费者模型（一）

这里使用整数自增和自减来模拟生产和消费。先来简单的，每个任务只有一个线程执行。

先定义一个工作台Workbench，用于生产和消费：

package com.xs.thread;

/**
 * 工作台
 * 
 * @author Administrator
 * 
 */
public class Workbench {
	private int number = 0; // 当前产品存储量

	private int maxNumber = 1;// 最大的产品存储量，默认为1

	private Object talkLocker = new Object();// 定义通信锁

	public Workbench() {
	}

	public Workbench(int maxNumber) {
		this.maxNumber = maxNumber;
	}

	/**
	 * 生产
	 * 
	 * @return
	 */
	public void produce() {
		synchronized (talkLocker) {
			if (number > maxNumber - 1) {
				try {
					talkLocker.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			int temp = ++number;
			// 打印生产后的数量
			System.out.println(Thread.currentThread().getName() + " --> "
					+ temp);
			talkLocker.notify();
		}
	}

	/**
	 * 消费
	 * 
	 * @return
	 */
	public void consume() {
		synchronized (talkLocker) {
			if (number < 1) {
				try {
					talkLocker.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			int temp = --number;
			// 打印消费后的数量
			System.out.println(Thread.currentThread().getName() + " --> "
					+ temp);
			talkLocker.notify();
		}
	}
}

测试：

package com.xs.thread;

public class ThreadTalkTest {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		final Workbench workbench = new Workbench(100);

		// 生产任务
		Runnable produceTask = new Runnable() {

			public void run() {
				while (true) {
					workbench.produce();
				}
			}
		};

		// 消费任务
		Runnable consumeTask = new Runnable() {

			public void run() {
				while (true) {
					workbench.consume();
				}
			}
		};

		System.out.println("start...");

		Thread producer = new Thread(produceTask);
		producer.setName("producer");
		Thread consumer = new Thread(consumeTask);
		consumer.setName("consumer");

		producer.start();
		consumer.start();
	}

}

运行结果遵循以下规范：

1.最小值为0，最大值为100。

2.输出0的一定是消费者，输出100的一定是生产者。

3.永远不会出现两个连续的结果相等。

4.生产者的输出结果一定是在上一次的输出结果上加1；消费者的输出结果一定是在上一次的输出结果上减1。

通信锁具有互斥作用，也就是说当生产者正在生产时，消费者不能消费；当消费者正在消费时，生产者不能生产。通信锁会让相互关联的不同任务不会同时执行。