java - 我想使用 Java 中的生产者-消费者模型将竞争条件复制到死锁

Question

在 wiki 上，我发现了以下生产者-消费者程序的伪代码，该程序具有可能导致死锁的竞争条件:

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. 消费者刚刚读取了变量 itemCount，注意到它为零，并且即将移入 if block 内。

2. 就在调用 sleep 之前，消费者被中断并恢复生产者。

3. 生产者创建一个项目，将其放入缓冲区，并增加 itemCount。

4. 由于缓冲区在最后一次添加之前为空，因此生产者尝试唤醒消费者。

5. 不幸的是，消费者尚未休眠，唤醒调用丢失。当消费者恢复时，它会进入休眠状态，并且永远不会再次被唤醒。这是因为只有当 itemCount 等于 1 时，消费者才会被生产者唤醒。

6. 生产者将循环直到缓冲区已满，之后它也会进入休眠状态。

我希望能够在 Java 中复制这一点，但到目前为止，在运行我的程序多次后我无法做到这一点。这是我的代码:

private LinkedList<Integer> sharedList = new LinkedList<Integer>();
private int sharedValue = 0;
private int MAX_LIMIT = 10;

public void produce() throws InterruptedException {

    Random random = new Random();

    while (true) {
        synchronized (this) {
            if (sharedValue == MAX_LIMIT) { //'produce' thread waits if list is full
                wait();
            }
            sharedValue = sharedValue + 1;
            sharedList.add(sharedValue); System.out.println("added value: " + sharedValue);

            if (sharedValue == 1) {
                notify(); //notifies  'consume' thread if list is not empty
            }
        }
    }
}

public void consume() throws InterruptedException {

    Random random = new Random();

    while (true) {
        synchronized (this) {
            if (sharedValue == 0) {    //'consume' waits if list is empty
                wait();
            }

            sharedValue = sharedValue - 1;
            sharedList.remove(); System.out.println("removed value: " + sharedValue);

            if (sharedValue == MAX_LIMIT-1) {
                notify(); //notifies 'produce' if list is not full
            }
        }
        Thread.sleep(random.nextInt(1000));
    }

}

Answer 1

原因是您同步了整个迭代步骤。 synchronized (this) {...} 下的两个代码块将按顺序运行。

您可以通过以下方式复制它:

    private LinkedList<Integer> sharedList = new LinkedList<Integer>();
    private volatile int sharedValue = 0;
    private int MAX_LIMIT = 10;

    public void produce() throws InterruptedException {

        while (true) {

            if (sharedValue == MAX_LIMIT) { //'produce' thread waits if list is full
                synchronized (this) {
                    wait();
                }
            }
            synchronized (this) {
                sharedValue = sharedValue + 1;
                sharedList.add(sharedValue);
                System.out.println("added value: " + sharedValue);
            }

            if (sharedValue == 1) {
                synchronized (this) {
                    notify(); //notifies  'consume' thread if list is not empty
                }
            }
        }

    }

    public void consume() throws InterruptedException {

        while (true) {

            if (sharedValue == 0) {    //'consume' waits if list is empty
                synchronized (this) {
                    wait();
                }
            }

            synchronized (this) {
                sharedValue = sharedValue - 1;
                sharedList.remove();
                System.out.println("removed value: " + sharedValue);
            }

            if (sharedValue == MAX_LIMIT - 1) {
                synchronized (this) {
                    notify(); //notifies 'produce' if list is not full
                }
            }
        }

    }