生产者-消费者模式指的是：生产者和消费者在同一个时间段共用同一段空间，在这段时间内，生产者负责往存储空间生产数据，而消费者则负责消费数据。实际上存在很多类似的场景：消息中间件就可以看做这种模式的应用，客户端请求负责把请求消息发送给消息中间件，然后由服务器负责从消息中间件获取请求并进行响应；还有网络编程中Socket也可以看做是生产者消费者模式的应用，etc。
为了简化问题的研究，现在仅仅考虑一种简单的场景：生产者负责生产“authorA–>titleA”和“authorB–>titleB”两种数据（这两种数据是一种代表author和title可以认为是生产的两种组件，并无实际意义），消费者则负责从中取数据。根据前面对线程安全的研究，该场景可能会出现取到的数据不完整或者重复取数据的情况。出现数据完整表现在：生产者生产完author后，还没有来得及生产title便被消费者取走了，这种情况需要使用线程同步机制实现；取到重复的数据表现在：消费者取到完整的数据后，没有及时通知生产者继续生产，导致第二次取到的数据仍然是上次取到的数据，显然这种情况需要使用等待/通知机制实现。
首先我们来定义需要生产的组件：Content。Content包括了两个组件信息：author和title，并提供了消费者和生产者执行的get和set方法
package com.rhwayfun.concurrency;
import java.util.concurrent.TimeUnit;
/**
* Created by rhwayfun on 16-4-4.
*/
public class Content {
//标题
private String title;
//作者
private String author;
//是否开始生产的标志，默认开始生产
private boolean produce = true;
/**
* 消费者执行的方法
* @param author
* @param title
* @throws InterruptedException
*/
public synchronized void set(String author, String title) throws InterruptedException {
//如果没有开始生产就阻塞等待
while (!produce) {
super.wait();
}
//设置作者
this.setAuthor(author);
//休眠1秒
TimeUnit.SECONDS.sleep(1);
//设置标题
this.setTitle(title);
System.out.println("[生产者]:" + this.getAuthor() + " --> " + this.getTitle());
//设置标志位为false。表示可以取数据了
produce = false;
//唤醒正在等待的线程
super.notify();
}
/**
* 消费者执行的方法
* @throws InterruptedException
*/
public synchronized void get() throws InterruptedException {
//如果已经开始生产了就阻塞等待
while (produce){
super.wait();
}
System.out.println("[消费者]:" + this.getAuthor() + " --> " + this.getTitle());
//让生产者继续生产
produce = true;
super.notify();
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
}
然后，我们定义了生产者，把生产者执行的生产任务放在一个线程中单独执行：
package com.rhwayfun.concurrency;
/**
* Created by rhwayfun on 16-4-4.
*/
public class Producer implements Runnable {
private Content content;
public Producer(Content content) {
this.content = content;
}
public void run() {
boolean flag = true;
for (int i = 0; i < 6; i++){
if (flag){
try {
content.set("authorA","titleA");
} catch (InterruptedException e) {
e.printStackTrace();
}
flag = false;
}else {
try {
content.set("authorB","titleB");
} catch (InterruptedException e) {
e.printStackTrace();
}
flag = true;
}
}
}
}
接着，我们定义消费者，消费者的消费任务也放在线程中单独执行：
package com.rhwayfun.concurrency;
/**
* Created by rhwayfun on 16-4-4.
*/
public class Consumer implements Runnable {
private Content content;
public Consumer(Content content) {
this.content = content;
}
public void run() {
for (int i = 0; i < 6; i++){
try {
content.get();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
最后，就是我们的测试代码了：
package com.rhwayfun.concurrency;
/**
* Created by rhwayfun on 16-4-4.
*/
public class ProducerConsumerModeTest {
public static void main(String[] args){
Content content = new Content();
Thread producer = new Thread(new Producer(content),"Producer");
Thread consumer = new Thread(new Consumer(content),"Consumer");
producer.start();
consumer.start();
}
}
运行上面的测试代码，得到的结果如下：
从运行结果可以看出，只有当生产者生产了数据后消费者才会从中取数据，这样取到的数据就不会重复。由一点要注意的是：消费者线程循环的次数必须和生产者线程一致，不然就会出现消费者一直等待生产者生产数据的情况，这点从代码中就可以看出，因为如果生产者没有继续生产的话消费者调用wait方法便会阻塞等待直到有数据。