java多线程编程 | 生产者消费者问题：Producer-Consumer 上

https://en.wikipedia.org/wiki/Producer–consumer_problem

背景

计算机领域，多线程编程是重要的编程技能，适用于多个领域；生产者消费者问题是多线程同步的经典问题：两个线程共享一块固定大小的内存区域(buffer)，一个负责写数据，一个负责读数据。

核心问题就是如何保证buffer满时，生产者不要继续写数据，buffer空消费者不要读数据。

有问题的实现

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

潜在的死锁问题：

1. consumer检测到buffer为空，准备去sleep()
2. consumer在调用sleep()之前被打断，调度器唤醒了produer线程
3. producer线程向buffer添加数据，此时buffer大小为1，调用wakeup(consumer)，此时consumer并没有sleep，wakeup无效。
4. consumer线程恢复，进入sleep状态，并且不会被唤醒。
5. producer在buffer满时，也进入sleep状态，两个线程都进入sleep状态，导致死锁

有问题的实现(java版本)

1. java如何创建线程
2. java线程的状态：New/Runnable/Blocked/Waiting/Time Waiting/Terminated
3. java如何唤醒线程

// 这个实现有不少问题，可以思考一下

public class Buffer  {

        private static Queue<Item> q = new LinkedList<Item>();
    
    public static void putItemIntoBuffer(Item e) {
        q.offer(e);
    }

    public static Item removeItemFromBuffer() {
        return q.isEmpty() ? null : q.poll();
    }

    public static int size(){
        return q.size();
    }

}
    
public class Item {
    private String location;
    private Long timeStamp;

    Item(String location, Long time){
        this.location = location;
        this.timeStamp = time;
    }
    
    @Override
    public String toString() {
        return "Item{" +
                "location='" + location + '\'' +
                ", timeStamp=" + timeStamp +
                '}';
    }
}

public class Producer implements Runnable {
    private final int SLEEP_TIME = 5000;
    private Thread consumer;

    public void setConsumer(Thread consumer) {
        this.consumer = consumer;
    }

    public void run() {
        StdOut.println("producer: run");
        while (true) {
            Item item = produceItem();
            if (Buffer.size() == Constants.BUFFER_SIZE) {
                while (true) {
                    try {
                        Thread.sleep(SLEEP_TIME);
                    } catch (InterruptedException e) {
                        StdOut.println("producer: wake up");
                        break;
                    }
                }
            }
            Buffer.putItemIntoBuffer(item);
            StdOut.println("producer: add item: " + item + " size: " + Buffer.size());
            if (Buffer.size() == 1) {
                consumer.interrupt();
                StdOut.println("producer: interrupt consumer");
            }
        }
    }

    private Item produceItem() {
        return new Item("beijing", System.currentTimeMillis());
    }
}

public class Consumer implements Runnable {
    private static final int SLEEP_TIME = 2000;
    private Thread producer;

    public void setProducer(Thread producer) {
        this.producer = producer;
    }

    public void run() {
        StdOut.println("consumer: run");
        while (true) {
            if (Buffer.size() == 0) {
                // simulate dead lock
                // if blocked here, may dead lock
                while (true) {
                    try {
                        Thread.sleep(SLEEP_TIME);
                    } catch (InterruptedException e) {
                        StdOut.println("consumer: wake up");
                        break;
                    }
                }
            }
            Item item = Buffer.removeItemFromBuffer();
            StdOut.println("consumer: get item: " + item + " size: " + Buffer.size());
            if (Buffer.size() == Constants.BUFFER_SIZE - 1) {
                producer.interrupt();
                StdOut.println("consumer: interrupt producer");
            }
        }
    }
}

public class ProducerConsumerProcess {
    public static void main(String[] args) {
        Producer producer = new Producer();
        Consumer consumer = new Consumer();

        Thread p = new Thread(producer);
        Thread c = new Thread(consumer);

        producer.setConsumer(c);
        consumer.setProducer(p);

        p.start();
        c.start();
    }
}

问题：
1）竞争引起的死锁
2）这个用interrupt实现的notify功能，sleep实现wait功能，应该有些问题。而且不适用多生产者和多消费者场景。

解法：使用条件变量