BlockingQueue - 阻塞队列

BlockingQueue - 阻塞队列

定义

BlockingQueue 一般用于生产者-消费者模式，生产者是往队列里添加元素的线程，消费者是从队列里拿元素的线程。BlockingQueue 就是存放元素的容器。

1. 常用方法

• 抛出异常：如果操作无法立即执行，则会抛出异常。当阻塞队列满的时候，再往队里里插入元素，会抛出 Queue full 异常。当队列为空时，从队列里获取元素会抛出 NoSuchElementException 异常。

• 返回特殊值：如果插入、删除操作成功，那么会返回结果：true、false。

• 一直阻塞：当队列满时，执行 put 增加操作那么会阻塞；当队列为空时，执行take 移除操作，那么也会阻塞。

• 超时退出：在 offer、poll 操作时，可以设置超时的属性，例如超时的时间、时间单位。如果在给定的时间内没有能够执行完成，那么就会返回true、false标识操作执行的状态。

不能往阻塞队列中插入 null，会抛出空指针异常。

可以访问阻塞队列中的任意元素，调用 remove(o)可以将队列之中的特定对象移除，但并不高效。

2. 具体实现类

1. ArrayBlockingQueue

   由数组结构组成的有界阻塞队列，初始化时必须指定容量大小，默认采用的是unfair 锁。

2. LinkedBlockingQueue

   由链表结构组成的有界阻塞队列，具有链表的特性。默认的队列的大小是Integer.MAX_VALUE，也可以指定大小。

3. DelayQueue

   延时队列，该队列中的元素只有当其指定的延迟时间到了，才能够从队列中获取到该元素。其中的元素必须实现 Delayed接口，内部是一个优先级队列，没有大小限制的队列，所以 take 和 put 操作永远不会阻塞，以为内部都是调用 poll 和 offer。

4. PriorityBlockingQueue

   基于优先级的无界队列，优先级通过判断传入构造参数中的 Compator 对象决定。因为是无界的，所以不会阻塞生产者put，但是当队列中容量为空时，则会阻塞消费者 take 操作。

5. SynchronousQueue

   内部没有任何容量，每个put操作必须等待一个take操作。内部的实现其实是TransferQueue（公平模式下），TransferStack（非公平模式下）, 直接使用CAS实现线程的安全访问。当它生产产品（即put的时候），如果当前没有人想要消费产品(即当前没有线程执行take)，此生产线程必须阻塞，等待一个消费线程调用take操作，take操作将会唤醒该生产线程，同时消费线程会获取生产线程的产品（即数据传递），这样的一个过程称为一次配对过程(当然也可以先take后put,原理是一样的)。

   公平模式下，总结下来就是：队尾匹配队头出队，先进先出，体现公平原则。

   非公平模式下，总结下来就是：栈顶匹配栈顶出栈，先进后出，体现非公平原则。

生产者生产数据的速度绝对不能快于消费者消费数据的速度，否则时间一长，则会耗尽所有的可用堆内存空间。

 

实现原理

下面就详细讲解下ArrayBlockingQueue的实现原理，主要是利用了 Lock 锁的多条件（Condition）阻塞控制。

1. 构造方法

   // 数组初始容量大小，
   // 公平锁的方法，默认是false 非公平锁
   // notEmpty：标记为消费者条件
   // notFull： 标记为生产者条件
   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. put

   /**
    * 插入元素到队列中，如果队列满了，那么就会等待队列可用时
    * @throws InterruptedException {@inheritDoc}
    * @throws NullPointerException {@inheritDoc}
    */
   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) {
       // 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();
   }

   总结 put 流程：

   • 所有执行 put 操作的线程竞争 lock 锁，拿到了 lock 锁的线程进入下一步，没有拿到 lock 锁的线程自旋竞争锁。

   • 判断阻塞队列是否满了，如果满了，则阻塞生产者线程继续生产。同时释放 lock 锁，等待被消费者线程唤醒。

   • 如果没有满，调用 enqueue(E x) 使得 x 元素进行入队操作，唤醒一个消费者线程。

3. take

   // 获取队列元素
   public E take() throws InterruptedException {
       final ReentrantLock lock = this.lock;
       // 获取全局锁
       lock.lockInterruptibly();
       try {
           // 当队列为空，阻塞消费者线程获取元素
           while (count == 0)
               notEmpty.await();
           // 队列不为空，返回出队元素
           return dequeue();
       } finally {
           lock.unlock();
       }
   }
   ​
   // 出队，先进先出
   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;
   }

   总结 take 操作：

   • 所有执行 take 操作的线程竞争 lock 锁，没有拿到全局锁，则会自旋竞争锁。

   • 判断队列是否为空，如果为空，则阻塞消费者线程获取元素。

   • 如果不为空，调用 dequeue() 返回出队元素，最后唤醒一个生产者线程。

   1. put 和 take 操作都是需要先获取锁。

   2. 拿到锁后，还要查看队列状态，是否满足入队、出队条件。