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

    }

}

关于生产者消费者的思考

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

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