深入理解LinkedBlockingQueue

 

说明

通过阅读源码，了解LinkedBlockingQueue的特性。本文基于JDK1.7源码

正文

通过查询API对LinkedBlockingQueue特点进行简单的了解：

• LinkedBlockingQueue是一个基于已链接节点的，范围任意的blocking queue
• 此队列按FIFO（先进先出）排序元素
• 新元素插入到队列的尾部，并且队列获取操作会获得位于队列头部的元素
• 链接队列的吞吐量通常要高于基于数组的对列（ArrayBlockingQueue）,但是在大多数并发应用程序中，其可预知的性能要低
• 可选的容量范围构造方法参数作为防止队列过度扩展的一种方法，如果未指定容量，则等于Integer.MAX_VALUE，除非插入节点会使队列超出容量，否则每次插入后会动态地创建链接节点

LinkedBlockingQueue

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

LinkedBlockingQueue继承自AbstractQueue,实现了BlockingQueue,Serializable接口
关于BlockingQueue接口在《深入理解ArrayBlockingQueue》一文中已有介绍，在此不再赘述

节点内部类Node

static class Node<E> {
        E item;

        /**
         * One of:
         * - the real successor Node
         * - this Node, meaning the successor is head.next
         * - null, meaning there is no successor (this is the last node)
         */
        Node<E> next; //指向下个节点

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

LinkedBlockingQueue的属性

    private final int capacity; // 队列容量，如果构造时未指定则为Integer.MAX_VALUE

    //使用AtomicInteger来统计队列中元素数量
    private final AtomicInteger count = new AtomicInteger(0);

    /**
     * Head of linked list.
     * Invariant: head.item == null
     */
    private transient Node<E> head; // 队列的头元素 值为null 

    /**
     * Tail of linked list.
     * Invariant: last.next == null
     */
    private transient Node<E> last; // 队列的尾元素 它的下一个节点为null

    /** Lock held by take, poll, etc */
    private final ReentrantLock takeLock = new ReentrantLock(); // 出队锁

    /** Wait queue for waiting takes */
    private final Condition notEmpty = takeLock.newCondition(); // 取出线程condition

    /** Lock held by put, offer, etc */
    private final ReentrantLock putLock = new ReentrantLock(); // 入队锁

    /** Wait queue for waiting puts */
    private final Condition notFull = putLock.newCondition(); // 添加线程condition

LinkedBlockingQueue的构造函数

public LinkedBlockingQueue() {
        this(Integer.MAX_VALUE); //当未指定容量时，为Integer.MAX_VALUE
    }

• 1
• 2
• 3

public LinkedBlockingQueue(int capacity) {
        if (capacity <= 0) throw new IllegalArgumentException();
        this.capacity = capacity;
        last = head = new Node<E>(null); // 构造队列时创建值为null的节点
    }

LinkedBlockingQueue的添加方法

put(e)

该方法没有返回值，当队列已满时，会阻塞当前线程

 public void put(E e) throws InterruptedException {
        if (e == null) throw new NullPointerException();//先检查添加值是否为null
        // 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); //先创建新的节点
        final ReentrantLock putLock = this.putLock; //使用putLock来保证线程安全
        final AtomicInteger count = this.count;
        putLock.lockInterruptibly();
        try {

            while (count.get() == capacity) {//当队列已满，添加线程阻塞
                notFull.await();
            }
            enqueue(node); // 调用enqueue方法添加到队尾
            c = count.getAndIncrement(); //调用AtomicInteger的getAndIncrement()是数量加1
            if (c + 1 < capacity)//添加成功后判断是否可以继续添加，队列未满
                notFull.signal(); //唤醒添加线程
        } finally {
            putLock.unlock();
        }
        if (c == 0) // 添加后如果队列中只有一个元素，唤醒一个取出线程，使用取出锁
            signalNotEmpty();
    }

offer(e,timeout,unit)

该方法返回true或false，当队列已满时，会阻塞给定时间，添加操作成功返回true，否则返回false

public boolean offer(E e, long timeout, TimeUnit unit)
        throws InterruptedException {

        if (e == null) throw new NullPointerException();
        long nanos = unit.toNanos(timeout);
        int c = -1;
        final ReentrantLock putLock = this.putLock; //使用putLock
        final AtomicInteger count = this.count;
        putLock.lockInterruptibly();
        try {
            while (count.get() == capacity) { //当队列已满阻塞给定时间
                if (nanos <= 0) //当时间消耗完全，操作未成功 返回false
                    return false;
                nanos = notFull.awaitNanos(nanos);
            }
            enqueue(new Node<E>(e)); // 调用enqueue方法添加一个新的节点
            c = count.getAndIncrement(); //同样调用AtomicInteger的方法
            if (c + 1 < capacity)
                notFull.signal();
        } finally {
            putLock.unlock();
        }
        if (c == 0)
            signalNotEmpty();
        return true; // 操作成功返回true
    }

offer(e)

该方法返回true或false，不会阻塞，直接返回

 public boolean offer(E e) {
        if (e == null) throw new NullPointerException();
        final AtomicInteger count = this.count;
        if (count.get() == capacity)
            return false; //当队列已满，直接返回false
        int c = -1;
        Node<E> node = new Node(e); // 先创建新的节点
        final ReentrantLock putLock = this.putLock;//使用putLock
        putLock.lock();
        try {
            if (count.get() < capacity) { // 加锁后再次判断队列是否已满
                enqueue(node); //调用enqueue方法将节点添加到队尾
                c = count.getAndIncrement();
                if (c + 1 < capacity)
                    notFull.signal();
            }
        } finally {
            putLock.unlock();
        }
        if (c == 0)
            signalNotEmpty();
        return c >= 0; // 比较c的大小，判断是否成功，当c大于-1时则添加操作成功
    }

通过以上三种添加方法我们发现：

• 添加时，使用putLock这个可重入锁保证线程安全
• 共同调用了enqueue()方法实现节点的添加
• 改变队列元素数量时，调用了AtomicInteger的getAndIncrement()方法，保证原子性

enqueue(e)

 /**
     * Links node at end of queue.
     *
     * @param node the node
     */
    private void enqueue(Node<E> node) {
        // assert putLock.isHeldByCurrentThread();
        // assert last.next == null;
        last = last.next = node; //将新的节点添加到队尾，并变成新的尾节点
    }

getAndIncrement()

此方法内部调用了compareAndSet()方法

public final int getAndIncrement() {
        for (;;) { // 采用循环的方式，将值加1
            int current = get();
            int next = current + 1;
            if (compareAndSet(current, next))
                return current; //加1成功后返回原值
        }
    }

compareAndSet( expect, update)
此方法内部调用了unsafe类的compareAndSwapInt()方法，该方法共有四个参数，第一个参数为需要修改的对象，第二个为偏移量（内存的旧值），第三个参数为期待的值，第四个为更新后的值；若果valueOffset的值和expect的值相等，则将valueOffset值修改为update返回true，否则不做操作，返回false

public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

LinkedBlockingQueue的取出方法

take()

 public E take() throws InterruptedException {
        E x;
        int c = -1;
        final AtomicInteger count = this.count;
        final ReentrantLock takeLock = this.takeLock;//使用takeLock保证线程安全
        takeLock.lockInterruptibly();
        try {
            while (count.get() == 0) {//当队列为空，取出线程阻塞
                notEmpty.await();
            }
            x = dequeue(); //掉用dequeue方法从队头取出元素
            c = count.getAndDecrement(); //调用AtomicInteger的getAndDecrement()将count值减1
            if (c > 1)//判断如果当前队列之前元素的数量大于1，唤醒取出线程
                notEmpty.signal();
        } finally {
            takeLock.unlock();
        }
        if (c == capacity)//之前队列元素数量为容量值，取出一个，只能唤醒一个添加线程
            signalNotFull();
        return x;
    }

poll(timeout,unit)

该方法取出元素时，如果队列为空，则阻塞给定的时间

  public E poll(long timeout, TimeUnit unit) throws InterruptedException {
        E x = null;
        int c = -1;
        long nanos = unit.toNanos(timeout);
        final AtomicInteger count = this.count;
        final ReentrantLock takeLock = this.takeLock;//使用takeLock保证线程安全
        takeLock.lockInterruptibly();
        try {
            while (count.get() == 0) {//当队列为空则阻塞给定时间
                if (nanos <= 0)//时间消耗完全后，如果操作未成功则返回null
                    return null;
                nanos = notEmpty.awaitNanos(nanos);
            }
            x = dequeue();//调用dequeue方法返回节点值
            c = count.getAndDecrement();//将count值减1
            if (c > 1)
                notEmpty.signal();
        } finally {
            takeLock.unlock();
        }
        if (c == capacity)
            signalNotFull();
        return x;
    }

poll()

该方法取出元素时，如果队列为空，则直接返回null

 public E poll() {
        final AtomicInteger count = this.count;
        if (count.get() == 0)// 如果队列为空，直接返回null
            return null;
        E x = null;
        int c = -1;
        final ReentrantLock takeLock = this.takeLock;//使用takeLock保证线程安全
        takeLock.lock();
        try {
            if (count.get() > 0) {
                x = dequeue();//调用dequeue方法取出队头节点元素的值
                c = count.getAndDecrement();//count减1
                if (c > 1)//如果取出元素不是唯一的，唤醒取出线程
                    notEmpty.signal();
            }
        } finally {
            takeLock.unlock();
        }
        if (c == capacity)//如果从已满队列取出的，则唤醒一个添加线程
            signalNotFull();
        return x;
    }

通过以上三种取出方法，发现：

• 所有的取出方法都是使用takeLock这个可重入锁保证线程安全
• 都调用了dequeue()方法从队头取出元素
• 调用了AtomicInteger的getAndDecrement()方法将count值减1，保证原子性

dequeue()

/**
     * Removes a node from head of queue.
     *
     * @return the node
     */
    private E dequeue() {
        // assert takeLock.isHeldByCurrentThread();
        // assert head.item == null;
        Node<E> h = head; //队列的头结点是值为null的节点
        Node<E> first = h.next; //返回头节点之后的第一个节点
        h.next = h; // help GC
        //因为创建节点时创建了一个新的对象，所以需要GC，即需要将头节点的后继节点指向自身，帮助GC
        head = first;//将新的头节点置为将要删除的第一个节点
        E x = first.item; //将节点的值赋给x
        first.item = null;//将节点值置为null，变为新的头节点
        return x;//返回取出的值
    }

getAndDecrement()

此方法与getAndIncrement()方法相似，底层都是调用了unsafe的compareAndSwapInt方法保证操作的原子性

peek()

该方法只返回队头元素的值，并不能将节点从队列中删除

public E peek() {
        if (count.get() == 0)
            return null;
        final ReentrantLock takeLock = this.takeLock;
        takeLock.lock();
        try {
            Node<E> first = head.next;
            if (first == null)//如果队列为空，则直接返回null
                return null;
            else
                return first.item;
        } finally {
            takeLock.unlock();
        }
    }

remove(o)

从队列中删除指定元素值的节点

public boolean remove(Object o) {
        if (o == null) return false;
        fullyLock(); //此时将入队锁和出队锁全部锁住来保证线程安全
        try {
            for (Node<E> trail = head, p = trail.next;
                 p != null;
                 trail = p, p = p.next) {// 循环遍历查找值相等的元素
                if (o.equals(p.item)) {
                    unlink(p, trail);//调用unlink删除此节点
                    return true;//操作成功返回true
                }
            }
            return false;
        } finally {
            fullyUnlock();
        }
    }

fullyLock()

void fullyLock() {
        putLock.lock();
        takeLock.lock();
    }

unlink(p, trail)

 void unlink(Node<E> p, Node<E> trail) {//p为要删除节点，trail为删除节点的前一个节点
        // assert isFullyLocked();
        // p.next is not changed, to allow iterators that are
        // traversing p to maintain their weak-consistency guarantee.
        p.item = null;
        trail.next = p.next; // 改变指针将前一节点的后继节点指向删除节点的后一个节点
        if (last == p)
            last = trail;
        if (count.getAndDecrement() == capacity)
            notFull.signal();
    }

获取队列当前大小及剩余容量

size()

 public int size() {
        return count.get();
    }

remainingCapacity()

public int remainingCapacity() {
        return capacity - count.get();
    }

这两个方法都没有使用锁来保证线程安全，是因为count自身为AtomicInteger对象，保证了操作的原子性