Java8 ReentrantLock 조건 운용

   LinkedBlockingQueue  ，  ReentrantLock Condition   。

/** 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 boolean offer(E e, long timeout, TimeUnit unit)
    throws InterruptedException {

    if (e == null) throw new NullPointerException(); //      ，       
    long nanos = unit.toNanos(timeout); //          
    final int c;
    final ReentrantLock putLock = this.putLock; //     
    final AtomicInteger count = this.count; //    
    putLock.lockInterruptibly(); //       
    try {
        while (count.get() == capacity) { //     ，    
            if (nanos <= 0L) //       
                return false; //  false，      
            nanos = notFull.awaitNanos(nanos); //    CPU  ，    ，    ，  while  
        }
        enqueue(new Node(e)); //     ，    ，       
        c = count.getAndIncrement(); //         ，       +1
        if (c + 1 < capacity) //     
            notFull.signal();  //  notFull
    } finally {
        putLock.unlock(); //       
    }
    if (c == 0) //          0
        signalNotEmpty(); //     ，  notEmpty
    return true; //  true，      
}

public E poll(long timeout, TimeUnit unit) throws InterruptedException {
    final E x;
    final int c;
    long nanos = unit.toNanos(timeout); //          
    final AtomicInteger count = this.count; //    
    final ReentrantLock takeLock = this.takeLock; //     
    takeLock.lockInterruptibly(); //       
    try {
        while (count.get() == 0) { //     ，    
            if (nanos <= 0L) //       
                return null; //  null，      
            nanos = notEmpty.awaitNanos(nanos); //    CPU  ，    ，    ，  while  
        }
        x = dequeue(); //     ，    ，             
        c = count.getAndDecrement(); //         ，       -1
        if (c > 1) //     
            notEmpty.signal(); //  notEmpty
    } finally {
        takeLock.unlock(); //       
    }
    if (c == capacity) //          
        signalNotFull(); //     ，  notFull
    return x; //       
}

1. Condition：    ，  while    。1.            ；2.    。
2. LinkedBlockingQueue      takeLock、putLock，     ，            ，        ，  putLock       signalNotEmpty，  takeLock 。