Java8 ArrayBlockingQueue 源码解析

ArrayBlockingQueue表示一个基于数组实现的固定容量的，先进先出的，线程安全的队列（栈），本篇博客就详细讲解该类的实现细节。

1、定义

ArrayBlockingQueue的类继承关系如下：

其核心接口BlockingQueue包含的方法定义如下：

上图中的Queue和Collection下面都有两个接口，这两个接口是BlockingQueue覆写的，并不是说这两类只有这两接口，Collection和Queue的主要接口实现都由AbstractQueue实现了，我们重点关注上图中列出来的这些接口的实现。

ArrayBlockingQueue包含的属性如下：

     /**保存队列元素的数组 */
    final Object[] items;

    /** items index for next take, poll, peek or remove */
    int takeIndex;

    /** offer，add，put等方法将元素保存到该索引处 */
    int putIndex;

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

    /** 互斥锁*/
    final ReentrantLock lock;

    /** 如果数组是空的，在该Condition上等待 */
    private final Condition notEmpty;

    /** 如果数组是满的，在该Condition上等待 */
    private final Condition notFull;

    /** 遍历器实现 */
    transient Itrs itrs = null;

重点关注以下方法的实现。

2、构造方法

public ArrayBlockingQueue(int capacity) {
        this(capacity, false);
    }

//capacity表示队列的容量，fair表示是否使用公平锁
public ArrayBlockingQueue(int capacity, boolean fair) {
        if (capacity <= 0)
            throw new IllegalArgumentException();
        this.items = new Object[capacity];
        lock = new ReentrantLock(fair);
        notEmpty = lock.newCondition();
        notFull =  lock.newCondition();
    }

public ArrayBlockingQueue(int capacity, boolean fair,
                              Collection<? extends E> c) {
        this(capacity, fair);

        final ReentrantLock lock = this.lock;
        //加锁的目的是为了其他CPU能够立即看到修改
        //加锁和解锁底层都是CAS，会强制修改写回主存，对其他CPU可见
        lock.lock(); // Lock only for visibility, not mutual exclusion
        try {
            int i = 0;
            try {
                for (E e : c) {
                    checkNotNull(e);
                    items[i++] = e;
                }
            } catch (ArrayIndexOutOfBoundsException ex) {
                throw new IllegalArgumentException();
            }
            count = i;
            putIndex = (i == capacity) ? 0 : i;
        } finally {
            lock.unlock();
        }
    }

3、add / offer / put

这三个方法都是往队列中添加元素，说明如下：

add方法依赖于offer方法，如果队列满了则抛出异常，否则添加成功返回true；
offer方法有两个重载版本，只有一个参数的版本，如果队列满了就返回false，否则加入到队列中，返回true，add方法就是调用此版本的offer方法；另一个带时间参数的版本，如果队列满了则等待，可指定等待的时间，如果这期间中断了则抛出异常，如果等待超时了则返回false，否则加入到队列中返回true；
put方法跟带时间参数的offer方法逻辑一样，不过没有等待的时间限制，会一直等待直到队列有空余位置了，再插入到队列中，返回true

public boolean add(E e) {
        //调用子类offer方法实现，如果队列满了则抛出异常
        return super.add(e);
    }

public boolean offer(E e) {
        //非空检测
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            //数组满了
            if (count == items.length)
                return false;
            else {
                enqueue(e);
                return true;
            }
        } finally {
            lock.unlock();
        }
    }

public void put(E e) throws InterruptedException {
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        //等待的过程被中断了则抛出异常
        lock.lockInterruptibly();
        try {
            //如果数组是满的，则等待
            while (count == items.length)
                notFull.await();
            //加入到数组中   
            enqueue(e);
        } finally {
            lock.unlock();
        }
    }

//同上面的put方法，只不过可以指定等待的时间
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 = notFull.awaitNanos(nanos);
            }
            enqueue(e);
            return true;
        } finally {
            lock.unlock();
        }
    }

public boolean add(E e) {
        if (offer(e))
            return true;
        else
            throw new IllegalStateException("Queue full");
    }


 private void enqueue(E x) {
        final Object[] items = this.items;
        //保存到putIndex索引处
        items[putIndex] = x;
        //数组满了，将其重置为0
        if (++putIndex == items.length)
            putIndex = 0;
        //数组元素个数增加    
        count++;
        //唤醒因为队列是空的而等待的线程
        notEmpty.signal();
    }

private static void checkNotNull(Object v) {
        if (v == null)
            throw new NullPointerException();
    }

4、poll / take / peek

这几个方法都是获取队列顶的元素，具体说明如下：

poll方法有两个重载版本，第一个版本，如果队列是空的，返回null，否则移除并返回队列头部元素；另一个带时间参数的版本，如果栈为空则等待，可以指定等待的时间，如果等待超时了则返回null，如果被中断了则抛出异常，否则移除并返回栈顶元素
take方法同带时间参数的poll方法，但是不能指定等待时间，会一直等待直到队列中有元素为止，然后移除并返回栈顶元素
peek方法只是返回队列头部元素，不移除

public E poll() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            //如果为空，返回null，否则取出一个元素
            return (count == 0) ? null : dequeue();
        } finally {
            lock.unlock();
        }
    }

    public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            //如果空的，则等待
            while (count == 0)
                notEmpty.await();
            //取出一个元素   
            return dequeue();
        } finally {
            lock.unlock();
        }
    }

    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; //等待超时，返回null
                //数组为空，等待    
                nanos = notEmpty.awaitNanos(nanos);
            }
            return dequeue();
        } finally {
            lock.unlock();
        }
    }

    public E peek() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            //返回栈顶元素，takeIndex值不变
            return itemAt(takeIndex); // null when queue is empty
        } finally {
            lock.unlock();
        }
    }

private E dequeue() {
        // assert lock.getHoldCount() == 1;
        // assert items[takeIndex] != null;
        final Object[] items = this.items;
        @SuppressWarnings("unchecked")
        //取出takeIndex的元素，将其置为null
        E x = (E) items[takeIndex];
        items[takeIndex] = null;
        if (++takeIndex == items.length)
            takeIndex = 0;//取完了，从头开始取
        count--;
        if (itrs != null)
            //通知itrs栈顶的元素被移除了
            itrs.elementDequeued();
        //唤醒因为栈满了等待的线程    
        notFull.signal();
        return x;
    }

  final E itemAt(int i) {
        return (E) items[i];
    }

5、remove / clear /drainTo

这三个方法用于从队列中移除元素，具体说明如下：

remove方法用于移除某个元素，如果栈为空或者没有找到该元素则返回false，否则从栈中移除该元素；移除时，如果该元素位于栈顶则直接移除，如果位于栈中间，则需要将该元素后面的其他元素往前面挪动，移除后需要唤醒因为栈满了而阻塞的线程
clear方法用于整个栈，同时将takeIndex置为putIndex，保证栈中的元素先进先出；最后会唤醒最多count个线程，因为正常一个线程插入一个元素，如果唤醒超过count个线程，可能导致部分线程因为栈满了又再次被阻塞
drainTo方法有两个重载版本，一个是不带个数，将所有的元素都移除并拷贝到指定的集合中；一个带个数，将指定个数的元素移除并拷贝到指定的集合中，两者的底层实现都是同一个方法。移除后需要重置takeIndex和count，并唤醒最多移除个数的因为栈满而阻塞的线程。

public boolean remove(Object o) {
        if (o == null) return false;
        final Object[] items = this.items;
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            if (count > 0) {
                final int putIndex = this.putIndex;
                int i = takeIndex;
                //从takeIndex开始往后遍历直到等于putIndex
                do {
                    if (o.equals(items[i])) {
                        //找到目标元素，将其移除
                        removeAt(i);
                        return true;
                    }
                    //走到数组末尾了又从头开始，put时也按照这个规则来
                    if (++i == items.length) 
                        i = 0;
                } while (i != putIndex);
            }
            //如果数组为空，返回false
            return false;
        } finally {
            lock.unlock();
        }
    }


public void clear() {
        final Object[] items = this.items;
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            int k = count;
            if (k > 0) {
                final int putIndex = this.putIndex;
                int i = takeIndex;
                //从takeIndex开始遍历直到i等于putIndex，将数组元素置为null
                do {
                    items[i] = null;
                    if (++i == items.length)
                        i = 0;
                } while (i != putIndex);
                //注意此处没有将这两个index置为0，只是让他们相等，因为只要相等就可以实现栈先进先出了
                takeIndex = putIndex;
                count = 0;
                if (itrs != null)
                    itrs.queueIsEmpty();
                //如果有因为栈满了而等待的线程，则将其唤醒
                //注意这里没有使用signalAll而是通过for循环来signal多次，单纯从唤醒线程来看是可以使用signalAll的，效果跟这里的for循环是一样的
                //如果有等待的线程，说明count就是当前线程的最大容量了，这里清空了，最多只能put count次，一个线程只能put 1次，只唤醒最多count个线程就避免了
                //线程被唤醒后再次因为栈满了而阻塞   
                for (; k > 0 && lock.hasWaiters(notFull); k--)
                    notFull.signal();
            }
        } finally {
            lock.unlock();
        }
    }

public int drainTo(Collection<? super E> c) {
        return drainTo(c, Integer.MAX_VALUE);
    }

public int drainTo(Collection<? super E> c, int maxElements) {
        //校验参数合法
        checkNotNull(c);
        if (c == this)
            throw new IllegalArgumentException();
        if (maxElements <= 0)
            return 0;
        final Object[] items = this.items;
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            //取两者之间的最小值
            int n = Math.min(maxElements, count);
            int take = takeIndex;
            int i = 0;
            try {
                //从takeIndex开始遍历，取出元素然后添加到c中，直到满足个数要求为止
                while (i < n) {
                    @SuppressWarnings("unchecked")
                    E x = (E) items[take];
                    c.add(x);
                    items[take] = null;
                    if (++take == items.length)
                        take = 0;
                    i++;
                }
                return n;
            } finally {
                // Restore invariants even if c.add() threw
                if (i > 0) {
                    //取完了，修改count减去i
                    count -= i;
                    takeIndex = take;
                    if (itrs != null) {
                        if (count == 0)
                             //通知itrs 栈空了
                            itrs.queueIsEmpty();
                        else if (i > take)
                             //说明take中间变成0了，通知itrs
                            itrs.takeIndexWrapped();
                    }
                    //唤醒在因为栈满而等待的线程，最多唤醒i个，同上避免线程被唤醒了因为栈又满了而阻塞
                    for (; i > 0 && lock.hasWaiters(notFull); i--)
                        notFull.signal();
                }
            }
        } finally {
            lock.unlock();
        }
    }

void removeAt(final int removeIndex) {
        final Object[] items = this.items;
        if (removeIndex == takeIndex) {
            //如果移除的就是栈顶的元素
            items[takeIndex] = null;
            if (++takeIndex == items.length)
                takeIndex = 0;
            //元素个数减1    
            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 {
                    //如果下一个元素的索引等于putIndex，说明i就是栈中最后一个元素了，直接将该元素置为null
                    items[i] = null;
                    //重置putIndex为i
                    this.putIndex = i;
                    break;
                }
            }
            count--;
            if (itrs != null)
                //通知itrs节点移除了
                itrs.removedAt(removeIndex);
        }
        //唤醒因为栈满了而等待的线程
        notFull.signal();
    }

6、iterator / Itr / Itrs

iterator方法返回一个迭代器实例，用于实现for循环遍历和部分Collection接口，该方法的实现如下：

public Iterator<E> iterator() {
        return new Itr();
    }

Itr() {
            // assert lock.getHoldCount() == 0;
            lastRet = NONE;
            final ReentrantLock lock = ArrayBlockingQueue.this.lock;
            lock.lock();
            try {
                if (count == 0) {
                    //NONE和DETACHED都是常量
                    cursor = NONE;
                    nextIndex = NONE;
                    prevTakeIndex = DETACHED;
                } else {
                    //初始化各属性
                    final int takeIndex = ArrayBlockingQueue.this.takeIndex;
                    prevTakeIndex = takeIndex;
                    nextItem = itemAt(nextIndex = takeIndex);
                    cursor = incCursor(takeIndex);
                    if (itrs == null) {
                        //初始化Itrs，将当前线程注册到Itrs
                        itrs = new Itrs(this);
                    } else {
                        //将当前线程注册到Itrs中，并执行清理
                        itrs.register(this); // in this order
                        itrs.doSomeSweeping(false);
                    }
                    prevCycles = itrs.cycles;
                }
            } finally {
                lock.unlock();
            }
        }

Itrs(Itr initial) {
    register(initial);
}

//根据index计算cursor
 private int incCursor(int index) {
            // assert lock.getHoldCount() == 1;
            if (++index == items.length)
                index = 0;
            if (index == putIndex)
                index = NONE;
            return index;
        }

void register(Itr itr) {
    head = new Node(itr, head);
}

Itr和Itrs都是ArrayBlockingQueue的两个内部类，Itr包含的属性如下：

 /** 查找下一个nextItem的索引，如果是NONE表示到栈底了*/
 private int cursor; 

 /** 下一次调用next()方法返回的元素，初始值为takeIndex对应的元素 */
 private E nextItem; 

 /**nextItem元素对应的索引，如果是NONE表示nextItem是null, 如果是REMOVED表示nextItem被移除了，初始值就等于takeIndex*/
 private int nextIndex; 

 /**上一次被返回的元素，如果*/
 private E lastItem; 

 /**lastItem对应的索引 */
 private int lastRet; 

 /**Itr初始化时takeIndex的值 */
 private int prevTakeIndex; 

 /**Itr初始化时iters.cycles的值 */
 private int prevCycles; 

 /** 特殊的索引值，表示这个索引对应的元素不存在 */
 private static final int NONE = -1; 

 /** 特殊的索引值，表示该索引对应的元素已经被移除了 */
 private static final int REMOVED = -2; 

 /** 特殊的prevTakeIndex值，表示当前Iter已经从Iters中解除关联了 */
 private static final int DETACHED = -3;

Itrs包含的属性如下：

  /**当takeIndex变成0以后加1 */
  int cycles = 0;

  /** Iter实例链表的链表头 */
  private Node head;

  /** Used to expunge stale iterators */
  private Node sweeper = null;

  private static final int SHORT_SWEEP_PROBES = 4;
  private static final int LONG_SWEEP_PROBES = 16;

其中Node为Itrs的一个内部类，其定义如下：

注意Node继承自WeakReference。

7、doSomeSweeping / register

Itrs内部维护了一个Itr实例链表，register方法用于将一个新的Itr实例加入到链表头，doSomeSweeping方法用于清除该链表中无效的Itr实例，查找这类实例是通过for循环实现的，初始for循环的次数是通过参数tryHandler控制的，如果为true，则循环16次，如果为false，则循环4次，在循环的过程中找到了一个无效的Itr实例，则需要再遍历16次，直到所有节点都遍历完成。注意这里的无效指的这个Itr实例已经同Itrs datached了，当ArrayBlockingQueue执行Itrs的回调方法时就不会处理这种Itr实例了，即Itr实例无法感知到ArrayBlockingQueue的改变了，这时基于Itr实例遍历的结果可能就不准确了。

//创建一个新的Itr实例时，会调用此方法将该实例添加到Node链表中
void register(Itr itr) {
            //创建一个新节点将其插入到head节点的前面
            head = new Node(itr, head);
        }

//用于清理那些陈旧的Node
void doSomeSweeping(boolean tryHarder) {
            // assert lock.getHoldCount() == 1;
            // assert head != null;
            //probes表示循环查找的次数
            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
            
            //o表示上一个有效节点，p表示当前遍历的节点，如果o为空，则p是head，否则是o的下一个节点
            //进入此方法，sweeper可能为null，head不会为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; //sweeper为null时，passedGo为true，终止循环，将sweeper赋值
                    //passedGo为false，sweeper不为null，因为p为null，还是将其置为true，即只能循环一次   
                    o = null;
                    p = head;
                    passedGo = true;
                }
                //获取关联的Itr
                final Itr it = p.get();
                final Node next = p.next;
                if (it == null || it.isDetached()) {
                    //如果it为null或者已经解除关联了
                    //只要找到了一个无效节点，则需要再遍历LONG_SWEEP_PROBES次，直到所有节点遍历完为止
                    probes = LONG_SWEEP_PROBES; // "try harder"
                    //将关联的Itr置为null
                    p.clear();
                    p.next = null;
                    if (o == null) { //sweeper为null或者sweeper的next为null时
                        //没有找到有效节点，重置head，将next之前的节点都移除
                        head = next;
                        if (next == null) {
                            //next为null，没有待处理的节点了，所以Itr都退出了，将itrs置为null
                            itrs = null;
                            return;
                        }
                    }
                    else
                        //将next作为o的下一个节点，即将p移除了
                        o.next = next;
                } else {
                    //p对应的Itr实例是有效的，将o置为p
                    o = p;
                }
                //处理下一个节点
                p = next;
            }
            //重置sweeper，p等于null说明节点都遍历完了，sweeper为null
            //如果p不等于null，说明还有未遍历的节点，将sweeper置为0，下一次遍历时可以重新从该节点开始遍历
            this.sweeper = (p == null) ? null : o;
        }

boolean isDetached() {
            // assert lock.getHoldCount() == 1;
            return prevTakeIndex < 0;
        }

8、queueIsEmpty / elementDequeued / takeIndexWrapped / removedAt

这四个方法都是在某种条件下，由ArrayBlockingQueue回调Itrs的方法，具体如下：

queueIsEmpty方法用于因为元素移除栈空了时调用的，会将Itr链表中的所有元素对Itr实例的引用置为null，将Itr实例的各属性置为null或者特殊index值
takeIndexWrapped方法用于takeIndex变成0了后调用，会增加cycles计数，如果当前cycles属性减去Itr实例的prevCycles属性大于1，则说明Itr初始化时栈中的元素都被移除了，此时再遍历无意义，将这类节点从Itr实例链表中移除，将对Itr的引用置为null，将Itr实例的各属性置为null或者特殊index值
removedAt方法用于从栈中注意不是栈顶移除元素时调用的，会重新计算cursor，lastRet，nextIndex等属性，如果计算出来的属性小于0，则将这个节点从Itr实例链表中移除，将Itr实例的各属性置为null或者特殊index值
elementDequeued方法时元素从栈顶移除时调用，如果当前栈空了则调用queueIsEmpty方法，如果takeIndex变成0了，则调用takeIndexWrapped方法

//从栈顶移除一个元素时回调的
void elementDequeued() {
            // assert lock.getHoldCount() == 1;
            if (count == 0)
                //如果栈空了
                queueIsEmpty();
            else if (takeIndex == 0)
                takeIndexWrapped();
        }

//栈变成空的以后回调此方法
void queueIsEmpty() {
            // assert lock.getHoldCount() == 1;
            //遍历链表
            for (Node p = head; p != null; p = p.next) {
                Itr it = p.get();
                if (it != null) {
                    //将引用清除
                    p.clear();
                    //通知Itr队列空了，将各参数置为null或者特殊index值
                    it.shutdown();
                }
            }
            //重置为null
            head = null;
            itrs = null;
        }

//当takeIndex变成0的时候回调的
void takeIndexWrapped() {
            // assert lock.getHoldCount() == 1;
            cycles++;
            //遍历链表，o表示上一个有效节点，p表示当前遍历的节点
            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之前的节点都移除了
                        head = next;
                    else
                        //移除p这一个节点
                        o.next = next;
                } else {
                    //保存上一个有效节点
                    o = p;
                }
                //处理下一个节点
                p = next;
            }
            //没有有效节点，itrs置为null
            if (head == null)   // no more iterators to track
                itrs = null;
        }

//栈中某个元素被移除时调用
void removedAt(int removedIndex) {
            //遍历链表
            for (Node o = null, p = head; p != null;) {
                final Itr it = p.get();
                final Node next = p.next;
                //removedAt方法判断这个节点是否被移除了
                if (it == null || it.removedAt(removedIndex)) {
                    //将p从链表中移除
                    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;
        }

//判断Itr这个节点是否应该被移除
boolean takeIndexWrapped() {
            // assert lock.getHoldCount() == 1;
            if (isDetached())
                return true;
            if (itrs.cycles - prevCycles > 1) {
                // cycles不一致了，则原来栈中的元素可能都没了
                shutdown();
                return true;
            }
            return false;
        }



void shutdown() {
            // assert lock.getHoldCount() == 1;
            //nextItem没有被置为null，通过next方法还可以返回
            cursor = NONE;
            if (nextIndex >= 0)
                nextIndex = REMOVED;
            if (lastRet >= 0) {
                lastRet = REMOVED;
                lastItem = null;
            }
            prevTakeIndex = DETACHED;
        }

boolean removedAt(int removedIndex) {
            // assert lock.getHoldCount() == 1;
            if (isDetached())
                return true;

            final int cycles = itrs.cycles;
            final int takeIndex = ArrayBlockingQueue.this.takeIndex;
            final int prevCycles = this.prevCycles;
            final int prevTakeIndex = this.prevTakeIndex;
            final int len = items.length;
            int cycleDiff = cycles - prevCycles;
            if (removedIndex < takeIndex)
                cycleDiff++;
            final int removedDistance =
                (cycleDiff * len) + (removedIndex - prevTakeIndex);
            // assert removedDistance >= 0;
            int cursor = this.cursor;
            //按照特定的逻辑重新计算cursor，lastRet，nextIndex等属性
            if (cursor >= 0) {
                int x = distance(cursor, prevTakeIndex, len);
                if (x == removedDistance) {
                    if (cursor == putIndex)
                        this.cursor = cursor = NONE;
                }
                else if (x > removedDistance) {
                    // assert cursor != prevTakeIndex;
                    this.cursor = cursor = dec(cursor);
                }
            }
            int lastRet = this.lastRet;
            if (lastRet >= 0) {
                int x = distance(lastRet, prevTakeIndex, len);
                if (x == removedDistance)
                    this.lastRet = lastRet = REMOVED;
                else if (x > removedDistance)
                    this.lastRet = lastRet = dec(lastRet);
            }
            int nextIndex = this.nextIndex;
            if (nextIndex >= 0) {
                int x = distance(nextIndex, prevTakeIndex, len);
                if (x == removedDistance)
                    this.nextIndex = nextIndex = REMOVED;
                else if (x > removedDistance)
                    this.nextIndex = nextIndex = dec(nextIndex);
            }
            else if (cursor < 0 && nextIndex < 0 && lastRet < 0) {
                this.prevTakeIndex = DETACHED;
                return true;
            }
            return false;
        }

private int distance(int index, int prevTakeIndex, int length) {
            int distance = index - prevTakeIndex;
            if (distance < 0)
                distance += length;
            return distance;
        }

9、next / hasNext / remove

这三个方法时Itr对Iterator接口的实现，如下：

public boolean hasNext() {
            // assert lock.getHoldCount() == 0;
            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();
                //如果isDetached为true还会继续执行    
                // assert nextIndex != NONE;
                // assert lastItem == null;
                lastRet = nextIndex;
                final int cursor = this.cursor;
                if (cursor >= 0) {
                    //获取指定cursor的元素
                    nextItem = itemAt(nextIndex = cursor);
                    //重新计算cursor，如果等于putIndex就将其置为None
                    this.cursor = incCursor(cursor);
                } else {
                    //已经遍历到putIndex处了，上次incCursor计算时将其变成负值
                    nextIndex = NONE;
                    nextItem = null;
                }
            } finally {
                lock.unlock();
            }
            return x;
        }

public void remove() {
            // assert lock.getHoldCount() == 0;
            final ReentrantLock lock = ArrayBlockingQueue.this.lock;
            lock.lock();
            try {
                if (!isDetached())
                    incorporateDequeues(); // might update lastRet or detach
                final int lastRet = this.lastRet;
                this.lastRet = NONE;
                if (lastRet >= 0) {
                    if (!isDetached())
                        //移除lastRet处的元素
                        removeAt(lastRet);
                    else {
                        final E lastItem = this.lastItem;
                        // assert lastItem != null;
                        this.lastItem = null;
                        if (itemAt(lastRet) == lastItem)
                            removeAt(lastRet);
                    }
                } else if (lastRet == NONE)
                    throw new IllegalStateException();

                if (cursor < 0 && nextIndex < 0)
                    detach(); //将当前Itr标记为无效并尝试清理掉
            } finally {
                lock.unlock();
            }
        }

private void noNext() {
            final ReentrantLock lock = ArrayBlockingQueue.this.lock;
            lock.lock();
            try {
                // assert cursor == NONE;
                // assert nextIndex == NONE;
                if (!isDetached()) {
                    //如果当前Itr还是有效的
                    incorporateDequeues(); // might update lastRet
                    if (lastRet >= 0) {
                        lastItem = itemAt(lastRet);
                        // assert lastItem != null;
                        detach();
                    }
                }
                
            } finally {
                lock.unlock();
            }
        }

boolean isDetached() {
            // assert lock.getHoldCount() == 1;
            return prevTakeIndex < 0;
        }

//校验并调整相关属性
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;
                // how far takeIndex has advanced since the previous
                // operation of this iterator
                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;
                }
            }
        }

//校验这个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)
                distance += length;
            return dequeues > distance;
        }

private void detach() {
            if (prevTakeIndex >= 0) {
                //将当前Itr标记为无效的
                prevTakeIndex = DETACHED;
                //尝试将当前Itr从链表中移除
                itrs.doSomeSweeping(true);
            }
        }

private int incCursor(int index) {
            // assert lock.getHoldCount() == 1;
            if (++index == items.length)
                index = 0;
            if (index == putIndex)
                index = NONE;
            return index;
        }

Java8 ArrayBlockingQueue 源码解析

1、定义

2、构造方法

3、add / offer / put

4、poll / take / peek

5、remove / clear /drainTo

6、iterator / Itr / Itrs

7、doSomeSweeping / register

8、queueIsEmpty / elementDequeued / takeIndexWrapped / removedAt

9、next / hasNext / remove

微服务实践之使用 Visual Studio 2022 调试Dapr 应用程序

wpf附加属性理解 WPF附加属性

Java8 File / FileSystem（一）源碼解析

Java8 FileInputStream / FileDescriptor / FileOutputStream 源碼解析

Java8 File / FileSystem（二）源碼解析

Java8 ReentrantLock 源碼解析

Hotspot Thread本地方法實現源碼解析

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結