java阻塞队列之ArrayBlockingQueue

在Java的java.util.concurrent包中定义了和多线程并发相关的操作，有许多好用的工具类，今天就来看下阻塞队列。阻塞队列很好的解决了多线程中数据的安全传输问题，其中最典型的例子就是客园很好的解决“生产者--消费者”问题。下面来看其中一个实现类ArrayBlockingQueue。看到这个名字，就很好理解这个队列肯定是使用数组实现的队列，即使用数组实现的“先进先出”的队列，下面看其具体的实现。（均为JDK8）

一、构造方法

在ArrayBlockingQueue类中有下面的3个构造方法，

1、ArrayBlockingQueue(int)

接收一个整型的参数，这个整型参数指的是队列的长度，其定义如下，

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

可以看到这个方法调用的是ArrayBlockingQueue(int,boolean)方法，那么看下这个方法，

2、ArrayBlockingQueue(int,boolean)

接收两个参数，一个整型，一个boolean类型，前边已经知道整型参数是队列的长度，那么boolean类型参数代表什么意思那，其定义如下，

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

可以看到在这个构造方法中进行了相关逻辑实现，对items进行了数组初始化，boolean类型的参数是作为可重入锁的参数进行初始化，规定可重入锁是公平还是不公平，默认为false，另外初始化了notEmpty、notFull两个信号量。

3、ArrayBlockingQueue(int,boolean,Collection<? extends E>)

接收两三个参数，第一个整型，第二个boolean类型，第三个集合类型，此构造方法不常用，其定义如下，

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

        final ReentrantLock lock = this.lock;
        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();
        }
    }

通过上面的三个构造方法可以构造一个ArrayBlockingQueue的队列，在构造方法中初始化了实列变量，下面是一些实例变量，

private static final long serialVersionUID = -817911632652898426L;

    /** The queued items */
    //保存队列元素的数组
    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;

    /*
     * Concurrency control uses the classic two-condition algorithm
     * found in any textbook.
     */

    /** 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.
     */
    transient Itrs itrs = null;

二、队列的操作

需要使用阻塞队列，那么就需要向队列中添加或取出元素，在ArrayBlocking中已经实现了相关操作，对于添加/取出均是成对出现，提供的方法中有抛出异常、返回false、线程阻塞等几种情形。

1、add/peek

add/peek是一对互斥的操作，add向队列种放入元素，peek取出元素。

1.1、add

add的定义如下

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

从上面可以看出add方法调用了其父类的实现，父类实现如下

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

父类实现种调用的offer方法，在offer方法返回true时，add方法返回true，其他则抛出“Queue full”的异常。offer方法下面会讲到。

1.2、peek

peek方法定义如下

public E peek() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return itemAt(takeIndex); // null when queue is empty
        } finally {
            lock.unlock();
        }
    }

在peek方法种使用可重入锁，返回takeIndex处的元素，前面注释中写道，此变量代表的是待取出元素的索引。itemAt方法定义如下，

@SuppressWarnings("unchecked")
    final E itemAt(int i) {
        return (E) items[i];
    }

此方法未进行任何的判断直接返回takeIndex出的数组元素。

2、put/take

put/take是一对互斥的操作，put向队列种放入元素，take取出元素,其实现方式和add/peek不一样。

2.1、put

put的定义如下

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

此方法会判断元素是否null，然后判断当前队列中的元素数量和队列的长度，如果二者相等则阻塞当前线程；如果不相等则执行enqueue(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();
    }

把待插入的元素放在数组的putIndex位置，如果执行完插入后putIndex等于数组的长度，说明队列已经满了，那么把putIndex的值置为0，即下次插入的位置为0，下次要插入成功的必要条件是取出了一个元素，取出的位置为takeIndex。

2.2、take

take方法是取出一个元素，其定义如下，

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

此方法中首先判断当前队列的元素数量如果为0，则当前线程进行等待，等待notEmpty.singal()，如果不为空则执行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;
    }

此方法取出takeIndex位置的元素，把数组中此位置的引用置为null，判断takeIndex和数组的长度，如果相等证明，已经取到了最后一个元素，下次再取元素需要从位置0开始，为此把takeIndex置为0。

3、offer(E)/poll

offer/poll是一对互斥的操作，offer向队列种放入元素，poll取出元素，

3.1、offer

offer的定义如下

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

此方法判断如果队列中的元素数量和队列长度相等，则直接返回false，否则执行enqueue方法，put方法会将线程挂起，直到被中断或插入成功。

3.2、poll

poll方法如下

public E poll() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return (count == 0) ? null : dequeue();
        } finally {
            lock.unlock();
        }
    }

此方法判断当前队列中的元素个数如果为0返回null，否则执行dequeue操作，take方法会将线程挂起，直到被中断或取出成功。

4、offer(E,long,TimeUnit)/poll(long,TimeUnnit)

这两个方法是普通offer/poll方法的加强版，在队列满时指定了重试的时间，如果超过指定的时间后还是无法添加或取出则返回false。

4.1、offer

offer方法如下

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;//超过规定时间，返回false
                nanos = notFull.awaitNanos(nanos);
            }
            enqueue(e);
            return true;
        } finally {
            lock.unlock();
        }
    }

此方法会在指定的规定时间内一直重试，如果规定时间内无法退出循环即添加元素，则返回false。

4.2、poll

poll方法如下，

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

此方法同样是在取出元素时进行规定时间的重试，超过规定时间则返回null。

三、方法比较

1、添加方法比较

序号	方法名	队列满时处理方式	方法返回值
1	add(E e)	抛出“Queue full”异常	boolean
2	offer(E e)	返回false	boolean
3	put(E e)	线程阻塞，直到中断或被唤醒	void
4	offer(E e, long timeout, TimeUnit unit)	在规定时间内重试，超过规定时间返回false	boolean

2、取出方法比较

序号	方法名	队列空时处理方式	方法返回值
1	peek()	返回null	E
2	poll()	返回null	E
3	take()	线程阻塞，指定中断或被唤醒	E
4	poll(long timeout, TimeUnit unit)	在规定时间内重试，超过规定时间返回null	E

四、总结

以上时关于ArrayBlockingQueue这个阻塞队列的相关实现及方法介绍，此队列以数组为载体，配合可重入锁实现生产线程和消费线程共享数据，ArrayBlockingQueue作为共享池，实现了并发条件下的添加及取出等方法。

有不正之处欢迎指正，感谢！