Java 多线程2：生产者消费者问题

概念

生产者消费者问题描述了两个线程（即生产者线程和消费者线程），共享固定大小的缓冲区，在实际运行中可能出现的问题。

生成者：生成一定量的数据放到缓冲区中，然后重复此过程。
消费者：在缓冲区消耗这些数据。
该问题的关键就是 要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区中空时消耗数据。

要解决该问题，就必须 让生产者在缓冲区满时休眠（要么干脆就放弃数据），等到下次消费者消耗缓冲区中的数据的时候，生产者才能被唤醒，开始往缓冲区添加数据。同样，也可以让 消费者在缓冲区空时进入休眠，等到生产者往缓冲区添加数据之后，再唤醒消费者 。

死锁的发生

对于多线程的问题，如果处理不好就会出现死锁，如下：

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());        }    }}

关于生产者消费者的思考

其实很多的多线程问题 以及优化方式 都可以归纳为生产者消费者模式。比如说，在上述的例子中，能否两个生产者同时生产呢？能否两个消费者同时消费，以及 当生产者或者消费者唤醒一个线程的时候， 如何保证唤醒的肯定是想要唤醒的线程？

所以说，了解生产者消费者线程还是比较有好处的。