Java 集合框架系列（五）：Queue 接口及其实现类

Queue 队列，也是 Collection 的一个重要分支，是一个先进先出的数据结构，其一个重要的子接口为BlockingQueue（阻塞队列），阻塞队列在多线程的场景中有着广泛的应用，平时用的队列可以直接使用 LinkedList 来使用。

阻塞队列

阻塞队列中的阻塞意为等待，与非阻塞队列相比的话有如下的不同点：

1. 入队：

• 非阻塞队列：当队列满的时候，放入新的元素时，数据丢失。
• 阻塞队列：当队列满的时候，放入新的元素时，线程阻塞等待，等待队列中有出队的元素，再继续运行放进去。

2. 出队：

• 非阻塞队列：当队列没有元素的时候，取数据时得到的是null。
• 阻塞队列：当队列没有元素的时候，取数据时，线程阻塞等待，什么时候有元素入队了，才可以继续运行取出元素。

常用 API

1. 添加元素

 // 不能添加 null，成功时返回 true，不成功时抛出 Queue Full 异常
public boolean add(E, e);
 // 不能添加null，成功时返回true，不成功时返回false
public boolean offer(E, e);
// 队列满的时候阻塞队列
public void put(E e); 

2. 查询

// 获取并移除此队列的头部，在元素变得可用之前一直等待
public E take(); 
// 获取并移除此队列的头部，在指定时间内等待可用的元素
public E poll(long time, TimeUnit unit); 
// 获取队列的头部，不移除 
public E peek(); 

BlockingQueue 的常见实现类

ArrayBlockingQueue

ArrayBlockingQueue 底层是一个基于数组的有边界的阻塞队列，其只用了一把锁来同时阻塞读写操作，读写不分离。

1. 类的定义和关键字段

 public class ArrayBlockingQueue<E> extends AbstractQueue<E>
         implements BlockingQueue<E>, java.io.Serializable {
   
     // 底层使用数组保存数据
     final Object[] items;
     // 取元素时用到的索引，初始为0
     int takeIndex;
     // 放元素时用到的索引，初始为0
     int putIndex;
     // 数组中元素的个数
     int count;
     // 可重入锁，用于出队和入队等操作中
     final ReentrantLock lock;
     // lock伴随的一个不为空的等待池，当队列有数据时会唤醒在该等待队列中的线程获取数据
     private final Condition notEmpty;
     // lock伴随的一个队列不满的等待池，当队列中还没有满时会唤醒在该等待队列中的线程往队列        添加数据
     private final Condition notFull;
     
     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();
     }
 }

2. 入队

// 添加元素
 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();
     }
 }
 // 入队
 private void enqueue(E x) {
   
     final Object[] items = this.items;
     // 将x放入putIndex索引指向的位置
     items[putIndex] = x;
     if (++putIndex == items.length)
         // 循环数组的作用，可以不断的利用底层数组存放数据
         putIndex = 0;
     // 元素个数+1
     count++;
     // 添加一个元素则证明底层数组有数据了，唤醒在空队列的等待池中阻塞的线程取出数据，即唤醒take方法的阻塞
     notEmpty.signal();
 }

3. 出队

 // 取出元素
 public E take() throws InterruptedException {
   
     final ReentrantLock lock = this.lock;
     lock.lockInterruptibly();
     try {
   
         while (count == 0)
             // 如果没有元素的话，则会将当前线程放入非空等待池中阻塞
             notEmpty.await();
         return dequeue