ArrayBlockingQueue原理分析(一)

概述

ArrayBlockingQueue是一个阻塞队列，其实底层就是一个数组，说到底层是数组，ArrayList底层也是数组，那它其实也可以作为队列，但是是非阻塞的，那阻塞和非阻塞的区别是什么？区别在于当队列中没有元素的时候就阻塞等待，直到队列中有数据再消费，而如果队列满了之后（队列有界），生产者就要阻塞。下面就总结一下ArrayBlockingQueue的特性。

• 是一个有界的队列，初始化队列的时候传入队列大小
• 采用ReentrantLock + Condition实现线程安全和阻塞
• 底层采用数组存储
• 生产者和消费者共用一把锁，所以效率一般

总结来说就是效率一般，容量有限，那既然这么差还要搞一个这个对象，原因就是这个实现起来简单。ArrayBlockingQueue的插入和删除操作都比较简单，但是里面有一个东西其实还挺复杂的，就是Itrs,迭代器，我打算写两篇博客，本篇介绍插入和删除等一般的方法，下一篇介绍迭代器。

继承结构图

 这幅图画出了Java中常用队列的继承结构图，可以看出所有的队列都实现了AbstartQueue，这个抽象类实现了Queue接口，提供了Queue接口中方法的默认实现，继承它可以少写一些不必要的代码，但是Queue接口中没有提供大多数的阻塞方法，所以有了BlockingQueue接口，这个接口中提供很多的阻塞的插入删除方法，而最底层的实现者都是阻塞队列，所以都会实现这个接口。

属性分析

    /** 队列中元素保存的地方 */
    final Object[] items;

    /** items index for next take, poll, peek or remove，这个英文注释很详细 */
    int takeIndex;

    /** items index for next put, offer, or add */
    int putIndex;

    /** Number of elements in the queue */
    int count;

    /** Main lock guarding all access */
    final ReentrantLock lock;

    /** Condition for waiting takes，处理消费者线程的 */
    private final Condition notEmpty;

    /** Condition for waiting puts，处理生产者线程的 */
    private final Condition notFull;

    /**
     * Shared state for currently active iterators, or null if there
     * are known not to be any.  Allows queue operations to update
     * iterator state.
     * 迭代器，由于一个队列可以有多个迭代器，所以在该队列中，迭代器通过链表连接起来，itrs属性就是链表头
     * 通过这个头，就可以找到所有的迭代器，下一篇文章会具体分析
     */

    transient Itrs itrs = null;

构造方法

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

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();
    }

关于这里的公平锁，在网上看资料时，发现有的胖友写的文章中说，这里如果是公平锁，如果队列满了，生产者阻塞了非常多，那等待最久的生产者线程会先竞争到锁，别的阻塞线程不能跟他竞争锁，其实这么解释的结论是对的，就是如果是公平锁，那等最久的确实先竞争到锁，但是原因并不是上面说的原因，即便是非公平锁，如果没有新的生产者加入竞争锁，也是等最久先竞争到锁，这里公平锁的作用是说，当多个消费者线程消费多个元素之后，唤醒多个生产者，这时候如果有新的生产者加入，这些生产者需要等待刚刚唤醒的生产者执行完之后才可以竞争锁。

Queue

public interface Queue<E> extends Collection<E> {
    //添加元素
    boolean add(E e);
    //添加元素
    boolean offer(E e);
    //删除
    E remove();
    //消费元素，其实也是删除
    E poll();
    //当前元素
    E element();
    //当前消费要消费的元素，不会移除队列，只是获取
    E peek();
}

BlockingQueue

//其实这个接口继承于Queue，只不过多添加了几个方法
public interface BlockingQueue<E> extends Queue<E> {
    //添加元素
    boolean add(E e);
    //添加元素
    boolean offer(E e);
    //添加元素
    void put(E e) throws InterruptedException;
    //添加元素
    boolean offer(E e, long timeout, TimeUnit unit)
        throws InterruptedException;
    //消费元素
    E take() throws InterruptedException;
    //消费元素
    E poll(long timeout, TimeUnit unit)
        throws InterruptedException;
    
    int remainingCapacity();
    //删除元素
    boolean remove(Object o);

    public boolean contains(Object o);

    int drainTo(Collection<? super E> c);

    public boolean contains(Object o);

}

搞不懂有些方法在Queue中已经定义了，这里还要重复定义。

ArrayBlockedQueue

ArrayBlockedQueue实现了上面的队列，下面就对其实现的方法做一个对比。

生产者方法	消费者方法
add(E e)：直接调用offer,和offer方法返回不同，如果插入成功，返回true，否则抛出异常
offer(E e)：向队尾插入数据，如果队列满了，就返回插入失败	poll()：从队头获取元素，如果队列为空，返回失败
offer(E e, long timeout, TimeUnit unit)：向队尾插入数据， 如果队列满了，阻塞等待一段时间，超时返回插入失败	poll(long timeout, TimeUnit unit)：从队头获取元素，如果队列为空，等待一段时间，如果超时返回失败
put(E e)：向队尾插入元素，如果队列满了就一直等待，直到队列中有空闲空间	take()：从队头获取元素，如果队列为空，阻塞等待，直到队列中有元素再消费
	remove(Object o)：删除队列中的元素，可以是队列中的任意元素

从上面的对比可知，中间三个方法生产者和消费者是相对的。

add(E e)

public boolean add(E e) {
        return super.add(e);
    }

//AbstractQueue的实现，直接调用offer方法，不过和offer不同的是，如果插入队列失败
//直接抛出异常
public boolean add(E e) {
        if (offer(e))
            return true;
        else
            throw new IllegalStateException("Queue full");
    }

offer(E e)

    public boolean offer(E e) {
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        //先加锁，防止多线程出问题
        lock.lock();
        try {
            //如果数组满了，返回false
            if (count == items.length)
                return false;
            else {
                //下面分析这个方法
                enqueue(e);
                return true;
            }
        } finally {
            lock.unlock();
        }
    }

进入#enqueue(E e)

    private void enqueue(E x) {
        // assert lock.getHoldCount() == 1;
        // assert items[putIndex] == null;
        final Object[] items = this.items;
        //队尾插入
        items[putIndex] = x;
        if (++putIndex == items.length)
            putIndex = 0;
        //元素数量自增
        count++;
        //通知阻塞的消费者线程
        notEmpty.signal();
    }

这个方法实现很简单，不过生产者的几个方法基本都是调用这个方法。

offer(E e, long timeout, TimeUnit unit)

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) {
               //下面那个返回负数，这里直接return一个false结束
                if (nanos <= 0)
                    return false;
                //阻塞固定的时间，如果超时之后会返回一个0或者负数
                nanos = notFull.awaitNanos(nanos);
            }
            //还是调用这个方法，就不分析了
            enqueue(e);
            return true;
        } finally {
            lock.unlock();
        }
    }

这个方法和offer(E e)有两点不同：

• 使用的锁是可中断锁，就是说如果在等待过程中，线程被中断了会抛出一个异常
• 使用了超时等待，如果超时才会返回false

put(E e)

    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();
        }
    }

ok，到此就把生产者的方法分析完了，其实都是调用的enqueue方法，很简单。

用最帅的陈永仁做分割线。。。

　　　　　　

poll(E e)

    public E poll() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            //如果队列为空返回null，否则之后后面的方法
            return (count == 0) ? null : dequeue();
        } finally {
            lock.unlock();
        }
    }

进入dequeue()方法

private E dequeue() {
        // assert lock.getHoldCount() == 1;
        // assert items[takeIndex] != null;
        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)
            itrs.elementDequeued();
        //通知生产者线程
        notFull.signal();
        return x;
    }

上面的过程都非常简单，这里提一下itrs这部分代码，举个例子，假设通过如下代码获取了一个迭代器

ArrayBlockingQueue<Integer> queue = new ArrayBlockingQueue(10);
Iterator<Integer> iterator = queue.iterator();

在迭代器初始化时候，其第一个要迭代的元素和消费者要消费的元素是同一个，在上面的代码中如果消费者消费元素，把队列中所有的元素消费完了，但是迭代器还没有运行，这个时候就需要更新迭代器中的一些参数，不让它迭代了，因为队列已经为空了，这里只是提一下，下一篇文章会详细介绍。

poll(long timeout, TimeUnit unit)

    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();
        }
    }

take(E e)

    public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            while (count == 0)
                notEmpty.await();
            return dequeue();
        } finally {
            lock.unlock();
        }
    }

remove(Object o)

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;
                do {
                   //遍历队列，寻找要删除的元素
                    if (o.equals(items[i])) {
                        //执行删除，之后移动数组中的元素，把删除的元素的空位置给挤占掉
                        removeAt(i);
                        return true;
                    }
                    if (++i == items.length)
                        i = 0;
                } while (i != putIndex);
            }
            return false;
        } finally {
            lock.unlock();
        }
    }

进入removeAt(i)

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;
            if (++takeIndex == items.length)
                takeIndex = 0;
            count--;
            if (itrs != null)
                itrs.elementDequeued();
        } else {
            // an "interior" remove

            // slide over all others up through putIndex.
            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();
    }

以上就是ArrayBlockingQueue常用方法，还有几个比如contains,toString,toArray都很简单，就不贴代码了。

总结

ArrayBlockingQueue总的来说在上面列的结构图中算是最简单的一个，在概述中也说了，其实这里面复杂的是迭代，队列其实很简单，下一篇文章分析迭代过程。