多线程执行多任务（线程通信）：生产者消费者模型（一）

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

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

package com.xs.thread;

/**
* 工作台
*
* @author Administrator
*
*/
public class Workbench {
private int number = 0;

private int maxNumber = 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。

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