多线程学习-基础（十三）(学习参考·网摘) ArrayBlockingQueue源代碼解析（base jdk 1.8）

前记：

　　　　这个得首先声明一下，以下大部分内容均参考于：https://blog.csdn.net/wx_vampire/article/details/79585794，本随笔只作为学习作用，侵权删！

　　说一下我看的学习心得吧！对于BlockingQueue这个接口以及常用的实现类的用法，真的是不看不知道，一看吓一跳！有点超出了我的现有水平的理解范畴了！主要是里面的一些对Java基础中一些不常用的方法，修饰符的使用，这个对我来说真的算是涨姿势了。

还有就是，一些链表在处理数据的算法，这些也让我有点头大，学习的过程中处于“半懂”状态，这让我很受打击，不过好处就是让我知道接下来要往哪方面学习了。

　　好了，开始正文吧，以下算是一个网上转摘学习资料备份了。

正文：

ArrayBlockingQueue 是数组结构的堵塞队列的一种实现，那么肯定要实现的BlockingQueue接口。

解释一下接口含义

• boolean add(E e); 队列添加元素，返回成功标识，队列满了抛出队列满的异常，无堵塞。
• boolean offer(E e);队列添加元素，返回成功标识，无堵塞。
• void put(E e);队列添加元素，无返回值，队列满了会堵塞。
• boolean offer(E e, long timeout, TimeUnit unit);队列添加元素，队列满了堵塞，设置有超时时间。
• E poll();队列拉取元素，无堵塞，没有值返回null。
• E take();队列拉取元素，队列空了会堵塞，等待能拉取到值为止
• E poll(long timeout, TimeUnit unit);队列拉取元素，队列空了等待，设置有等待超时时间
• E peek() ; 只读队首元素的值，没有返回空
• int remainingCapacity(); 计算剩余容量
• boolean remove(Object o); 移除元素
• int drainTo(Collection<? super E> c, int maxElements);  移除元素放到入参的集合当中
• public Iterator<E> iterator() jdk 1.8以后ArrayBlockingQueue还增加了迭代器功能，这个模块下面会重点介绍，很有意思。

堵塞队列提供的功能：

1. 在多线程环境下提供一个类似于生产者和消费者这样的一个模型
2. 提供一个FIFO的顺序读取和插入

那就引起我的思考：

1. 怎么实现的堵塞机制和堵塞的超时机制？
2. 作为一个集合类，数组结构的怎么在多线程环境下实现安全扩容？
3. 1.8jdk版本为什么会增加迭代器功能？

下面的代码说明：部分是我自己按照自己的立即翻译，当然多数是参考原作者的注释。

 package java.util.concurrent;    //所在包
 import java.util.concurrent.locks.Condition;
 import java.util.concurrent.locks.ReentrantLock;//重入锁
 import java.util.AbstractQueue;//抽象队列
 import java.util.Collection;//集合
 import java.util.Iterator;//迭代器
 import java.util.NoSuchElementException;//异常
 import java.lang.ref.WeakReference;//弱引用
 import java.util.Spliterators;//分割迭代
 import java.util.Spliterator;//分割迭代
 class
 public class ArrayBlockingQueue<E>
         extends AbstractQueue<E>    //继承了抽象队列
         implements BlockingQueue<E>, //实现了BlockingQueue接口
                    java.io.Serializable//实现了Serializable接口，说明此类可以被序列化
 {
     //序列化ID
     private static final long serialVersionUID = -817911632652898426L;

     /** 阻塞队列中存放的对象 */
     default final Object[] items;

     /** 消费者获取对象的下一个对象下标，具体的操作有poll take peek remove */
     default int takeIndex

     /** 生产者放入对象的下一个对象的下标，具体的操作有 put offer add */
     default int putIndex;

     /** 队列中元素的数量 */
     default int count;

      /** 这个锁就是实现生产者，消费者模型的锁模型，并且所有和并发相关的堵塞控制都是通过这个锁来实现的*/
     default final ReentrantLock lock;

     /** 这个是有ReentrantLock 中的Condition一个标识队列中有元素非空标志，用于通知消费者队列中有数据了，快来取数据 */
     private final Condition notEmpty;

    /** 这个也是ReentrantLock 中的Condition的一个标识，标识队列中的元素不满用于通知生产者队列中空地，快来塞数据*/
     private final Condition notFull;

     /**
      * 这是一个迭代器集合，是之前没有的特性，
      * 细节：transient 标示变量是序列化忽略这个变量。
      */
     default transient Itrs itrs = null;
 /***********************【阻塞队列常用的方法】*************************************************************************************/
     /**
      *
      *堵塞提交，超时返回false
      */
     public boolean offer(E e, long timeout, TimeUnit unit)
             throws InterruptedException {
         checkNotNull(e);
         long nanos = unit.toNanos(timeout);
         final ReentrantLock lock = this.lock;
     //获取锁
         lock.lockInterruptibly();
         try {
             while (count == items.length) {
                 if (nanos <= 0)
                     return false;
     //这里是使用同步队列器的超时机制，在nanos的时间范围内，方法会在这里堵塞，超过这个时间段nanos的值会被赋值为负数，方法继续，然后在下一个循环返回false。这个标志是未满标志，队列里面未满就可以放进元素嘛。然后判断成功就是一个入队列操作
                 nanos = notFull.awaitNanos(nanos);
             }
             enqueue(e);
             return true;
         } finally {
             lock.unlock();
         }
     }
     /**
      * 入队列操作，因为putIndex已经是当前该放入元素的下标了，放入元素之后，
      * 需要将putIndex+1，并且元素数量加1。然后直接调用非空标志通知等待中的消费者
      * 质疑：如果我没有等待中的消费者，那也要通知，那不是浪费么？
      * 解释：下端代码是signal的实现
     public final void signal() {
                 if (!isHeldExclusively())
                     throw new IllegalMonitorStateException();
                     Node first = firstWaiter;
                         if (first != null)
                             doSignal(first)
      }
      signal方法已经在里面已经对队列的首元素判断空，不通知了，
      这个引起我的一个思考，确实在函数里面就应该对这些条件做判断要比外面判断更好一些，一个是更健壮，一个是更友好，但是这个最小作用模块还是功能模块，别一个调用链做了多次的这种条件的判断，这就让阅读者难受了。
      */
     private void enqueue(E x) {
         final Object[] items = this.items;
         items[putIndex] = x;
         if (++putIndex == items.length)
             putIndex = 0;
         count++;
         notEmpty.signal();
     }
     /***
      * poll的操作和offer基本一样，就是做的是出队列的操作。还有就是一个drainTo方法也很类似，有一个细节有意思就是drainTo是
     *一个批量操作，但是通知却是一个一个通知的。没有调用singalAll()。因为堵塞队列强调一个顺序。一进一出原则。还有就是在外面判断了有无等待者。因为这**样却是省不必要的循环了。
     */
     public E poll(long timeout, TimeUnit unit) throws InterruptedException {
         long nanos = unit.toNanos(timeout);
         final ReentrantLock lock = this.lock;
         lock.lockInterruptibly();
         try {
             while (count == 0) {
                 if (nanos <= 0)
                     return null;
                 nanos = notEmpty.awaitNanos(nanos);
             }
             return dequeue();
         } finally {
             lock.unlock();
         }
     }  

     /**
      * 出队列操作，跟入队列操作正好是相反的，多了一个清理操作
      *
      */
     private E dequeue() {
       final Object[] items = this.items;
         @SuppressWarnings("unchecked")
         E x = (E) items[takeIndex];
         items[takeIndex] = null;
         if (++takeIndex == items.length)
             takeIndex = 0;
         count--;
         if (itrs != null)
             //@key jdk1.8的新特性迭代器特性，这里是因为元素的出队列所以清理和这个元素相关联的迭代器
         itrs.elementDequeued();
         //对于生产者的通知
         notFull.signal();
         return x;
     }
     /**
      * 根据下标移除元素，那么会分成两种情况一个是移除的是队首元素，一个是移除的是非队首元素,移除队首元素，就相当于出队*列操作，移除非队首元素那么中间就有空位了，后面元素需要依次补上，然后如果是队尾元素，那么putIndex也就是插入操作的*下标也就需要跟着移动。这里面同样有无用迭代器的清理和notFull标志的通知。elementDequeued 和removedAt 这两个函数差*不多主要做的就是清理。但是不一样的是第一种情况当成出队列来处理了。而第二种就相当于这个元素就没有进过队列来处理，*轻轻地来，轻轻地走不带走一片云彩
      */
     void removeAt(final int removeIndex) {
        final Object[] items = this.items;
         //当移除的元素正好是队列首元素，就是take元素，正常的类似出队列的操作，
         if (removeIndex == takeIndex) {
             // removing front item; just advance
             items[takeIndex] = null;
             if (++takeIndex == items.length)
                 takeIndex = 0;
             count--;
             if (itrs != null)
                 itrs.elementDequeued();
             //
         } else {
             //因为是队列中间的值被移除了，所有后面的元素都要挨个迁移
             final int putIndex = this.putIndex;
             for (int i = removeIndex;;) {
                 int next = i + 1;
                 if (next == items.length)
                     next = 0;
                 if (next != putIndex) {
                     items[i] = items[next];
                     i = next;
                 } else {
                     items[i] = null;
                     this.putIndex = I;
                     break;
                 }
             }
             count—;
             if (itrs != null)
             itrs.removedAt(removeIndex);
         }
         notFull.signal();
     }
         /**
          * 当元素出队列的时候调用的方法这个出队列方法
          */
         void elementDequeued() {
             // 在队列为空的时候调用清空所有的迭代器;
             if (count == 0)
                 queueIsEmpty();
             // 当拿元素进行循环的时候，清理所有过期的迭代器
             else if (takeIndex == 0)
                 takeIndexWrapped();
         }
     }
     /**
      * 因为takeIndex等于0了，意味着开始下一个循环了.
      * 然后通知所有的迭代器，删除无用的迭代器。
      */
     void takeIndexWrapped() {
         //循环了一次cycle加1
         cycles++;
         for (Node o = null, p = head; p != null;) {
             final Itr it = p.get();
             final Node next = p.next;
             //需要清理的条件，和清理代码
             if (it == null || it.takeIndexWrapped()) {
                 p.clear();
                 p.next = null;
                 if (o == null)
                     head = next;
                 else
                     o.next = next;
             } else {
                 o = p;
             }
             p = next;
         }
         //没有迭代器了，就关掉迭代器的集合
         if (head == null)   // no more iterators to track
             itrs = null;
     }
     /**这个takeIndexWrapped 是内部类Itr 的方法跟上面不是一个类的方法
      *这里就是判断这个迭代器所持有的元素还在队列里面么,那么有两个条件，1.isDetached()
      * 2.就是看这个的循环次数，比建立这个迭代器的时候的循环次数，如果大于1，说明发生过两次以上的循环
      * 拿里面的元素都换了个遍，拿肯定是不对了，拿这个迭代器就被关闭了。
      * @return true if this iterator should be unlinked from itrs
      */
     boolean takeIndexWrapped() {
         // assert lock.getHoldCount() == 1;
         if (isDetached())
             return true;
         if (itrs.cycles - prevCycles > 1) {
             // All the elements that existed at the time of the last
             // operation are gone, so abandon further iteration.
             shutdown();
             return true;
         }
         return false;
     }
     //将所有的标志位都标记成remove ，null
     void shutdown() {
          cursor = NONE;
         if (nextIndex >= 0)
             nextIndex = REMOVED;
         if (lastRet >= 0) {
             lastRet = REMOVED;
             lastItem = null;
         }
         prevTakeIndex = DETACHED;
     }
     /***
      * 迭代器的基本方法之一，获取下一个元素，会发生缓存器失效的情况，如果是缓存器失效了，能重组就重组，即从takeIndex开始遍历，如果不行就标记失效，  *返回none
      * @return
      */
     public E next() {
         // assert lock.getHoldCount() == 0;
         final E x = nextItem;
         if (x == null)
             throw new NoSuchElementException();
         final ReentrantLock lock = ArrayBlockingQueue.this.lock;
         lock.lock();
         try {
             //当判定该迭代器失效了，会重组迭代器，以takeIndex为起点开始遍历，或者标记失效
             if (!isDetached())
                 incorporateDequeues();
             lastRet = nextIndex;
             final int cursor = this.cursor;
     //cursor这个值会在incorporateDequeues方法中修改，
             if (cursor >= 0) {
                 nextItem = itemAt(nextIndex = cursor);
                 this.cursor = incCursor(cursor);
             } else {
                 nextIndex = NONE;
                 nextItem = null;
             }
         } finally {
             lock.unlock();
         }
         return x;
     }  

     /**
      * 发现元素发生移动，通过判定cycle等信息，然后cursor取值游标就重新从takeIndex开始
      * 下面如果发现所有记录标志的值发生变化，就直接清理本迭代器了。
      * */
     private void incorporateDequeues() {
        final int cycles = itrs.cycles;
         final int takeIndex = ArrayBlockingQueue.this.takeIndex;
         final int prevCycles = this.prevCycles;
         final int prevTakeIndex = this.prevTakeIndex;
         if (cycles != prevCycles || takeIndex != prevTakeIndex) {
             final int len = items.length;
             // 从本迭代器建立开始，到目前堵塞队列出队列的个数，也就是takeIndex的偏移量
             long dequeues = (cycles - prevCycles) * len
                     + (takeIndex - prevTakeIndex);
             // 判断所记录的last，next cursor 还是不是原值如果不是，这个迭代器就判定detach
             if (invalidated(lastRet, prevTakeIndex, dequeues, len))
                 lastRet = REMOVED;
             if (invalidated(nextIndex, prevTakeIndex, dequeues, len))
                 nextIndex = REMOVED;
             if (invalidated(cursor, prevTakeIndex, dequeues, len))
                 cursor = takeIndex;
             if (cursor < 0 && nextIndex < 0 && lastRet < 0)
                 detach();
             else {
                 //重新记录cycle值
                 this.prevCycles = cycles;
                 this.prevTakeIndex = takeIndex;
             }
         }
     }
 /***********************【迭代器类的链表集合管理类】*************************************************************************************/
      /**
      * 下面是一个内部类：迭代集合链表类（用于处理迭代器）
      *  作用：管理当前阻塞队列的迭代器
       */
     class Itrs {

         /**
          * 内部类中的内部类，自定义了一个节点
          * 将里面的元素设置成弱引用，目标就是当成缓存使用的
          * WeakReference：帮助JVM合理的释放对象，造成不必要的内存泄漏！！
          */
         private class Node extends WeakReference<Itr> {
             //下一个节点
             Node next;
             //节点构造器
             Node(Itr iterator, Node next) {
                 super(iterator);
                 this.next = next;
             }
         }

         /** 记录循环的次数，当take下标到0的时候为一个循环 cycle+1 */
         int cycles = 0;

         /** 定义一个头节点 **/
         private Node head;

         /** 用于删除无用的迭代器 */
         private Node sweeper = null;
         /**
          * 这个标识删除探针
          */
         private static final int SHORT_SWEEP_PROBES = 4;
         private static final int LONG_SWEEP_PROBES = 16;
         //迭代器链表集合的构造器
         Itrs(Itr initial) {
             register(initial);
         }
         /**
          * 注册逻辑的实现，在链表的最前面加元素
          */
         void register(Itr itr) {
             head = new Node(itr, head);//创建一个头节点
         }
         void doSomeSweeping(boolean tryHarder) {}    //删除旧的，过期的,无用的迭代器
         void takeIndexWrapped() {}                    //
         void removedAt(int removedIndex) {}            //
         void queueIsEmpty() {}                        //
         void elementDequeued() { }                    //
     }
 /***********************【迭代器类】*************************************************************************************/
     /**
      *创建一个内部类：当前阻塞队列的迭代器
      */
      private class Itr implements Iterator<E> {
         /** 光标，是迭代器下一次迭代时的坐标，迭代器没有需要遍历的对象了，这个值会为负值*/
         private int cursor;

         /** 下一个元素内容，调用Iterator.next方法拿到的值 */
         private E nextItem;

         /** 下一个元素的下标，none 是-1 被移除了是-2对应下面的static int */
         private int nextIndex;

         /** 上一个元素的内容 */
         private E lastItem;

         /** 上一个元素的的下标，none 是-1 被移除的是-2 同样对应下面的static int */
         private int lastRet;

          /** 记录之前的开始遍历的下标，当这个迭代器判定为失效了这个值就是DETACHED */
         private int prevTakeIndex;

          /* 记录之前循环次数的值，和Cycles进行比对，就知道有没有再循环过 */
         private int prevCycles;

         /** 当阻塞队列中无数据时的状态值 */
         private static final int NONE = -1;

         /**元素被调用remove方法移走，的状态值*/
         private static final int REMOVED = -2;

         /**元素被调用detached方法后的状态值*/
         private static final int DETACHED = -3;
         /**迭代器的初始化函数从takeIndex位置开始遍历*/
         Itr() {
             lastRet = NONE;
             /**拿到当前阻塞队列的锁*/
             final ReentrantLock lock = ArrayBlockingQueue.this.lock;
             /**开始锁住*/
             lock.lock();
             try {
                 if (count == 0) {//当前阻塞队列中无数据
                     cursor = NONE;//下一次迭代的索引值：-1
                     nextIndex = NONE;//下一位元素的索引值：-1
                     prevTakeIndex = DETACHED;//上一次遍历使用的索引值：-3  失效
                 } else {//阻塞队列中有数据
                     /** 初始化Itr迭代器的属性值 */
                     final int takeIndex = ArrayBlockingQueue.this.takeIndex;//拿到当前阻塞队列下一个取到数据的索引值
                     prevTakeIndex = takeIndex;//下一位索引值=前一位取值索引值
                     nextItem = itemAt(nextIndex = takeIndex);
                     cursor = incCursor(takeIndex);//队列首元素后一个
                     if (itrs == null) {
                         itrs = new Itrs(this);
                     } else {
                         //注册到itrs，所有迭代器的集合，顺序注册的
                         itrs.register(this);
                         // 清理无用的迭代器
                         itrs.doSomeSweeping(false);
                     }
                     prevCycles = itrs.cycles;
                 }
             } finally {
                 //解锁
                 lock.unlock();
             }
         }
         /**当前迭代器是否失效： 负值意味着失效迭代器 */
         boolean isDetached() {
             return prevTakeIndex < 0;
         }
         /**初始化下一个要拿到的元素的索引值 */
         private int incCursor(int index) {
             if (++index == items.length){//如果下一个元素的索引值刚好等于阻塞队列元素个数（说明已经到了队列的尾部），迭代重头开始
                 index = 0;//返回第一个元素的索引值
             }
             if (index == putIndex){//下一个元素的索引值=putIndex：生产者放入对象的下一个对象的索引值
                  index = NONE;//NONE=-1 表示队列中无数据
             }
             return index;
         }

         /**如果给定数量的索引无效，则返回true。*/
         private boolean invalidated(int index, int prevTakeIndex,
                                     long dequeues, int length) {
             if (index < 0)//队列中无数据，失效
                 return false;
             int distance = index - prevTakeIndex;//计算  下一位元素的索引值-前一位元素索引值
             if (distance < 0)//如果差值小于0
                 distance += length;
             return dequeues > distance;
         }
         private void incorporateDequeues() {
             final int cycles = itrs.cycles;
             final int takeIndex = ArrayBlockingQueue.this.takeIndex;
             final int prevCycles = this.prevCycles;
             final int prevTakeIndex = this.prevTakeIndex;

             if (cycles != prevCycles || takeIndex != prevTakeIndex) {
                 final int len = items.length;
                 long dequeues = (cycles - prevCycles) * len
                     + (takeIndex - prevTakeIndex);

                 if (invalidated(lastRet, prevTakeIndex, dequeues, len))
                     lastRet = REMOVED;
                 if (invalidated(nextIndex, prevTakeIndex, dequeues, len))
                     nextIndex = REMOVED;
                 if (invalidated(cursor, prevTakeIndex, dequeues, len))
                     cursor = takeIndex;

                 if (cursor < 0 && nextIndex < 0 && lastRet < 0)
                     detach();
                 else {
                     this.prevCycles = cycles;
                     this.prevTakeIndex = takeIndex;
                 }
             }
         }
     }
 }

回顾一下；

我介绍了ArrayblockingQueue其实是包含了两个部分一个是标准阻塞队列接口的实现。另一个是jdk1.8增加的迭代器。上一个满大街博客都能找的到，我就把接口描述了一下，然后介绍了两个还算是复杂一点的接口。和整个一个工作原理，没有太多使用case。主要是就是生产者和消费者模型。一个锁应用，和其他的JUC框架不一样。它什么操作都加锁，并发变串行。所以它就没有用到原子类修饰的共享变量。
    关于迭代器部分好像是只有我这里有写。如果有百度上有看到相关ArrayBlockingQueue迭代器文章的请留言。毕竟我一家之言，还是有可能会有理解上的偏差。我们总结一下这个迭代器。首先跟别的设计一样，谁用谁new。这个不一样的是会增加一个注册到堵塞队列对象里面itrs上面。然后呢用了一个软引用，那么就GC可以回收避免内存溢出。然后会有对无用的迭代器的清理，类似于threadLocal那样。那么什么是无用的迭代器呢。标识无用就一个条件，我的迭代器标识的结点被覆盖了，因为它空间就这么大，举个例子一个大小5的堵塞队列。然后我建了一个迭代器，那么这个迭代器的下标就是0.然后迭代器我没有马上用，然后进出队列10次，那么之前节点的值已经被替换了。队列里面还有值，但是迭代器的值已经在take方法中被干掉了，已经失效了。判断条件就是cycle的循环次数。有兴趣可以好好了解一下，这应该是我看过的最复杂的迭代器了。

留一些问题：

1.这个迭代器为什么会比arrayList复杂这么多？

2.其实作为堵塞队列来说无非就是数据交换，拿有什么场景是需要迭代器的？而且本身就全都锁控制，效率就不高。还加入这么复杂的迭代模块。会更慢一些的？

这篇文章会看起来比较碎。尽力了。。没有整块的时间去写。而且没想这个迭代器这么复杂。花费我很多时间去研究（没错，这就是我脱稿的原因）

还有就是风格和上一篇不一样了。我希望可以让看这篇文章的人不光是可以学习到之前不知道的知识。也可以触发大家更多的去主动的思考，去思考模块的设计，功能的实现。而不是被动接受这篇文章所传递出来的内容。

还有就是看这种源码。一定要先框架，功能。摸透再去看细节。如果你对这个代码块所要完成的功能不够了解。拿看起来费劲。框架，功能这些都摸透了。再钻到细节上面去。我们可能用到的框架很多，拿要读的源代码那就太多了。其实阅读源代码我觉得是培养一个阅读代码的能力。一个是学习处理这种场景的解决方案，一个是学习编程风格，编码模式。还有就是可能会培养对编程、对探究的兴趣。毕竟工作不能只是为了赚钱。