title: Java LinkedBlockingQueue Realization
body: <p>I looked at JDK <code>LinkedBlockingQueue</code> class and was lost.</p>
  
  <pre><code>public void put(E e) throws InterruptedException {
      if (e == null) throw new NullPointerException();
      // Note: convention in all put/take/etc is to preset local var
      // holding count negative to indicate failure unless set.
      int c = -1;
      final ReentrantLock putLock = this.putLock;
      final AtomicInteger count = this.count;
      putLock.lockInterruptibly();
      try {
          /*
           * Note that count is used in wait guard even though it is
           * not protected by lock. This works because count can
           * only decrease at this point (all other puts are shut
           * out by lock), and we (or some other waiting put) are
           * signalled if it ever changes from
           * capacity. Similarly for all other uses of count in
           * other wait guards.
           */
          while (count.get() == capacity) { 
                  notFull.await();
          }
          enqueue(e);
          c = count.getAndIncrement();
          if (c + 1 &lt; capacity)
              notFull.signal();
      } finally {
          putLock.unlock();
      }
      if (c == 0)
          signalNotEmpty();
  }
  </code></pre>
  
  <p>Look please at the last condition <code>(c == 0)</code>, I think it should be <code>(c != 0)</code></p>
  
  <p>Thank you, I understand.
  But I have another one question about LinkedBlockingQueue realization.
  enqueue and dequeue function must not intersect. I see that when put() is executed, take() could be executed too. And head and tail objects have not synchronization, than enqueue and dequeue could work simultaneously in different thread. It is not thread-safe, failures could occur.</p>