java - ArrayBlockingQueue 显示异常行为

Question

我正在研究 BlockingQueue 接口(interface)，其中 ArrayBlockingQueue 是一个实现。出于演示目的，我开发了以下代码:

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class MainJava {
    public static void main(String[] args) {
        BlockingQueue<String> queue = new ArrayBlockingQueue<>(1);
        Producer producer = new Producer(queue);
        Consumer consumer = new Consumer(queue);
        new Thread(producer).start();
        new Thread(consumer).start();
    }
}

class Producer implements Runnable {
    BlockingQueue<String> queue = null;

    public Producer(BlockingQueue<String> queue) {
        this.queue = queue;
        // TODO Auto-generated constructor stub
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                System.out.println("Producer added " + i);
                queue.put(String.valueOf(i));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Consumer implements Runnable {
    BlockingQueue<String> queue = null;

    public Consumer(BlockingQueue<String> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                System.out.println("Consumer used " + queue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

预期行为

Producer add 0
Consumer used 0
Producer add 1
Consumer used 1 
and so on..

Actaul O/P

Producer added 0
Producer added 1
Consumer used 0
Consumer used 1
Producer added 2
Producer added 3
Producer added 4 

我尝试使用 Debug模式，但它工作正常。那么，为什么没有 Debug模式，事情就不能正常工作？

Answer 1

您的代码按预期工作 - 这只是一种“错觉”，您的队列似乎一次包含多个项目，这是由于时间不巧和 System.out.println 在错误的地方:

在您的生产者中，System.out.println 出现在阻塞 put 之前，因此即使 put 必须等到队列变空。

但即使我们交换这两行(让 put 出现在 System.out.println 之前)，输出似乎也是错误的:

Consumer used 0
Producer added 0
Producer added 1
Consumer used 1
Consumer used 2
Producer added 2
Producer added 3
Consumer used 3

不过，这是不吉利的时机造成的错觉。如您所见，在我的输出中，消费者似乎在生产者将其放入队列之前消费了元素 0!当然不是这样。 System.out 是一个 PrintStream 对象，它是线程安全的。所以只有一个线程可以同时打印一些东西。在上面的运行中，消费者线程只是在生产者之前获取了锁。

执行顺序可能是这样的:

1. 生产者:将 0 放入队列
2. 消费者:从队列中取出 0
3. 消费者:打印“消费者使用 0”
4. 消费者:等到队列不为空
5. 生产者:打印“生产者添加 0”
6. 生产者:将 1 放入队列
7. Producer: print 'Producer added 1'
8. 生产者:等到队列未满
9. 消费者:从队列中取 1
10. 消费者:打印“消费者使用 1”
11. 生产者:将 2 放入队列
12. 消费者:从队列中取出 2
13. 消费者:打印“消费者使用 2”
14. Producer: print 'Producer added 2'

等等

在多线程系统中很难争论正确的行为...