概念
生产者消费者问题描述了两个线程(即生产者线程和消费者线程),共享固定大小的缓冲区,在实际运行中可能出现的问题。
生成者:生成一定量的数据放到缓冲区中,然后重复此过程。
消费者:在缓冲区消耗这些数据。
该问题的关键就是 要保证生产者不会在缓冲区满时加入数据,消费者也不会在缓冲区中空时消耗数据。
要解决该问题,就必须 让生产者在缓冲区满时休眠(要么干脆就放弃数据),等到下次消费者消耗缓冲区中的数据的时候,生产者才能被唤醒,开始往缓冲区添加数据。同样,也可以让 消费者在缓冲区空时进入休眠,等到生产者往缓冲区添加数据之后,再唤醒消费者 。
死锁的发生
对于多线程的问题,如果处理不好就会出现死锁,如下:
int itemCount = 0;
procedure producer() {
while (true) {
item = produceItem();
if (itemCount == BUFFER_SIZE) {
sleep();
}
putItemIntoBuffer(item);
itemCount = itemCount + 1;
if (itemCount == 1) {
wakeup(consumer);
}
}
}
procedure consumer() {
while (true) {
if (itemCount == 0) {
sleep();
}
item = removeItemFromBuffer();
itemCount = itemCount - 1;
if (itemCount == BUFFER_SIZE - 1) {
wakeup(producer);
}
consumeItem(item);
}
}
上面代码中的问题在于它可能导致竞争条件,进而引发死锁。考虑下面的情形:
消费者把最后一个 itemCount的内容读出来,注意它现在是零。消费者返回到while的起始处,现在进入 if 块;
就在调用sleep之前,CPU决定将时间让给生产者,于是消费者在执行 sleep之前就被中断了,生产者开始执行;
生产者生产出一项数据后将其放入缓冲区,然后在 itemCount 上加 1;
由于缓冲区在上一步加 1 之前为空,生产者尝试唤醒消费者;
遗憾的是,消费者并没有在休眠,唤醒指令不起作用。当消费者恢复执行的时候,执行 sleep,一觉不醒。出现这种情况的原因在于,消费者只能被生产者在 itemCount 为 1 的情况下唤醒;
生产者不停地循环执行,直到缓冲区满,随后进入休眠。
由于两个进程都进入了永远的休眠,死锁情况出现了。因此,该算法是不完善的。
Java 中的例子(解决生成者消费者问题)
import java.util.LinkedList;
import java.util.concurrent.atomic.AtomicInteger;
public class ProducerConsumerTest {
private final static int BUFFER_SIZE = 10;
private static LinkedList<Object> buffer = new LinkedList<Object>();
public static void main (String args[]){
//创建2个Producer,3个Consumer
Thread producerA = new Thread(createProducer("producerA"));
Thread producerB = new Thread(createProducer("producerB"));
Thread consumerA = new Thread(createConsumer("consumerA"));
Thread consumerB = new Thread(createConsumer("consumerB"));
Thread consumerC = new Thread(createConsumer("consumerC"));
producerA.start();
producerB.start();
consumerA.start();
consumerB.start();
consumerC.start();
}
private static Producer createProducer(String name){
return new Producer(name);
}
private static Consumer createConsumer(String name){
return new Consumer(name);
}
static class Producer extends Thread{
public Producer(String name){
this.setName(name);
}
private static AtomicInteger i = new AtomicInteger(0);
@Override
public void run() {
while(i.getAndIncrement() < BUFFER_SIZE){
synchronized (buffer){
produce();
buffer.notifyAll();
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void produce(){
buffer.add(new Object());
System.out.println(this.getName() + " produce object. buffer.size = " + buffer.size());
}
}
static class Consumer extends Thread{
public Consumer(String name){
this.setName(name);
}
private static AtomicInteger i = new AtomicInteger(0);
@Override
public void run() {
while (i.getAndIncrement() < BUFFER_SIZE) {
synchronized (buffer) {
while (buffer.size() == 0) {
try {
buffer.wait(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
consumer();
}
}
}
public void consumer(){
buffer.removeFirst();
System.out.println(this.getName() + " consume object. buffer.size = " + buffer.size());
}
}
}
关于生产者消费者的思考
其实很多的多线程问题 以及优化方式 都可以归纳为生产者消费者模式。比如说,在上述的例子中,能否两个生产者同时生产呢?能否两个消费者同时消费,以及 当生产者或者消费者唤醒一个线程的时候, 如何保证唤醒的肯定是想要唤醒的线程?
所以说,了解生产者消费者线程还是比较有好处的。