linkedblockingqueue在java中的原理

// 容量

private final int capacity;

// 元素数量

private final AtomicInteger count = new AtomicInteger();

// 链表头

transient Node<E> head;

// 链表尾

private transient Node<E> last;

// take锁

private final ReentrantLock takeLock = new ReentrantLock();

// notEmpty条件

// 当队列无元素时，take锁会阻塞在notEmpty条件上，等待其它线程唤醒

private final Condition notEmpty = takeLock.newCondition();

// 放锁

private final ReentrantLock putLock = new ReentrantLock();

// notFull条件

// 当队列满了时，put锁会会阻塞在notFull上，等待其它线程唤醒

private final Condition notFull = putLock.newCondition();

public LinkedBlockingQueue() {

    this(Integer.MAX_VALUE);

}

// 限制队列容量,并初始化队列的 head 和 last 节点.

public LinkedBlockingQueue(int capacity) {

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

    this.capacity = capacity;

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

}

// LinkedBlockingQueue(int capacity)初始化,然后加写锁,将集合c一个个入队.

public LinkedBlockingQueue(Collection<? extends E> c) {

    this(Integer.MAX_VALUE);

    final ReentrantLock putLock = this.putLock;

    putLock.lock(); // 写锁(以重入锁实现,对队尾的插入进行控制)

    try {

        int n = 0;

        for (E e : c) {

            // null元素抛出异常

            if (e == null)

                throw new NullPointerException();

            if (n == capacity)

                throw new IllegalStateException("Queue full");

            enqueue(new Node<E>(e)); //将元素封装成Node,入队

            ++n;

        }

        count.set(n);

    } finally {

        putLock.unlock(); // 释放

    }

}