BlockingQueue - 阻塞队列

定义

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

1. 常用方法

抛出异常：如果操作无法立即执行，则会抛出异常。当阻塞队列满的时候，再往队里里插入元素，会抛出 Queue full 异常。当队列为空时，从队列里获取元素会抛出 NoSuchElementException 异常。
返回特殊值：如果插入、删除操作成功，那么会返回结果：true、false。
一直阻塞：当队列满时，执行 put 增加操作那么会阻塞；当队列为空时，执行take 移除操作，那么也会阻塞。
超时退出：在 offer、poll 操作时，可以设置超时的属性，例如超时的时间、时间单位。如果在给定的时间内没有能够执行完成，那么就会返回true、false标识操作执行的状态。

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

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

2. 具体实现类

ArrayBlockingQueue

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

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

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

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

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

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

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

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

实现原理

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

构造方法

// 数组初始容量大小，
// 公平锁的方法，默认是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();
}

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 元素进行入队操作，唤醒一个消费者线程。

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() 返回出队元素，最后唤醒一个生产者线程。

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

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

BlockingQueue - 阻塞队列

BlockingQueue - 阻塞队列

定义

1. 常用方法

2. 具体实现类

实现原理

猜你喜欢