高并发编程之ArrayBlockingQueue讲解

一、ArrayBlockingQueue介绍
ArrayBlockingQueue：是一个用数组实现的有界阻塞队列，此队列按照先进先出（FIFO）的原则对元素进行排序。支持公平锁和非公平锁。【注：每一个线程在获取锁的时候可能都会排队等待，如果在等待时间上，先获取锁的线程的请求一定先被满足，那么这个锁就是公平的。反之，这个锁就是不公平的。公平的获取锁，也就是当前等待时间最长的线程先获取锁】

二、ArrayBlockingQueue常用方法介绍
1、add(E e) ： 将指定的元素插入到此队列的尾部（如果立即可行且不会超过该队列的容量），在成功时返回 true，如果此队列已满，则抛出 IllegalStateException。

2、clear() ：自动移除此队列中的所有元素。

3、contains(Object o) ：如果此队列包含指定的元素，则返回 true。

4、iterator() ： 返回在此队列中的元素上按适当顺序进行迭代的迭代器，返回值为Iterator。

5、offer(E e) ：将指定的元素插入到此队列的尾部（如果立即可行且不会超过该队列的容量），在成功时返回 true，如果此队列已满，则返回 false。

6、offer(E e, long timeout, TimeUnit unit) ： 将指定的元素插入此队列的尾部，如果该队列已满，则在到达指定的等待时间之前等待可用的空间。返回值为Boolean。

7、 peek() ：获取但不移除此队列的头；如果此队列为空，则返回 null。
8、 poll() ：获取并移除此队列的头，如果此队列为空，则返回 null。

9、 poll(long timeout, TimeUnit unit) ：获取并移除此队列的头部，在指定的等待时间前等待可用的元素（如果有必要）。
put(E e) ：将指定的元素插入此队列的尾部，如果该队列已满，则等待可用的空间。

10、remove(Object o) ：从此队列中移除指定元素的单个实例（如果存在）。返回值为Boolean。

11、size() ：返回此队列中元素的数量。

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

13、toArray() ：返回一个按适当顺序包含此队列中所有元素的数组。

14、toString() ：返回此 collection 的字符串表示形式。返回值为String。

三、下面是对ArrayBlockingQueue的一些方法写的一些代码示例

package chapter3.arrayblockingqueue;

import java.util.Iterator;
import java.util.concurrent.ArrayBlockingQueue;

/**
 * @author czd
 */
public class ArrayBlockingQueueTest {


    public static void main(String[] args) {
        /**
         * 1、ArrayBlockingQueue(int capacity)：
         *    创建一个带有给定的（固定）容量
         * 和 默认访问策略的 ArrayBlockingQueue。（不公平的锁）
         * 2、ArrayBlockingQueue(int capacity, boolean fair)
         *    创建一个具有给定的（固定）容量
         * 和  指定访问策略的 ArrayBlockingQueue（true:公平的锁  false:不公平的锁）
         */

        //1、add(E e)：将指定的元素插入到此队列的尾部（如果立即可行且不会超过该队列的容量），在成功时返回 true，如果此队列已满，则抛出
        ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue(5);
        Boolean addBoolean = arrayBlockingQueue.add(5);
        System.out.println("是否添加成功: " + addBoolean);

        //2、peek()：获取但不移除此队列的头；如果此队列为空，则返回 null。
        Integer peekResult = arrayBlockingQueue.peek();
        System.out.println("peekResult: " + peekResult);

        /**
         * 3.1、poll()：获取并移除此队列的头，如果此队列为空，则返回 null。
         * 3.2、poll(long timeout, TimeUnit unit)：获取并移除此队列的头部，在指定的等待时间前等待可用的元素（如果有必要）。
         */

        Integer pollResult = arrayBlockingQueue.poll();
        System.out.println("pollResult: " + pollResult);
        Integer afterPollResult = arrayBlockingQueue.poll();
        System.out.println("poll后的结果: " + afterPollResult);

        //4、put(E e)：将指定的元素插入此队列的尾部，如果该队列已满，则等待可用的空间,无返回值
        try {
            arrayBlockingQueue.put(6);
            System.out.println("put后：" + arrayBlockingQueue.peek());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        /**
         * 5.1offer(E e) ：将指定的元素插入到此队列的尾部（如果立即可行且不会超过该队列的容量）
         *                 在成功时返回 true，如果此队列已满，则返回 false,返回值为Boolean。
         *
         * 5.2 offer(E e, long timeout, TimeUnit unit)：将指定的元素插入此队列的尾部，
         *                 如果该队列已满，则在到达指定的等待时间之前等待可用的空间,返回值为Boolean。
         */
        Boolean offerBoolean = arrayBlockingQueue.offer(7);
        System.out.println("是否成功offer: " + offerBoolean);

        //6、remove(Objec8t o): 从此队列中移除指定元素的单个实例（如果存在）。返回值为Boolean
        Boolean remove8Boolean = arrayBlockingQueue.remove(8);
        System.out.println("移除8是否成功：" + remove8Boolean);
        Boolean remove7Boolean = arrayBlockingQueue.remove(7);
        System.out.println("移除7是否成功：" + remove7Boolean);

        //7、size()：返回此队列中元素的数量。
        int sizeQueue = arrayBlockingQueue.size();
        System.out.println("arrayBlockingQueue.size = " + sizeQueue);

        //8、contains(Object o) 如果此队列包含指定的元素，则返回 true。
        Boolean containsBoolean = arrayBlockingQueue.contains(9);
        System.out.println("arrayBlockingQueue是否包含9: " + containsBoolean);

        //9、iterator() 返回在此队列中的元素上按适当顺序进行迭代的迭代器，返回值为Iterator
        Iterator iterator = arrayBlockingQueue.iterator();
        while (iterator.hasNext()){
            Integer result = iterator.next();
            System.out.println("iterator的结果result: " + result);
        }

        //11、take()：获取并移除此队列的头部，在元素变得可用之前一直等待（如果有必要）。
        try {
            Integer takeResult = arrayBlockingQueue.take();
            System.out.println("takeResult: " + takeResult);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        //11、clear()：自动移除此队列中的所有元素。
        arrayBlockingQueue.clear();
        System.out.println("看一下是否还存在元素：" + arrayBlockingQueue.peek());

    }
}

如果想对ArrayBlockingQueue更加深入的了解的话，可以打开JavaAPI*（http://tool.oschina.net/apidocs/apidoc?api=jdk-zh）查找ArrayBlockingQueue详细去了解ArrayBlockingQueue的所有方法***