ArrayBlockingQueue源码讲解

尊重原创，转载请标明出处   http://blog.csdn.net/abcdef314159

源码：\sources\android-25

ArrayBlockingQueue是一个数组阻塞队列，这个队列的元素是先进先出，head元素是最先加入的，tail是最后加入的，并且新的元素加入到tail，获取元素从head开始。他有两个int指针，putIndex指向队尾的下一个，是空，表示下一个存放的位置，takeInput指向队首，表示下一个读取的位置takeInput有可能大于putIndex，也有可能小于putIndex。takeInput有固定大小，一旦创建大小则不能改变，如果把一个元素放入到一个满的队列中则会阻塞，同样如果从一个空的队列中获取元素也会阻塞。先看一下ArrayBlockingQueue的几个方法，从上往下看，先看第一个dec(int i)

    /**     * Circularly decrements array index i.     */    final int dec(int i) {//他表示获取当前下标i的前一个下标，如果i为0就表示获取head的前一个，//这里让他等于最后一个。        return ((i == 0) ? items.length : i) - 1;    }

接着看下一个方法enqueue(E x)，表示加入一个元素x，

    /**     * Inserts element at current put position, advances, and signals.     * Call only when holding lock.     */    private void enqueue(E x) {        // assert lock.getHoldCount() == 1;        // assert items[putIndex] == null;        final Object[] items = this.items;//putIndex表示最后插入元素的index        items[putIndex] = x;//如果puIndex等于items的长度，则让putIndex等于0，        if (++putIndex == items.length) putIndex = 0;        count++;        notEmpty.signal();    }

接着下一个方法dequeue()表示移除第一个元素，注意第一个元素是takeIndex下标的元素，最后一个元素是putIndex下标的上一个元素，putIndex指向的是下一个存放的位置。接着看下一个方法removeAt(final int removeIndex)，移除指定位置的元素

    /**     * Deletes item at array index removeIndex.     * Utility for remove(Object) and iterator.remove.     * Call only when holding lock.     */    void removeAt(final int removeIndex) {        // assert lock.getHoldCount() == 1;        // assert items[removeIndex] != null;        // assert removeIndex >= 0 && removeIndex < items.length;        final Object[] items = this.items;        if (removeIndex == takeIndex) {//如果移除的正好等于头元素，直接移除，因为这个队列就是先进先出的。            // removing front item; just advance            items[takeIndex] = null;//如果takeIndex等于items的长度，则让他等于0，相当于从队尾又指向队首            if (++takeIndex == items.length) takeIndex = 0;            count--;            if (itrs != null)                itrs.elementDequeued();        } else {            // an "interior" remove            // slide over all others up through putIndex.            for (int i = removeIndex, putIndex = this.putIndex;;) {                int pred = i;                if (++i == items.length) i = 0;//打算把后面的往前移，直到找到putIndex才会break，如果后面一个正好是putIndex//（putIndex相当于队尾，就是元素存放的位置，实际上还没有存，是空的），则直接//把当前下标为i的删除，然后再让putIndex等于i，                if (i == putIndex) {                    items[pred] = null;                    this.putIndex = pred;                    break;                }//把后面的往前移                items[pred] = items[i];            }            count--;            if (itrs != null)                itrs.removedAt(removeIndex);        }        notFull.signal();    }

接着看下一个remove(Object o)方法

    public boolean remove(Object o) {        if (o == null) return false;        final ReentrantLock lock = this.lock;        lock.lock();        try {            if (count > 0) {                final Object[] items = this.items;//putIndex相当于尾                final int putIndex = this.putIndex;//takeIndex相当于头，但要注意，putIndex和takeIndex相当于//两个指针，有可能putIndex大于takeIndex，也有可能takeIndex大于putIndex                int i = takeIndex;//从takeIndex开始检查是否相等，如果相等则直接返回，否则循环检查，直到//i等于putIndex为止，因为takeIndex是最先加入的，元素的范围也就是从// takeIndex到putIndex，这里takeIndex和putIndex谁大谁小还不一定，//这里可以参照前面写的《ArrayDeque源码详解》                do {                    if (o.equals(items[i])) {                        removeAt(i);                        return true;                    }                    if (++i == items.length) i = 0 ;//如果找到数组的最后，要从头开始                } while (i != putIndex);            }            return false;        } finally {            lock.unlock();        }    }

接着是contains(Object o)方法，和上面的contains(Object o)方法差不多，就不在介绍。接着是Object[] toArray()方法，这里要分两种情况，一种是putIndex大于takeIndex，还一种是putIndex小于takeIndex。这个可以参照前面讲的《ArrayDeque源码详解》的Object[] toArray()方法，这里就不在介绍。再来看最后一个方法drainTo

    public int drainTo(Collection<? super E> c, int maxElements) {//从takeIndex开始提取maxElements个元素存储在集合c中，如果maxElements//大于数组，则提取大小为items.size();提取之后把当前的ArrayBlockingQueue//中提取的删除。        Objects.requireNonNull(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 {                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;                    takeIndex = take;                    if (itrs != null) {                        if (count == 0)                            itrs.queueIsEmpty();                        else if (i > take)                            itrs.takeIndexWrapped();                    }                    for (; i > 0 && lock.hasWaiters(notFull); i--)                        notFull.signal();                }            }        } finally {            lock.unlock();        }    }