概述
在上篇文章的结构图中可以看出，所有的队列最后都实现了Queue接口，而Queue继承了Collection接口，而Collection接口继承了Iterable，由于不同的集合会根据自己集合的特性实现自己的迭代器，那本文就分析一下ArrayBlockingQueue集合迭代器的实现方式，因为之前都是一直使用这玩意，从来不清楚内部如何工作的，所以就拿这个集合的迭代器分析一下。
Iterable接口
public interface Iterable<T> {
//顺序迭代器
Iterator<T> iterator();
//遍历集合，里面传入一个Consumer
default void forEach(Consumer<? super T> action) {
Objects.requireNonNull(action);
for (T t : this) {
action.accept(t);
}
}
//可分割迭代器
default Spliterator<T> spliterator() {
return Spliterators.spliteratorUnknownSize(iterator(), 0);
}
}
这个方法会返回两个迭代器，后面都会分析，中间那个是遍历集合中的元素，传入一个Consumer，意思是说对集合中的每个元素都执行一下accept方法。
Iterator接口
public interface Iterator<E> {
public interface Iterator<E> {
//是否有下一个元素
boolean hasNext();
//返回当前的下一个
E next();
//移除，一般调用集合的remove方法进行移除
default void remove() {
throw new UnsupportedOperationException("remove");
}
//对剩余元素遍历
default void forEachRemaining(Consumer<? super E> action) {
Objects.requireNonNull(action);
while (hasNext())
action.accept(next());
}
}
Spliterator接口
public interface Spliterator<T> { //单个对元素执行给定的动作，如果有剩下元素未处理返回true，否则返回false boolean tryAdvance(Consumer<? super T> action); //对每个剩余元素执行给定的动作，依次处理，直到所有元素已被处理或被异常终止。默认方法调用tryAdvance方法 default void forEachRemaining(Consumer<? super T> action) { do { } while (tryAdvance(action)); } //对任务分割，返回一个新的Spliterator迭代器 Spliterator<T> trySplit(); }
从这三个接口可以看出，第一个接口只是把下面的两个接口封装了一下，其本身基本没有定义迭代相关的方法，就只有一个遍历。Iterator和Spliterator的区别在于一个是顺序遍历，另一个是可分割的遍历，因为Java8为了加快大集合的遍历，采用了分布式的方式，先把大集合拆分成小集合，之后多线程并行遍历。本文不会介绍ArrayBlockingQueue的Spliterator迭代器，只介绍Iterator迭代器。
Itrs类
该类封装了Itr类，而Itr实现了Iterator接口。
class Itrs { /** * Node in a linked list of weak iterator references. * 定义节点，节点中包装了Itr迭代器，当Itr没有强引用存在的时候 * 可以直接回收Itr，然后doSomeSweeping会回收无用的节点 */ private class Node extends WeakReference<Itr> { Node next; Node(Itr iterator, Node next) { super(iterator); this.next = next; } } /** Incremented whenever takeIndex wraps around to 0 */ int cycles = 0; /** Linked list of weak iterator references，首节点 */ private Node head; /** Used to expunge stale iterators ，要被清除的node*/ 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); } //清除迭代器已经被回收的Node节点 void doSomeSweeping(boolean tryHarder) { // assert lock.getHoldCount() == 1; // assert head != null; int probes = tryHarder ? LONG_SWEEP_PROBES : SHORT_SWEEP_PROBES; Node o, p; final Node sweeper = this.sweeper; boolean passedGo; // to limit search to one full sweep //如果为null，从头开始清理 if (sweeper == null) { o = null; p = head; passedGo = true; } else { o = sweeper; p = o.next; passedGo = false; } for (; probes > 0; probes--) { if (p == null) { if (passedGo) break; o = null; p = head; passedGo = true; } final Itr it = p.get(); final Node next = p.next; if (it == null || it.isDetached()) { // found a discarded/exhausted iterator //这里只要发现了需要清理的node，就重置probes，让循环一直进行下去 probes = LONG_SWEEP_PROBES; // "try harder" // unlink p //移除节点 p.clear(); p.next = null; if (o == null) { head = next; if (next == null) { // We've run out of iterators to track; retire itrs = null; return; } } else o.next = next; } else { o = p; } p = next; } this.sweeper = (p == null) ? null : o; } /** * Adds a new iterator to the linked list of tracked iterators. */ void register(Itr itr) { // assert lock.getHoldCount() == 1; //将加入的节点放在链表的头部 head = new Node(itr, head); } //移除节点 void removedAt(int removedIndex) { for (Node o = null, p = head; p != null;) { final Itr it = p.get(); final Node next = p.next; if (it == null || it.removedAt(removedIndex)) { // unlink p // assert it == null || it.isDetached(); 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; } /** * Called whenever the queue becomes empty. * * Notifies all active iterators that the queue is empty, * clears all weak refs, and unlinks the itrs datastructure. */ void queueIsEmpty() { // assert lock.getHoldCount() == 1; for (Node p = head; p != null; p = p.next) { Itr it = p.get(); if (it != null) { p.clear(); it.shutdown(); } } head = null; itrs = null; } /** * Called whenever an element has been dequeued (at takeIndex). */ void elementDequeued() { // assert lock.getHoldCount() == 1; if (count == 0) queueIsEmpty(); else if (takeIndex == 0) takeIndexWrapped(); } }
Itr内部类
从上面的分析可知，Itrs用来管理Itr，将Itr包装到一个Node节点中，然后节点中有一个指针，最终构成一个链表，其中Itr使用了弱引用包装，方便垃圾回收。Itr类是ArrayBlockingQueue内部的一个类，实现了Iterator接口，下面看一下这个类。
属性
private class Itr implements Iterator<E> { /** Index to look for new nextItem; NONE at end,迭代器的迭代位置*/ private int cursor; /** Element to be returned by next call to next(); null if none，下一个元素的值，这个值是队列中的值 */ private E nextItem; /** Index of nextItem; NONE if none, REMOVED if removed elsewhere，下一个元素位置 */ private int nextIndex; /** Last element returned; null if none or not detached. */ private E lastItem; /** Index of lastItem, NONE if none, REMOVED if removed elsewhere */ private int lastRet; }
构造方法
Itr() { // assert lock.getHoldCount() == 0; lastRet = NONE; final ReentrantLock lock = ArrayBlockingQueue.this.lock; lock.lock(); try { //如果队列中没有元素 if (count == 0) { // assert itrs == null; cursor = NONE; nextIndex = NONE; prevTakeIndex = DETACHED; } else { //初始化赋值，takeIndex为消费者消费的位置 final int takeIndex = ArrayBlockingQueue.this.takeIndex; prevTakeIndex = takeIndex; //这里就是下一个待消费数据 nextItem = itemAt(nextIndex = takeIndex); //初始化游标，初始化为takeIndex的下一个位置 cursor = incCursor(takeIndex); if (itrs == null) { //itrs为链表的首节点，如果首节点为null，说明当前队列没有迭代器 itrs = new Itrs(this); } else { //如果有的，就把当前迭代器节点放到链表的最前面 itrs.register(this); // in this order //清除链表中无效的迭代器节点 itrs.doSomeSweeping(false); } prevCycles = itrs.cycles; // assert takeIndex >= 0; // assert prevTakeIndex == takeIndex; // assert nextIndex >= 0; // assert nextItem != null; } } finally { lock.unlock(); } }
从上面可以看出，构造方法，就是为里面的一些属性进行赋值，这些属性都是为了控制迭代过程的。
常用方法
public boolean hasNext() { // assert lock.getHoldCount() == 0; //直接看属性的变量中有没有，有就返回true if (nextItem != null) return true; noNext(); return false; } 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 { if (!isDetached()) incorporateDequeues(); // assert nextIndex != NONE; // assert lastItem == null; lastRet = nextIndex; final int cursor = this.cursor; if (cursor >= 0) { //重新更新nextItem，如果先执行next方法，之后执行了两次take方法 //第二次即便take已经把第二个元素取出了，这个时候再调用next，依然为 //执行take方法之前的第二个元素 nextItem = itemAt(nextIndex = cursor); // assert nextItem != null; //更新游标 this.cursor = incCursor(cursor); } else { nextIndex = NONE; nextItem = null; } } finally { lock.unlock(); } return x; }
总结
整个来说，迭代器原理就是使用一些变量控制到迭代的位置，当队列中的元素发生变更的时候，迭代器的控制变量跟着变动就可以，由于ArrayBlockingQueue采用了加锁的方式，所以迭代的过程中队列中删除元素是没有影响的，因为会自动修复迭代器的控制变量，而且只有一个变量修改，所以不会出现线程不安全的问题。一个队列可以有多个迭代器，迭代器被封装在Node中，最后构成一个链表，当队列中的元素更新的时候，方便统一更新迭代器的控制变量。