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

每个任务有多个线程执行。

工作台类HigherWorkbench：

package com.xs.thread;

/**
 * 工作台
 * 
 * @author Administrator
 * 
 */
public class HigherWorkbench {

	private int number = 0; // 当前产品存储量

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

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

	private Object produceTaskLocker = new Object();// 定义生产任务锁
	private Object consumeTaskLocker = new Object();// 定义消费任务锁

	public HigherWorkbench() {
	}

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

	/**
	 * 生产
	 * 
	 * @return
	 */
	public void produce() {
		synchronized (produceTaskLocker) {
			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 (consumeTaskLocker) {
			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 HigherThreadTalkTest {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		final int maxNumber = 1000;
		final int producers = 100;
		final int consumers = 100;

		final HigherWorkbench workbench = new HigherWorkbench(maxNumber);
		Thread[] producerThreads = new Thread[producers];
		Thread[] consumerThreads = new Thread[consumers];

		// 生产任务
		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...");

		// 创建线程
		for (int i = 0; i < producerThreads.length; i++) {
			Thread thread = new Thread(produceTask);
			thread.setName("producer" + i);
			producerThreads[i] = thread;
		}
		for (int i = 0; i < consumerThreads.length; i++) {
			Thread thread = new Thread(consumeTask);
			thread.setName("consumer" + i);
			consumerThreads[i] = thread;
		}

		// 启动线程
		for (int i = 0; i < producerThreads.length; i++) {
			producerThreads[i].start();
		}
		for (int i = 0; i < consumerThreads.length; i++) {
			consumerThreads[i].start();
		}
	}

}

任务锁用于锁定单个任务，而通信锁表述的是任务之间的协作关系。通常有多少个任务需要执行，就可以定义多少把任务锁；有多少个任务之间的协作关系，就可以定义多少把通信锁。

以上例子中，有两个任务，即生产和消费，所以定义了两个任务锁；生产和消费之间存在协作关系，所以定义了一个通信锁。