深入理解Java并发编程之LinkedBlockingQueue队列

private final AtomicInteger count = new AtomicInteger();

/** Lock held by take, poll, etc */

private final ReentrantLock takeLock = new ReentrantLock();

/** Wait queue for waiting takes */

private final Condition notEmpty = takeLock.newCondition();

/** Lock held by put, offer, etc */

private final ReentrantLock putLock = new ReentrantLock();

/** Wait queue for waiting puts */

private final Condition notFull = putLock.newCondition();

public static final int MAX_VALUE = 0x7fffffff ;

public LinkedBlockingQueue() {

     this (Integer.MAX_VALUE);

}

public LinkedBlockingQueue( int capacity) {

     if (capacity <= 0 ) throw new IllegalAgrumentException();

     this .capacity = capacity;

     last = head = new Node<E>( null );

}

public boolean offer(E e) {

//(1)

     if (e == null ) throw new NullPointerException();

     //(2)

     final AtomicInteger count = this .count;

     if (count.get() == capacity)

         return false ;

         //(3)

     int c = - 1 ;

     Node<E> node = new Node<E>(e);

     final ReentrantLock putLock = this .putLock;

     putLock.lock();

     try {

     //(4)

         if (count.get() < capacity) {

             enqueue(node);

             c = count.getAndIncrement();

             //(5)

             if (c + 1 < capacity)

                 notFull.signal();

         }

     } finally {

     //(6)

         putLock.unlock();

     }

     //(7)

     if (c == 0 )

         signalNotEmpty();

         //(8)

     return c >= 0 ;

}