在Java中,BlockingQueue是否完全是线程安全的

我问,因为这个答案让我第二次猜测：
https://stackoverflow.com/a/22006181/4164238

首先是一个小房子,BlockingQueue是一个接口,任何非线程安全的实现都将破坏记录的合同.你包含的链接指的是LinkedBlockingQueue,它有一些聪明之处.

link that you included做了一个有趣的观察,是的,LinkedBlockingQueue中有两个锁.然而,它无法理解“简单”实现可能违反的边缘情况实际上正在被处理,这就是为什么take和put方法比最初期望的更复杂.

LinkedBlockingQueue经过优化,可以避免在读取和写入时使用相同的锁定,这样可以减少争用,但是对于正确的行为,它依赖于队列不为空.当队列中包含元素时,推送和弹出点不在同一内存区域,并且可以避免争用.但是当队列为空时,无法避免争用,因此需要额外的代码来处理这种常见的“边缘”情况.这是代码复杂性和性能/可伸缩性之间的常见折衷.

接下来的问题是,LinkedBlockingQueue如何知道队列是空的/非空的,从而处理线程呢？答案是它使用AtomicInteger和Condition作为两个额外的并发数据结构. AtomicInteger用于检查队列的长度是否为零,并且当队列可能处于所需状态时,条件用于等待信号通知等待线程.这种额外的协调确实有开销,但是在测量中已经表明,当增加并发线程的数量时,该技术的开销低于使用单个锁引入的争用.

下面我复制了LinkedBlockingQueue中的代码,并添加了解释它们如何工作的注释.在较高级别,take()首先锁定所有其他调用take(),然后根据需要发出put()信号. put()以类似的方式工作,首先它阻止put()的所有其他调用,然后在必要时发出take()信号.

从put()方法：

    // putLock coordinates the calls to put() only; further coordination
    // between put() and take() follows below
    putLock.lockInterruptibly();
    try {
        // block while the queue is full; count is shared between put() and take()
        // and is safely visible between cores but prone to change between calls
        // a while loop is used because state can change between signals, which is
        // why signals get rechecked and resent.. read on to see more of that 
        while (count.get() == capacity) { 
                notFull.await();
        }

        // we know that the queue is not full so add
        enqueue(e);
        c = count.getAndIncrement();

        // if the queue is not full, send a signal to wake up 
        // any thread that is possibly waiting for the queue to be a little
        // emptier -- note that this is logically part of 'take()' but it
        // has to be here because take() blocks itself
        if (c + 1 < capacity)
            notFull.signal();
    } finally {
        putLock.unlock();
    }
    if (c == 0)
        signalNotEmpty();

来自take()

    takeLock.lockInterruptibly();
    try {
            // wait for the queue to stop being empty
            while (count.get() == 0) {
                notEmpty.await();
            }

        // remove element
        x = dequeue();

        // decrement shared count
        c = count.getAndDecrement();

        // send signal that the queue is not empty
        // note that this is logically part of put(), but
        // for thread coordination reasons is here
        if (c > 1)
            notEmpty.signal();
    } finally {
        takeLock.unlock();
    }
    if (c == capacity)
        signalNotFull();