Java并发之ArrayBlockingQueue

 ArrayBlockingQueue是一个由数组支持的有界阻塞队列。此队列按 FIFO（先进先出）原则对元素进行排序。队列的头部是在队列中存在时间最长的元素。队列的尾部是在队列中存在时间最短的元素。新元素插入到队列的尾部，队列获取操作则是从队列头部开始获得元素。 

        ArrayBlockingQueue继承自 AbstractQueue并实现 BlockingQueue接口。

 

        ArrayBlockingQueue是一个典型的“有界缓存区”，固定大小的数组在其中保持生产者插入的元素和使用者提取的元素。一旦创建了这样的缓存区，就不能再增加其容量。试图向已满队列中放入元素会导致操作受阻塞，试图从空队列中提取元素将导致类似阻塞。 

        ArrayBlockingQueue支持对等待的生产者线程和使用者线程进行排序的可选公平策略。默认情况下，不保证是这种排序。然而，通过将公平性 (fairness) 设置为 true 而构造的队列允许按照 FIFO 顺序访问线程。公平性通常会降低吞吐量，但也减少了可变性和避免了“不平衡性”。 公平性通过创建 ArrayBlockingQueue实例时指定。

        1.成员变量

/** 队列数组实现 */
private final E[] items;
/** 已取出元素索引，用于下一个元素的 take, poll or remove */
private int takeIndex;
/** 已插入元素索引，用于下一个元素的 put, offer, or add */
private int putIndex;
/** 队列中项目数 */
private int count;
/** 保护所有访问的主锁 */
private final ReentrantLock lock;
/** Condition 实例，用于等待中 take */
private final Condition notEmpty;
/** Condition 实例，用于等待中 put*/
private final Condition notFull;

        之前我们已经学习了锁相关的知识，所以几个成员变量不难理解。

        1）其中E[] items;是数组式的队列实现；

        2）takeIndex 用于记录 take操作的次数；

        3）putIndex 用于记录 put操作的次数；

        4）count 用于记录队列中元素数目；

        5）ReentrantLock lock 是用于控制访问的主锁；

        6）Condition notEmpty 获取操作时的条；

        7）Condition notFull 插入操作时的条件；

        2.构造方法

        ArrayBlockingQueue的构造方法有3个。

        1）最简单的构造方法：

//指定队列大小
public ArrayBlockingQueue(int capacity) {
    this(capacity, false);
}

        此种构造方法最为简单也最为常用，在创建 ArrayBlockingQueue实例时只需指定其大小即可。

BlockingQueue<Object> q = new ArrayBlockingQueue<Object>(10);

        2）增加访问策略的构造方法，除了指定队列大小外还可指定队列的访问策略：

//指定队列大小、访问策略
public ArrayBlockingQueue(int capacity, boolean fair) {
    if (capacity <= 0)
        throw new IllegalArgumentException();
    this.items = (E[]) new Object[capacity];
    lock = new ReentrantLock(fair);
    notEmpty = lock.newCondition();
    notFull = lock.newCondition();
}

        fair如果为 true，则按照 FIFO 顺序访问插入或移除时受阻塞线程的队列；如果为 false，则访问顺序是不确定的。

        构造方法中首先初始化了 items数组，然后根据fair创建 ReentrantLock实例，最后返回 notEmpty与 notFull两个 Condition实例，分别用于等待中的获取与添加操作。

        3）带初始元素的构造方法：

//指定队列大小、访问策略、初始元素
public ArrayBlockingQueue(int capacity, boolean fair, Collection<? extends E> c) {
    this(capacity, fair);
    if (capacity < c.size())
        throw new IllegalArgumentException();

    for (Iterator<? extends E> it = c.iterator(); it.hasNext();)
        add(it.next());
}

        除了可以指定容量和访问策略外，还可以包含给定 collection 的元素，并以 collection 迭代器的遍历顺序添加元素。

        代码也可以观察到，在实例化队列之后还使用了add方法将 collection 中的元素按原有顺序添加到实例中。

        3.添加元素

        1）add方法

        ArrayBlockingQueue的add方法调用的是父类方法，而父类 add方法则调用的是 offer方法，以下是add方法的源代码：

public boolean add(E e) {
    //调用父类add方法
    return super.add(e);
}

        2）offer方法

        offer方法将指定的元素插入到此队列的尾部（如果立即可行且不会超过该队列的容量），在成功时返回 true，如果此队列已满，则返回 false。此方法通常要优于 add(E) 方法，后者可能无法插入元素，而只是抛出一个异常。 

/**
 * 将指定的元素插入到此队列的尾部（如果立即可行且不会超过该队列的容量），
 * 在成功时返回 true，如果此队列已满，则返回 false。
 * 此方法通常要优于 add(E) 方法，后者可能无法插入元素，而只是抛出一个异常。
 */
public boolean offer(E e) {
    //判断e是否为null
    if (e == null)
        throw new NullPointerException();
    final ReentrantLock lock = this.lock;
    //获取锁
    lock.lock();
    try {
        //判断队列是否已满
        if (count == items.length)
            return false;
        else {
            //如果未满则插入
            insert(e);
            return true;
        }
    } finally {
        //释放锁
        lock.unlock();
    }
}

        因为 add方法在队列已满时会抛出异常，所以 offer方法一般优于 add方法使用。

        首先，判断要添加的元素是否为 null，如果为null则抛出空指针异常。

        接着，创建一个 ReentrantLock实例，ReentrantLock是可重入锁实现。更详细介绍参考http://286.iteye.com/blog/2296191

        然后，获取锁。

        最后，判断队列是否已满，如果已满则返回 false；如果未满则调用insert方法插入元素，返回true。

        所有操作完成后释放锁。

        offer方法的处理流程可以参照以下流程图：

        从代码中就可以看到，offer方法利用了ReentrantLock来实现队列阻塞的功能，所以多线程操作相同队列时会排队等待。

        offer的另一个重载方法是 offer(E e, long timeout, TimeUnit unit)，此重载方法将指定的元素插入此队列的尾部，如果该队列已满，则在到达指定的等待时间之前等待可用的空间。其源代码为：

/**
 * 将指定的元素插入此队列的尾部，如果该队列已满，则在到达指定的等待时间之前等待可用的空间。
 */
public boolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException {

    if (e == null)
        throw new NullPointerException();
    long nanos = unit.toNanos(timeout);
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        for (;;) {
            if (count != items.length) {
                insert(e);
                return true;
            }
            if (nanos <= 0)
                return false;
            try {
                nanos = notFull.awaitNanos(nanos);
            } catch (InterruptedException ie) {
                notFull.signal(); // propagate to non-interrupted thread
                throw ie;
            }
        }
    } finally {
        lock.unlock();
    }
}

        与普通offer方法不同之处在于：offer(E e, long timeout, TimeUnit unit)方法利用循环在指定时间内不断去尝试添加元素，如果成功则返回true，如果指定时间已到则退出返回 false。

        3）insert方法

        insert方法在当前位置（putIndex）插入元素。

/**
 * 在当前位置（putIndex）插入元素（在获得锁的情况下调用）
 */
private void insert(E x) {
    //设置 putIndex位置 items数组元素为x
    items[putIndex] = x;
    //返回putIndex新值，如果已满则返回0，未满则+1
    putIndex = inc(putIndex);
    //增加元素数量
    ++count;
    //唤醒获取线程
    notEmpty.signal();
}

        因为 ArrayBlockingQueue内部队列实现为数组items，而 putIndex则记录了队列中已添加元素的位置，所以新添加的元素就直接被添加到数组的指定位置。随后修改 putIndex值，如果队列未满则+1，如果已满则从0重新开始。最后唤醒 notEmpty中的一个线程。

        4）put方法

        将指定的元素插入此队列的尾部，如果该队列已满，则等待可用的空间。

        以下是put方法的源代码：

/**
 * 将指定的元素插入此队列的尾部，如果该队列已满，则等待可用的空间
 */
public void put(E e) throws InterruptedException {
    //判断e是否为null
    if (e == null)
        throw new NullPointerException();
    final E[] items = this.items;
    final ReentrantLock lock = this.lock;
    //获取中断锁
    lock.lockInterruptibly();
    try {
        try {
            //利用循环判断队列是否已满
            while (count == items.length)
                //如果已满则调用await方法阻塞等待
                notFull.await();
        } catch (InterruptedException ie) {
            notFull.signal(); // propagate to non-interrupted thread
            throw ie;
        }
        //队列未满则插入
        insert(e);
    } finally {
        //释放锁
        lock.unlock();
    }
}

        put方法与其他方法类似，其中会循环判断队列是否已满，如果已满则阻塞 notFull，如果未满则调用 insert方法添加元素。因为其中运用了循环判断队列是否有位置添加新元素，如果队列已满则产生阻塞等待，直至可以添加元素为止。

        将本文开始时的例子修改一下，去掉消费者，只留下生产者，这样当队列满了之后没有消费者去消费产品，生产者就不会再向队列中插入了：

class Producer implements Runnable {
    private final ArrayBlockingQueue<Integer> queue;
    private int i;

    Producer(ArrayBlockingQueue<Integer> q) {
        queue = q;
    }

    public void run() {
        try {
            while (true) {
                int p=produce();
                queue.put(p);// 将产品放入缓冲队列
                System.out.println("插入成功:"+p);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    int produce() {
        return i++;// 生产产品
    }
}

public class Runner {
    public static void main(String[] args) {
        ArrayBlockingQueue<Integer> q = new ArrayBlockingQueue<Integer>(10);
        Producer p = new Producer(q);
        new Thread(p).start();
    }
}
//结果：
插入成功:0
插入成功:1
插入成功:2
插入成功:3
插入成功:4
插入成功:5
插入成功:6
插入成功:7
插入成功:8
插入成功:9

        此时程序并不会退出，而是阻塞在那里等待队列有位置插入。

        4.获取元素

        1）peek方法

        获取但不移除此队列的头；如果此队列为空，则返回 null。以下是peek方法的源代码：

/**
 * 获取但不移除此队列的头；如果此队列为空，则返回 null
 */
public E peek() {
    final ReentrantLock lock = this.lock;
    //获取锁
    lock.lock();
    try {
        //判断队列中是否有元素，如果没有则返回null，如果存在则返回该元素
        return (count == 0) ? null : items[takeIndex];
    } finally {
        //释放锁
        lock.unlock();
    }
}

        peek代码比较简单，首先判断队列是否有元素，即count==0，如果为空则返回null，非空则返回相应元素。

        2）poll方法

        获取并移除此队列的头，如果此队列为空，则返回 null。以下是poll方法的源代码：

/**
 * 获取并移除此队列的头，如果此队列为空，则返回 null
 */
public E poll() {
    final ReentrantLock lock = this.lock;
    //获取锁
    lock.lock();
    try {
        //判断是否存在元素
        if (count == 0)
            return null;
        //调用extract方法返回元素
        E x = extract();
        return x;
    } finally {
        //释放锁
        lock.unlock();
    }
}

        poll方法调用的是 extract()方法来获取头元素。

        3）extract方法

        以下是extract()方法的源代码：

/**
 * 从 takeIndex位置获取元素（在获得锁的情况下调用）
 */
private E extract() {
    final E[] items = this.items;
    //获取元素
    E x = items[takeIndex];
    //移除原位置元素
    items[takeIndex] = null;
    //计算 takeIndex新值
    takeIndex = inc(takeIndex);
    --count;
    //唤醒添加线程
    notFull.signal();
    return x;
}

        4）take方法

        获取并移除此队列的头部，在元素变得可用之前一直等待（如果有必要）。

/**
 * 获取并移除此队列的头部，在元素变得可用之前一直等待（如果有必要）
 */
public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    // 获取中断锁
    lock.lockInterruptibly();
    try {
        try {
            // 如果队列未空则阻塞等待，直到有元素为止
            while (count == 0)
                notEmpty.await();
        } catch (InterruptedException ie) {
            notEmpty.signal(); // 唤醒获取线程
            throw ie;
        }
        // 调用extract方法返回元素
        E x = extract();
        return x;
    } finally {
        // 释放锁
        lock.unlock();
    }
}

        与put方法类似，take方法也是利用循环阻塞的方式来获取元素，如果没有元素则等待，直至获取元素为止。

        与put方法的例子类似，生产者只生产5个产品，消费完这5个产品后，消费者就不得不等待队列有元素可取：

class Producer implements Runnable {
    private final ArrayBlockingQueue<Integer> queue;
    private int i;

    Producer(ArrayBlockingQueue<Integer> q) {
        queue = q;
    }

    public void run() {
        try {
            for (int i = 0; i < 5; i++) {
                int p = produce();
                queue.put(p);// 将产品放入缓冲队列
                System.out.println("插入成功:" + p);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    int produce() {
        return i++;// 生产产品
    }
}

class Consumer implements Runnable {
    private final ArrayBlockingQueue<Integer> queue;

    Consumer(ArrayBlockingQueue<Integer> q) {
        queue = q;
    }

    public void run() {
        try {
            while (true) {
                int p = queue.take();
                System.out.println("获取成功:" + p);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    void consume(Object x) {
        System.out.println("消费：" + x);// 消费产品
    }
}

public class Runner {
    public static void main(String[] args) {
        ArrayBlockingQueue<Integer> q = new ArrayBlockingQueue<Integer>(10);// 或其他实现
        Producer p = new Producer(q);
        Consumer c1 = new Consumer(q);
        Consumer c2 = new Consumer(q);
        new Thread(p).start();
        new Thread(c1).start();
        new Thread(c2).start();
    }
}
//结果：
插入成功:0
插入成功:1
插入成功:2
插入成功:3
插入成功:4
获取成功:0
获取成功:1
获取成功:2
获取成功:3
获取成功:4

        之后程序也是会阻塞在那里。

        5.移除元素

        1）remove方法

        remove方法从此队列中移除指定元素的单个实例（如果存在）。更确切地讲，如果此队列包含一个或多个满足 o.equals(e) 的元素 e，则移除该元素。如果此队列包含指定的元素（或者此队列由于调用而发生更改），则返回 true。 

/**
 * 从此队列中移除指定元素的单个实例（如果存在）
 */
public boolean remove(Object o) {
    //判断要移除元素是否为空
    if (o == null)
        return false;
    final E[] items = this.items;
    final ReentrantLock lock = this.lock;
    //获取锁
    lock.lock();
    try {
        int i = takeIndex;
        int k = 0;
        for (;;) {
            //判断队列是否含有元素
            if (k++ >= count)
                return false;
            //比较
            if (o.equals(items[i])) {
                //移除
                removeAt(i);
                return true;
            }
            //返回i新值，以便下次循环使用
            i = inc(i);
        }

    } finally {
        //释放锁
        lock.unlock();
    }
}

        remove方法其中利用循环来不断判断该元素的位置，如果找到则调用 removeAt方法移除指定位置的数组元素。

        以下是一个移除的小例子：

ArrayBlockingQueue<Integer> q = new ArrayBlockingQueue<Integer>(10);
// 添加10个元素
for (int i = 0; i < 10; i++) {
    q.add(i);
}
// 移除值为 1,3,5,7,9 的这五个元素
q.remove(1);
q.remove(3);
q.remove(5);
q.remove(7);
q.remove(9);
//又移除了一次 9
q.remove(9);
for (Integer i : q) {
    System.out.println(i);
}
//结果:
0
2
4
6
8

        从结果可以看出，从队列中正确的移除了我们指定的元素，在最后即使指定已经不存在的元素值，remove方法也之后返回false。

        2）drainTo方法

        drainTo方法用于移除此队列中所有可用的元素，并将它们添加到给定 collection 中。此操作可能比反复轮询此队列更有效。在试图向 collection c 中添加元素没有成功时，可能导致在抛出相关异常时，元素会同时在两个 collection 中出现，或者在其中一个 collection 中出现，也可能在两个 collection 中都不出现。如果试图将一个队列放入自身队列中，则会导致 IllegalArgumentException 异常。此外，如果正在进行此操作时修改指定的 collection，则此操作行为是不确定的。 

        以下是 drainTo方法的源代码：

public int drainTo(Collection<? super E> c) {
    //如果指定 collection为 null 抛出异常
    if (c == null)
        throw new NullPointerException();
    //如果指定 collection 是此队列，或者此队列元素的某些属性不允许将其添加到指定 collection 抛出异常
    if (c == this)
        throw new IllegalArgumentException();
    final E[] items = this.items;
    final ReentrantLock lock = this.lock;
    //获取锁
    lock.lock();
    try {
        //take操作的位置
        int i = takeIndex;
        int n = 0;
        //元素数量
        int max = count;
        //利用循环不断取出元素添加到c中
        while (n < max) {
            c.add(items[i]);
            items[i] = null;
            i = inc(i);
            ++n;
        }
        //添加完成后初始化必要值，唤醒添加线程
        if (n > 0) {
            count = 0;
            putIndex = 0;
            takeIndex = 0;
            notFull.signalAll();
        }
        //返回添加元素数量
        return n;
    } finally {
        //释放锁
        lock.unlock();
    }
}

        代码中并没有添加失败的相关处理，所以结果如上所说并不一定完整。以下是相关实例：

ArrayBlockingQueue<Integer> q = new ArrayBlockingQueue<Integer>(10);
List<Integer> list = new ArrayList<Integer>();
// 添加10个元素
for (int i = 0; i < 10; i++) {
    q.add(i);
    list.add(i + 10);
}
//将q中的元素添加到 list中
q.drainTo(list);
for (Integer i : list) {
    System.out.println(i);
}
//结果：
10
11
12
13
14
15
16
17
18
19
0
1
2
3
4
5
6
7
8
9

        需要值得注意的是 drainTo方法是将队列中的元素按顺序添加到指定 Collection中，别弄反了。

        drainTo(Collection<? super E> c, int maxElements)用法类似，只不过指定了移除元素数。

        3）clear方法

        移除此队列中的所有元素。在此调用返回之后，队列将为空。

/**
 * 移除此队列中的所有元素。在此调用返回之后，队列将为空
 */
public void clear() {
    final E[] items = this.items;
    final ReentrantLock lock = this.lock;
    //获取锁
    lock.lock();
    try {
        int i = takeIndex;
        int k = count;
        //将数组元素置为null
        while (k-- > 0) {
            items[i] = null;
            i = inc(i);
        }
        //初始化其他参数
        count = 0;
        putIndex = 0;
        takeIndex = 0;
        //唤醒添加线程
        notFull.signalAll();
    } finally {
        //释放锁
        lock.unlock();
    }
}

        clear方法比较简单，就是利用循环清除数组中的元素，然后将相关参数置为初始值。

        ArrayBlockingQueue还有一些其他方法，这些方法相对简单这里就不细说了。