LinkedBlockingQueue

一、LinkedBlockingQueue是什么？
LinkedBlockingQueue是一个线程安全的阻塞队列，具有先进先出等特性。主要实现BlockingQueue接口，BlockingQueue接口继承自java.util.Queue接口，并在这个接口的基础上增加了take和put方法。

二、线程安全？
在LinkedBlockingQueue的所有共享的全局变量 中，final声明的capacity在构造器生成实例时就成了不可变量了。而final声明的count由于是AtomicInteger类型的，所以能 够保证其操作的原子性。剩下的final的变量都是初始化成了不可变量，并且不包含可变属性，所以都是访问安全的。那么剩下的就是Node类型的head和 last两个可变量。所以要保证LinkedBlockingQueue是线程安全的就是要保证对head和last的访问是线程安全的 ，其中LinkedBloakingQueue是使用读和写两把锁来控制并发操作的。 如下：

    static class Node<E> {
        E item;
        Node<E> next;
        Node(E x) { item = x; }
    }

    /** The capacity bound, or Integer.MAX_VALUE if none */
    private final int capacity;

    /** Current number of elements */
    private final AtomicInteger count = new AtomicInteger();

    /**
     * Head of linked list.
     * Invariant: head.item == null
     */
    transient Node<E> head;

    /**
     * Tail of linked list.
     * Invariant: last.next == null
     */
    private transient Node<E> last;

    /** 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();

三、链表的入队和出队
LInkedBlockingQueue中的链表，包含头指针和尾指针，其中：
头指针用来管理元素出队，和 take(), poll(), peek() 三个操作关联
尾指针用来管理元素入队，和 put(), offer() 两个操作关联
入队：
put()算法，为阻塞算法，直到队列有空余时，才能为队列加入新元素
offer()算法为非阻塞算法，如果队列已满，立即返回或等待一会再返回，通过返回值ture或false，标记本次入队操作是否成功；
出队：
take()算法为阻塞算法，直到队列有非空时，才将允许调用线程取出数据
poll()算法为非阻塞算法，如果队列为空，立即返回或等待一会再返回，通过返回值ture或false，标记本次出队操作是否成功
peek()算法比较特殊，只返回队列中的第一个元素，既不出队，也不阻塞，如果没有元素，就返回null

四、take和put

    //出队
    public E take() throws InterruptedException {
        E x;
        int c = -1;
        final AtomicInteger count = this.count;
        final ReentrantLock takeLock = this.takeLock;
        takeLock.lockInterruptibly();//随时保证响应中断 
        try {
            while (count.get() == 0) {
                notEmpty.await();//队列为null时，,此时线程将处于阻塞状态，直到有新的元素
            }
            x = dequeue();//取出元素
            c = count.getAndDecrement(); // 取出元素之后，将“节点数量”-1；并返回“原始的节点数量”。
            if (c > 1)
                notEmpty.signal();//唤醒其他正在等待出队列的线程
        } finally {
            takeLock.unlock();
        }
        if (c == capacity)
            signalNotFull();
        return x;
    }

  //入队
    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;
        Node<E> node = new Node<E>(e);
        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(node);// //让元素进入队列的末尾
            c = count.getAndIncrement();//c是旧值，为了下面的c==0的判断。意思就是，之前没有元素，现在有了，其他线程赶紧来获取。
            if (c + 1 < capacity)
                notFull.signal();//唤醒其他正在等待入队列的线程
        } finally {
            putLock.unlock();
        }
        if (c == 0)  /*当c=0时，当前队列为空队列,出队列的线程都处于等待状态，
        现在新添加了一个新的元素,即队列不再为空,因此它会唤醒正在等待获取元素的线程。
        */
            signalNotEmpty();
    }

其中enqueue和dequeue
enqueue()的源码如下：将元素E添加到队列的末尾，设置node为新的尾节点！

private void enqueue(Node<E> node) {
    // assert putLock.isHeldByCurrentThread();
    // assert last.next == null;
    last = last.next = node;
}

dequeue()的源码如下：删除队列的头节点，并将表头指向“原头节点的下一个节点”。

private E dequeue() {
 // assert takeLock.isHeldByCurrentThread();
 // assert head.item == null; 
  Node<E> h = head; 
  Node<E> first = h.next; 
  h.next = h; // help GC 
  head = first;
   E x = first.item; 
  first.item = null; 
  return x;
}

问题：
补充两个线程去生产和消费的图
Lock的条件变量？ c= count.getAndIncrement();？count原子性的理解