Java同步数据结构之LinkedBlockingDeque

前言

前面介绍完了队列Queue/BlockingQueue的实现类，接下来介绍双端队列Deque/BlockingDeque的实现类之一LinkedBlockingDeque，它是一种基于链表的可选容量的同时支持FIFO、LIFO的阻塞双端队列。

比起前面介绍的队列实现中的节点都有一个指向下一个节点的next字段引用，双端队列为了能够实现能够从尾部添加元素，在队列节点类中不但有指向下一个节点的next字段，而且还有一个指向前一个前驱节点的字段prev。就是因为双端队列的节点同时持有指向下一个节点（后继）的next字段和指向前一个节点（前驱）的prev字段，所以才能实现双端队列特有的可以从对头、对尾两端插入和移除元素的双向特性。

LinkedBlockingDeque在实现的时候采用了单个非公平的可重入锁ReentrantLock保证队列的线程安全，通过两个Condition（notEmpty，notFull）实现阻塞唤醒机制，所以它的逻辑其实非常简单。LinkedBlockingDeque不但使用单个可重入锁来保证线程安全，而且几乎100%的方法都加了该锁（包括迭代器，toString、size()方法），所以它的性能可想而知有多么差，尤其是在竞争激烈的时候，它在双端队列中的地位就如同ArrayBlockingQueue在队列Queue的家族中的地位，所以在多线程环境下LinkedBlockingDeque基本上没有使用的价值，最好使用双端队列的另一个实现ConcurrentLinkedDeque。

LinkedBlockingDeque在对首尾节点进行出队的时候，采用了将数据item置空以及将相应后继或前驱指向自身的方式辅助垃圾回收，而内部节点进行移除的时候，仅仅将数据item置空，没有改变节点内部的前驱和后继节点的引用，这保证了迭代器的弱一致性，避免迭代器异常终止。LinkedBlockingDeque内部有两个字段first、last分别指向对头第一个节点和队尾最后一个节点，它们有如下的不变性：①队列为空时，  first，last都为null；②队列不为空时，first，last的数据项item都不为null（所以它不存在虚拟节点）；③队列不为空时，头节点first没有前驱节点，尾节点last没有后继节点。

LinkedBlockingDeque的大多数操作在恒定时间内运行完成(不计阻塞消耗的时间)。而remove、removeFirstOccurrence、removeLastOccurrence、contains、iterator.remove()和bulk操作，所有这些操作都在线性时间内运行完成。

源码解读

首先看它的一些基础字段、节点内部类以及构造方法：

 /** Doubly-linked list node class 双链表节点类 */
 static final class Node<E> {
     /**
      * 数据项，如果该节点已被删除，则为空。
      */
     E item;
 
     /**
      * 前驱为下面其中之一
      * - 正常的前驱节点
      * - 当前节点自身（自链接），意味着它的前驱是last（例如当前节点作为last从队尾出队之后）
      * - 空，意味着没有前驱节点（例如first）
      */
     Node<E> prev;
 
     /**
      * 后继为下面其中之一：
      * - 正常的后继节点
      * - 当前节点自身（自链接），意味着它的后继节点是first（例如当前节点作为first从队头出队之后）
      * - 空，意味着没有后继节点（例如last）
      */
     Node<E> next;
 
     Node(E x) {
         item = x;
     }
 }
 
 //不变性：
 //队列为空时，  first，last都为null
 //队列不为空时，first，last的数据项都不为null
 //队列不为空时，头节点first没有前驱节点，尾节点last没有后继节点
 /**
  * Pointer to first node. 头节点
  * Invariant: (first == null && last == null) || 头尾节点都为空
  *            (first.prev == null && first.item != null) 头节点的数据项不为空但没有前驱
  */
 transient Node<E> first;
 
 /**
  * Pointer to last node. 尾节点
  * Invariant: (first == null && last == null) ||头尾节点都为空
  *            (last.next == null && last.item != null)  尾节点的数据项不为空但没有后继
  */
 transient Node<E> last;
 
 /** Number of items in the deque 双端队列中数据项的数量*/
 private transient int count; 
 
 /** Maximum number of items in the deque 双端队列最大容量*/
 private final int capacity;
 
 /** Main lock guarding all access 保护所有访问的锁*/
 final ReentrantLock lock = new ReentrantLock();
 
 /** Condition for waiting takes 消费阻塞条件*/
 private final Condition notEmpty = lock.newCondition();
 
 /** Condition for waiting puts 生产阻塞条件*/
 private final Condition notFull = lock.newCondition();
 
 //默认容量为Integer.MAX_VALUE
 public LinkedBlockingDeque() {
     this(Integer.MAX_VALUE);
 }
 //指定容量
 public LinkedBlockingDeque(int capacity) {
     if (capacity <= 0) throw new IllegalArgumentException();
     this.capacity = capacity;
 }
 //创建一个容量为Integer.MAX_VALUE，并且初始状态包含给定集合中的元素的实例
 public LinkedBlockingDeque(Collection<? extends E> c) {
     this(Integer.MAX_VALUE);
     final ReentrantLock lock = this.lock;
     lock.lock(); // 没有竞争，但是为了可见性而加锁
     try {
         for (E e : c) {
             if (e == null)
                 throw new NullPointerException();
             if (!linkLast(new Node<E>(e))) //将节点链接到队尾，如果已满则返回false。
                 throw new IllegalStateException("Deque full");
         }
     } finally {
         lock.unlock();
     }
 }

可见节点内部类有前驱prev和后继next字段，LinkedBlockingDeque内部维护两个字段first、last分别指向对头和队尾，队列在为空的时候，first和last都为空。LinkedBlockingDeque在不指定容量时大小为Integer.MAX_VALUE。内部使用一把非公平可重入锁保证线程安全。

通过LinkedBlockingDeque的构造方法指定容量可以防止内存的过度扩展，如果没有指定容量大小，默认容量为Integer.MAX_VALUE。每次插入元素时都会动态创建链接节点，除非这会使deque超出容量限制。

入队实现

头部入队

 /**
  * 将节点链接为第一个元素，如果已满则返回false。
  */
 private boolean linkFirst(Node<E> node) {
     // assert lock.isHeldByCurrentThread();
     if (count >= capacity) //已满，返回false
         return false;
     Node<E> f = first;
     node.next = f; //旧first置为当前节点的后继节点
     first = node; //当前节点成为新的first
     if (last == null) //如果队尾为空，使其指向当前节点
         last = node;
     else
         f.prev = node; //将当前节点置为旧first的前驱
     ++count;
     notEmpty.signal();
     return true;
 }

linkFirst是从对头入队新节点的具体逻辑实现（被其它入队方法调用），看起来很简单：队列为空表示是第一个入队节点，则first、last都指向该节点；否则在原来的first节点前面插入该新节点，该新节点成为新的first，成为原first的前驱，原first成为该节点的后继。

尾部入队

 /**
  * 链接节点作为最后一个元素，如果已满则返回false。
  */
 private boolean linkLast(Node<E> node) {
     // assert lock.isHeldByCurrentThread();
     if (count >= capacity)
         return false; //已满，返回false
     Node<E> l = last;
     node.prev = l;//旧last置为当前节点的前驱节点
     last = node; //当前节点成为新的last
     if (first == null)
         first = node; //如果队尾为空，使其指向当前节点
     else
         l.next = node;//将当前节点置为旧last的后继
     ++count;
     notEmpty.signal();
     return true;
 }

linkLast是从队尾入队新节点的具体逻辑实现（被其它入队方法调用），看起来很简单：队列为空表示是第一个入队节点，则first、last都指向该节点；否则在原来的last节点后面插入该新节点，该新节点成为新的last，成为原last的后继，原last成为该节点的前驱。

头部出队

 /**
  * 删除并返回第一个元素，如果为空则返回null。
  */
 private E unlinkFirst() {
     // assert lock.isHeldByCurrentThread();
     Node<E> f = first;
     if (f == null)
         return null; //队列为空，返回null
     Node<E> n = f.next;
     E item = f.item;
     f.item = null; //将第一个节点数据置空
     f.next = f; // 将第一个节点自链接，辅助垃圾回收
     first = n;  //将第一个节点的后继置为first
     if (n == null)
         last = null; //队列为空了，把first，last都置为null
     else
         n.prev = null;//否则把新的first的前驱置为null
     --count;
     notFull.signal();
     return item;
 }

unlinkFirst是从对头移除元素的具体逻辑（被其它出队方法调用），看起来很简单：队列为空时返回null；否则将first节点出队，返回first节点的数据项之前将其数据item置为null，后继指向自身，first的后继节点成为新的first，新first 的前驱保持为null，如果移除之后队列为空了，则将first、last都置为null，还原到最初状态。

尾部出队

 /**
  * 删除并返回最后一个元素，如果为空则返回null。
  */
 private E unlinkLast() {
     // assert lock.isHeldByCurrentThread();
     Node<E> l = last;
     if (l == null)
         return null; //队列为空，返回null
     Node<E> p = l.prev;
     E item = l.item;
     l.item = null; //将最后一个节点数据置空
     l.prev = l; // 将最后一个节点自链接，辅助垃圾回收
     last = p; //将最后一个节点的前驱置为新的last
     if (p == null)
         first = null; //队列为空了，把first，last都置为null
     else
         p.next = null;//否则把新的last的后继置为null
     --count;
     notFull.signal();
     return item;
 }

unlinkLast是从对尾移除元素的具体逻辑（被其它出队方法调用），看起来很简单：队列为空时返回null；否则将last节点出队，返回last节点的数据项之前将其数据item置为null，前驱指向自身，last的前驱节点成为新的last，新last的后继保持为null，如果移除之后队列为空了，则将first、last都置为null，还原到最初状态。

内部节点移除

 /**
  * Unlinks x. 断开节点x
  */
 void unlink(Node<E> x) {
     // assert lock.isHeldByCurrentThread();
     Node<E> p = x.prev;
     Node<E> n = x.next;
     if (p == null) { //当前节点没有前驱，则说明是first，直接使用unlinkFirst出队
         unlinkFirst();
     } else if (n == null) {//当前节点没有后继，说明是last，直接使用unlinkLast出队
         unlinkLast();
     } else {
         //是非端点的内部节点，直接改变前驱和后继节点的相关链接
         p.next = n;
         n.prev = p;
         x.item = null; //将当前节点数据item置空
         //注意：这里并没有将节点本身的前驱后继指针改变，是为了防止迭代器异常
         // Don't mess with x's links.  They may still be in use by
         // an iterator.
         --count;
         notFull.signal();
     }
 }

unlink是内部节点移除的逻辑（被其它加锁方法调用），逻辑依然很简单，只是要注意的是，对内部节点的移除，只是将其数据item置空，然后让它的前驱和后继节点链接起来，而没有直接改变被移除节点对其它节点的链接，是为了保证迭代器的正常工作。

以上这些方法基本算组成了LinkedBlockingDeque其它方法的真正实现，那些真正使用时调用的public方法都是基于这些方法实现的，包括阻塞/超时方法也仅仅是在这些方法的基础上加入锁的等待唤醒机制。例如如下这些方法都是基于这些方法实现的：

 public boolean offerFirst(E e) {
     if (e == null) throw new NullPointerException();
     Node<E> node = new Node<E>(e);
     final ReentrantLock lock = this.lock;
     lock.lock();
     try {
         return linkFirst(node);
     } finally {
         lock.unlock();
     }
 }
 
 /**
  * @throws NullPointerException {@inheritDoc}
  */
 public boolean offerLast(E e) {
     if (e == null) throw new NullPointerException();
     Node<E> node = new Node<E>(e);
     final ReentrantLock lock = this.lock;
     lock.lock();
     try {
         return linkLast(node);
     } finally {
         lock.unlock();
     }
 }
 public void putFirst(E e) throws InterruptedException {
     if (e == null) throw new NullPointerException();
     Node<E> node = new Node<E>(e);
     final ReentrantLock lock = this.lock;
     lock.lock();
     try {
         while (!linkFirst(node))
             notFull.await();
     } finally {
         lock.unlock();
     }
 }
 public void putLast(E e) throws InterruptedException {
     if (e == null) throw new NullPointerException();
     Node<E> node = new Node<E>(e);
     final ReentrantLock lock = this.lock;
     lock.lock();
     try {
         while (!linkLast(node))
             notFull.await();
     } finally {
         lock.unlock();
     }
 }
 public boolean offerFirst(E e, long timeout, TimeUnit unit)
     throws InterruptedException {
     if (e == null) throw new NullPointerException();
     Node<E> node = new Node<E>(e);
     long nanos = unit.toNanos(timeout);
     final ReentrantLock lock = this.lock;
     lock.lockInterruptibly();
     try {
         while (!linkFirst(node)) {
             if (nanos <= 0)
                 return false;
             nanos = notFull.awaitNanos(nanos);
         }
         return true;
     } finally {
         lock.unlock();
     }
 }    

包括removeFirstOccurrence、removeLastOccurrence

 //从first开始遍历，拿走item相等的，并断开节点
 public boolean removeFirstOccurrence(Object o) {
     if (o == null) return false;
     final ReentrantLock lock = this.lock;
     lock.lock();
     try {
         for (Node<E> p = first; p != null; p = p.next) {
             if (o.equals(p.item)) {
                 unlink(p);
                 return true;
             }
         }
         return false;
     } finally {
         lock.unlock();
     }
 }
 //从last开始向前遍历，拿走item相等的，并断开节点
 public boolean removeLastOccurrence(Object o) {
     if (o == null) return false;
     final ReentrantLock lock = this.lock;
     lock.lock();
     try {
         for (Node<E> p = last; p != null; p = p.prev) {
             if (o.equals(p.item)) {
                 unlink(p);
                 return true;
             }
         }
         return false;
     } finally {
         lock.unlock();
     }
 }

这些方法汇总如下：①操作队头的方法

操作队头的方法
	失败抛异常	失败返回特殊值	条件不满足阻塞	条件不满足等待给定时长
入队	push/addFirst(e)	offerFirst(e)	putFirst(e)	offerFirst(e, time, unit)
出队（移除）	pop/remove/removeFirst()	poll/pollFirst()	take/takeFirst()	poll/pollFirst(time, unit)
获取但不移除	element/getFirst()	peek/peekFirst()	不支持	不支持

②操作队尾的方法：

操作队尾的方法
	失败抛异常	失败返回特殊值	条件不满足阻塞	条件不满足等待给定时长
入队	add/addLast(e)	offer/offerLast(e)	put/putLast(e)	offer/offerLast(e, time, unit)
出队（移除）	removeLast()	pollLast()	takeLast()	pollLast(time, unit)
获取但不移除	getLast()	peekLast()	不支持	不支持

其它一些方法，drainTo从对头开始一个一个的将全部或指定数量的节点的item数据添加到另一个集合中，并移除相应的节点，toArray从队头开始获取但不移除全部或指定数量节点的数据至数组中，contains(Object o)从队头开始依次比较节点的数据item，找到一个相等的立即返回true，遍历完都没找到返回false，这些方法并没有做item是否为空的判断，这是因为所以方法都是需要先获取同一个锁，所以在这些方法执行的时候不存在那样的节点。

clear()方法从对头first开始一个一个的将每一个节点的数据，前驱，后驱清空，执行完之后队列为空。LinkedBlockingDeque的方法都很简单就不一一介绍了。

迭代器

LinkedBlockingDeque支持正向和逆向的两种迭代器，分别是方法iterator、descendingIterator：

 //按正确的顺序返回deque中元素的迭代器。元素将按从第一个(head)到最后一个(tail)的顺序返回。
 //返回的迭代器是弱一致的。
 public Iterator<E> iterator() {
     return new Itr();
 }
 
 //以相反的顺序返回deque中元素的迭代器。元素将按从最后(tail)到第一个(head)的顺序返回。
 //返回的迭代器是弱一致的。
 public Iterator<E> descendingIterator() {
     return new DescendingItr();
 }

它们的逻辑主要是由一个内部抽象类AbstractItr来实现，而iterator和descendingIterator仅仅实现了AbstractItr的抽象方法，用来指示迭代器的开始位置和迭代方法，为了保证迭代器的弱一致性，迭代器在创建实例的时候就已经拿到了第一个节点next和其节点数据，为了实现迭代器的remove方法，迭代器还保留了迭代的上一个节点lastRet，用于获取迭代器的下一个节点的主要逻辑由succ方法实现：

 /**
  * 返回给定非空节点的后续节点，但可能已被删除。
  */
 private Node<E> succ(Node<E> n) {
     for (;;) {
         Node<E> s = nextNode(n);
         if (s == null) //队列没有更多元素了，空或者到头了
             return null;
         else if (s.item != null)//节点有效
             return s;
         else if (s == n) //自链接表示是正常的从队列头或者尾出队，所以直接拿最近的头或者尾即可
             return firstNode();
         else
             n = s; //否则表示s是被移除的内部节点，继续看下一个
     }
 }

可见迭代器会排除那些被移除的无效节点，迭代器的其它方法很简单就不一一列举了。

可拆分迭代器Spliterator

LinkedBlockingDeque的可拆分迭代器由内部类LBDSpliterator实现，它不像普通迭代器那样可以支持正向和反向迭代，可拆分迭代器仅支持正向的拆分迭代：

 public Spliterator<E> spliterator() {
     return new LBDSpliterator<E>(this);
 }

LinkedBlockingDeque的可拆分迭代器虽然也需要获取同一把锁，但是不同于其它所有方法，可拆分迭代器会队节点的数据item进行null值判断，只对item不为空的数据做处理，该可拆分迭代器的实现和LinkedTransferQueue的实现几乎一致，tryAdvance从对头开始查找获取队列中第一个item不为空的数据节点的数据做指定的操作，forEachRemaining从队头开始循环遍历当前队列中item不为空的数据节点的数据做指定的操作源码都很简单，就不贴代码了，至于它的拆分方法trySplit，其实和ConcurrentLinkedQueue拆分方式是一样的，代码都几乎一致，它不是像ArrayBlockingQueue那样每次分一半，而是第一次只拆一个元素，第二次拆2个，第三次拆三个，依次内推，拆分的次数越多，拆分出的新迭代器分的得元素越多，直到一个很大的数MAX_BATCH（33554432） ，后面的迭代器每次都分到这么多的元素，拆分的实现逻辑很简单，每一次拆分结束都记录下拆分到哪个元素，下一次拆分从上次结束的位置继续往下拆分，直到没有元素可拆分了返回null。

总结

LinkedBlockingDeque是以单个锁实现的基于链表的可选容量的双端队列，可以从对头、对尾两端插入和移除元素，这主要是通过节点同时持有前驱节点和后继节点的引用来达到同时支持正向反向的操作，它的迭代器支持正向和反向两种迭代方式。但是由于它的所有方法（几乎100%）都需要获取同一把独占锁，因此在竞争激烈的多线程并发环境下吞吐量非常底下。