《Java源码分析》：BlockingQueue之LinkedBlockingQueue

《Java源码分析》：LinkedBlockingQueue

LinkedBlockingQueue是大小不定的BlockingQueue,若其构造函数带一个规定大小的参数,生成的BlockingQueue有大小限制,若不带大小参数,所生成的BlockingQueue的大小由Integer.MAX_VALUE来决定.其所含的对象是以FIFO(先入先出)顺序排序的。

1、LinkedBlockingQueue的继承体系结构

    public class LinkedBlockingQueue<E> extends AbstractQueue<E>
            implements BlockingQueue<E>, java.io.Serializable 

LinkedBlockingQueue的继承体系结构如下，和ArrayBlockingQueue一模一样。

2、LinkedBlockingQueue的相关属性介绍

1、链表节点

    static class Node<E> {
        E item;
        Node<E> next;

        Node(E x) { item = x; }
    }

2、private final int capacity;容量边界，如果没有指定，则为Integer.MAX_VALUE

3、private final AtomicInteger count = new AtomicInteger(); 当前队列中存储元素的数量

4、transient Node head;队列的头结点，且始终head.item=null，即此头结点不存储任何元素。

5、private transient Node last;队列的尾结点，且始终last.next=null.

6、private final ReentrantLock takeLock = new ReentrantLock();take操作时所需要加的锁

7、当take操作时如果队列中存储的元素为空，则调用此Condition的await方法。

    private final Condition notEmpty = takeLock.newCondition();

8、put操作时所需要加的锁和Condition

   private final ReentrantLock putLock = new ReentrantLock();

    private final Condition notFull = putLock.newCondition();

从上面可以看到，LinkedBlockingQueue阻塞队列的实现采用了两把锁，一个是take锁，一个是put锁，这就说明，put和take操作是可以同时进行的。

3、LinkedBlockingQueue的构造方法

创造一个容量为Integer.MAX_VALUE的队列

    public LinkedBlockingQueue() {
        this(Integer.MAX_VALUE);
    }

创造一个指定大小（必须大于零）的队列，如果参数小于等于零，则抛异常。

    public LinkedBlockingQueue(int capacity) {
        if (capacity <= 0) throw new IllegalArgumentException();
        this.capacity = capacity;
        last = head = new Node<E>(null);//头结点和尾结点中存储的元素为null
    }

4、LinkedBlockingQueue的put方法介绍

函数功能：插入一个元素到队列的末尾，如果队列已满则等待直到有空间进行存储

源码如下：（有详细的注释）

    public void put(E e) throws InterruptedException {
        //检查是否为null，如果为null，则抛异常
        if (e == null) throw new NullPointerException();
        //注意：用此局部变量持有一个负数来指示CAS操作是否操作成功。 c = count.getAndIncrement();//利用原子性加一
        int c = -1;
        Node<E> node = new Node<E>(e);//根据当前的值构造一个节点
        final ReentrantLock putLock = this.putLock;
        final AtomicInteger count = this.count;
        putLock.lockInterruptibly();//加锁
        try {

            //如果已到达最大容量，则等待直到有空间来进行存储才会被唤醒
            while (count.get() == capacity) {
                notFull.await();
            }
            enqueue(node);//将节点加入到链表的末尾
            c = count.getAndIncrement();//利用原子性加一
            //如果当前存储的元素个数小于容量，则唤醒正在等待的生产者的线程。
            if (c + 1 < capacity)
                notFull.signal();
        } finally {
            putLock.unlock();//释放锁
        }
        //队列不为空，刚刚添加了一个元素，因此需要唤醒一个消费者线程
        if (c == 0)
            signalNotEmpty();
    }

    /*
     * 将节点加入到链表的末尾
     */
    private void enqueue(Node<E> node) {
        // assert putLock.isHeldByCurrentThread();
        // assert last.next == null;
        last = last.next = node;
    }

    //唤醒一个消费者线程
    private void signalNotEmpty() {
        final ReentrantLock takeLock = this.takeLock;
        takeLock.lock();
        try {
            notEmpty.signal();
        } finally {
            takeLock.unlock();
        }
    }

put方法实现的思想也比较简单，叙述如下：

1、首先检查元素是否为null，如果是，则抛异常，如果不是，则继续进行

2、加锁

3、检查队列是否已满，如果已满，则调用put所对应的Condition的await方法进行等待，直到有signal来将其唤醒。如果没有满，则进行 4.

4、调用enqueue方法将此节点加入到队列中，并将计数器进行加一操作。

本来到这里就差不多结束了，但是还需要处理两种唤醒操作。

5、如果此时队列中存储的元素小于最大容量，则唤醒其他正在等待生产的线程。

6、由于刚刚生产了元素，因此最后还需要唤醒消费者线程。

7、释放锁

put(e)方法的思想相当简单哈，下面来看take方法

LinkedBlockingQueue的take方法介绍

函数功能：获取队列中队首的元素。

源码如下：（有详细的注释）

    public E take() throws InterruptedException {
        E x;
        int c = -1;
        final AtomicInteger count = this.count;
        final ReentrantLock takeLock = this.takeLock;
        takeLock.lockInterruptibly();//加take锁
        try {
            //如果当前队列为空，则一直等待直到队列非空
            while (count.get() == 0) {
                notEmpty.await();
            }
            x = dequeue();//将头结点取出来
            c = count.getAndDecrement();//利用原子性进行进行减一操作
            //如果此时的容量是大于1的，则说明还有其它元素可以被消费线程获取，因此唤醒其他消费者线程
            if (c > 1)
                notEmpty.signal();
        } finally {
            takeLock.unlock();//释放锁
        }
        //如果c的容量是等于capacity，又被消费了一个，因此可以通知生产者线程来进行生产
        if (c == capacity)
            signalNotFull();
        return x;
    }

    private E dequeue() {
        // assert takeLock.isHeldByCurrentThread();
        // assert head.item == null;
        Node<E> h = head;
        Node<E> first = h.next;
        h.next = h; // help GC
        //头结点指向下一个节点，并将头结点中的元素置为null。即头结点的item始终为null。
        head = first;
        E x = first.item;
        first.item = null;
        return x;
    }


    /**
     * 唤醒一个生产者线程
     */
    private void signalNotFull() {
        final ReentrantLock putLock = this.putLock;
        putLock.lock();
        try {
            notFull.signal();
        } finally {
            putLock.unlock();
        }
    }

此方法实现的思想也特别简单，叙述如下：

1、加锁

2、判断队列中是否有元素，如果没有，则阻塞等待直至队列非空被唤醒。如果有，则进行 3

3、取出队列中头结点的下一个节点(头结点为傀儡节点)。并将计数器进行减一操作。

4、如果此时的容量是大于1的，则说明还有其它元素可以被消费线程获取，因此唤醒一个正在等待的消费者线程

5、如果此时的容量小于队列的最大容量，则唤醒正在等待的生产者线程进行生产。

6、释放锁

以上就是关于LinkedBlockingQueue的相关分析，比较简单哈。

小结

关于LinkedBlockingQueue我们只需要记住以下几点

1、是基于链表来实现的

2、使用了两个锁，take、put操作各一把锁。以及借用了两个Condition来进行阻塞和唤醒操作。