阻塞队列BlockingQueue
文章目录
- 阻塞队列BlockingQueue
-
- 队列
- 阻塞队列
- ArrayBlockingQueue
-
- 简介
- 实现原理
- LinkedBlockingQueue
-
- 简介
- 实现原理
- DelayQueue
-
- 简介
- 使用
- 原理
- 如何选择适合的阻塞队列
-
- 选择策略
- 线程池对于阻塞队列的选择
阻塞队列BlockingQueue
队列
先进先出的数据结构，允许出队的一端称为队头，允许入队的一端称为队尾。
在java中为队列定义了一个接口规范Queue接口
public interface Queue<E> extends Collection<E> {
//添加一个元素，添加成功返回true, 如果队列满了，就会抛出异常
boolean add(E e);
//添加一个元素，添加成功返回true, 如果队列满了，返回false
boolean offer(E e);
//返回并删除队首元素，队列为空则抛出异常
E remove();
//返回并删除队首元素，队列为空则返回null
E poll();
//返回队首元素，但不移除，队列为空则抛出异常
E element();
//获取队首元素，但不移除，队列为空则返回null
E peek();
}
阻塞队列
阻塞队列提供了线程安全的队列访问方式。多线程入队互斥，多线程出队互斥，队列满了阻塞生产者线程，队列空了阻塞消费者线程
阻塞队列的接口BlockingQueue 它继承了 Queue接口。并在原有Queue接口定义的方法规范下，再新增了两个关于阻塞的方法规范。
public interface BlockingQueue<E> extends Queue<E> {
// 阻塞方式 入队
void put(E e) throws InterruptedException;
// 阻塞方式 出队
E take() throws InterruptedException;
......
}
| 方法 | 抛出异常 | 返回特定值 | 阻塞 | 阻塞特定时间 |
|---|---|---|---|---|
| 入队 | add(e) | offer(e) | put(e) | offer(e, time, unit) |
| 出队 | remove() | poll() | take() | poll(time, unit) |
| 获取队首元素 | element() | peek() | 不支持 | 不支持 |
阻塞队列的应用场景
- 线程池
- 生产者-消费者模型
- 消息队列
- 缓存系统
- 并发任务处理
BlockingQueue 接口的实现类都被放在了 juc 包中，它们的区别主要体现在存储结构上或对元素操作上的不同，但是对于take与put操作的原理却是类似的。
| 队列 | 描述 |
|---|---|
| ArrayBlockingQueue | 基于数组结构实现的一个有界阻塞队列 |
| LinkedBlockingQueue | 基于链表结构实现的一个无界阻塞队列，指定容量为有界阻塞队列 |
| PriorityBlockingQueue | 支持按优先级排序的无界阻塞队列 |
| DelayQueue | 基于优先级队列（PriorityBlockingQueue）实现的无界阻塞队列 |
| SynchronousQueue | 不存储元素的阻塞队列 |
| LinkedTransferQueue | 基于链表结构实现的一个无界阻塞队列 |
| LinkedBlockingDeque | 基于链表结构实现的一个双端阻塞队列 |
详情
ArrayBlockingQueue
简介
ArrayBlockingQueue它队列使用的数据结构是双指针的环形数组，入队出队是基于生产者消费者模型实现的，它入队和出队使用的是同一把锁。
基本使用
BlockingQueue queue = new ArrayBlockingQueue(1024);
queue.put("1"); //向队列中添加元素
Object object = queue.take(); //从队列中取出元素
其实ava.util.concurrent.locks.Condition接口的注释中 给出的案例就和ArrayBlockingQueue的实现很相似，如下所示使用一个环形数组实现生产者消费者模式：
class BoundedBuffer {
final Lock lock = new ReentrantLock();
final Condition notFull = lock.newCondition();
final Condition notEmpty = lock.newCondition();
final Object[] items = new Object[100];
int putptr, takeptr, count;
// 生产者，把方法的入参往队列中存，队列是一个环形数组
public void put(Object x) throws InterruptedException {
lock.lock();
try {
// 队列放满了生产者就阻塞
while (count == items.length)
notFull.await();
// 往队列存数据
items[putptr] = x;
if (++putptr == items.length) putptr = 0;
// 队列中新存值了，要通知消费者开始消费了
++count;
notEmpty.signal();
} finally {
lock.unlock();
}
}
// 消费者，从队列中取
public Object take() throws InterruptedException {
lock.lock();
try {
// 队列空了，消费者就阻塞
while (count == 0)
notEmpty.await();
// 从队列中取值
Object x = items[takeptr];
if (++takeptr == items.length) takeptr = 0;
// 已经消费了，队列现在不是满的了，唤醒生产者进行生产
--count;
notFull.signal();
return x;
} finally {
lock.unlock();
}
}
}
实现原理
接下来具体来看ArrayBlockingQueue它的实现，首先是定义的属性如下：
public class ArrayBlockingQueue<E> extends AbstractQueue<E> implements BlockingQueue<E>, java.io.Serializable {
private static final long serialVersionUID = -817911632652898426L;
/** 队列 使用的是数组 */
final Object[] items;
/** 对头位置 出队的数组下标索引 */
int takeIndex;
/** 队尾位置 入队的数组下标索引 */
int putIndex;
/** 数组中目前未消费元素的个数 */
int count;
/** 入队与出队共用同一把锁 */
final ReentrantLock lock;
/** 如果队列空了 那么消费者就阻塞 等生产者生产数据了才唤醒 */
private final Condition notEmpty;
/** 如果队列满了 那么生产者就阻塞 等消费者消费数据了才唤醒 */
private final Condition notFull;
......
}
接下来是生产者 入队操作
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();
}
}
入队enqueue()方法
private void enqueue(E x) {
// 根据putIndex队尾的下标 进行赋值
final Object[] items = this.items;
items[putIndex] = x;
// 如果要入队的索引和数组长度相等了 那么就赋值为0
if (++putIndex == items.length)
putIndex = 0;
// 未消费数据的个数自增，并唤醒消费者线程
count++;
notEmpty.signal();
}
接下来是消费者 出队操作
public E take() throws InterruptedException {
// 和入队时加的是同一把锁
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
// 如果没有未消费的数据，那么消费者就阻塞
while (count == 0)
notEmpty.await();
// count如果不为0 则调用的dequeue()方法进行出队操作
return dequeue();
} finally {
lock.unlock();
}
}
出队dequeue()方法
private E dequeue() {
// 根据takeIndex出队下标 直接读取元素。然后把数组当前出队位置至null
final Object[] items = this.items;
E x = (E) items[takeIndex];
items[takeIndex] = null;
// takeIndex出队下标 到数组尽头了，返回头部 这是环形数组的实现
if (++takeIndex == items.length)
takeIndex = 0;
// 未消费数据个数自减
count--;
if (itrs != null)
itrs.elementDequeued();
// 唤醒生产者
notFull.signal();
return x;
}
LinkedBlockingQueue
简介
LinkedBlockingQueue的队列实现是采用的链表实现的，基本用法和上面一致，区别如下：
-
队列大小不一样，ArrayBlockingQueue必须指定队列长度，LinkedBlockingQueue有默认队列最大长度
-
LinkedBlockingQueue中的count是使用的原子类
-
LinkedBlockingQueue入队和出队有各自的锁对象，删除元素时就要获取两把锁。
-
因为是链表实现，比上面数组实现更占内存，但是并发场景下比ArrayBlockingQueue快，因为入队和出队不是使用的同一把锁
基本用法
//指定队列的大小创建有界队列
BlockingQueue<Integer> boundedQueue = new LinkedBlockingQueue<>(100);
//无界队列，
BlockingQueue<Integer> unboundedQueue = new LinkedBlockingQueue<>();
实现原理
LinkedBlockingQueue的基本属性
public class LinkedBlockingQueue<E> extends AbstractQueue<E> implements BlockingQueue<E>, java.io.Serializable {
private static final long serialVersionUID = -6903933977591709194L;
/**
* 链表 节点内部类
*/
static class Node<E> {
// 元素
E item;
// 下一个节点指针
Node<E> next;
Node(E x) { item = x; }
}
/** 链表的最大节点数，默认是2^32-1 */
private final int capacity;
/** 队列中未消费元素的个数 */
private final AtomicInteger count = new AtomicInteger();
/**
* 链表头节点指针，出队用它
* Invariant: head.item == null
*/
transient Node<E> head;
/**
* 链表尾节点指针，入队用它
* Invariant: last.next == null
*/
private transient Node<E> last;
/** 出队的锁对象 */
private final ReentrantLock takeLock = new ReentrantLock();
/** 队列空了那么就阻塞消费者线程 */
private final Condition notEmpty = takeLock.newCondition();
/** 入队的锁对象 */
private final ReentrantLock putLock = new ReentrantLock();
/** 队列满了那么就阻塞生产者线程 */
private final Condition notFull = putLock.newCondition();
......
}
构造方法
public LinkedBlockingQueue() {
// 如果没传容量，就使用最大int值初始化其容量
this(Integer.MAX_VALUE);
}
// 建议创建LinkedBlockingQueue时自己指定最大容量
public LinkedBlockingQueue(int capacity) {
if (capacity <= 0) throw new IllegalArgumentException();
this.capacity = capacity;
// 初始化head和last指针为空值节点
last = head = new Node<E>(null);
}
入队
public void put(E e) throws InterruptedException {
if (e == null) throw new NullPointerException();
int c = -1;
// 新元素，创建一个Node实例对象
Node<E> node = new Node<E>(e);
// 加锁 加入队的锁putLock
final ReentrantLock putLock = this.putLock;
final AtomicInteger count = this.count;
putLock.lockInterruptibly();
try {
// 如果队列满了 生产者线程阻塞
while (count.get() == capacity) {
notFull.await();
}
// 入队
enqueue(node);
// 入队完成后 如果队列还没满 那么也唤醒生产者线程
// 原因是因为可能有多个生产者线程阻塞在这个位置，消费者只有等到队列满了才唤醒生产者线程，此处不用等到取元素时才唤醒
c = count.getAndIncrement(); // 这里是先获取再自增
if (c + 1 < capacity)
notFull.signal();
} finally {
putLock.unlock();
}
// 如果原队列长度为0，现在加了一个元素后立即唤醒阻塞在notEmpty上的线程
if (c == 0)
signalNotEmpty();
}
// 具体入队操作就只是修改链表指针
private void enqueue(Node<E> node) {
last = last.next = node;
}
出队
public E take() throws InterruptedException {
E x;
int c = -1;
// 加锁 出队的锁takeLock
final AtomicInteger count = this.count;
final ReentrantLock takeLock = this.takeLock;
takeLock.lockInterruptibly();
try {
// 如果队列空了 那么就阻塞消费者线程
while (count.get() == 0) {
notEmpty.await();
}
// 出队
x = dequeue();
// 如果消费后 队列中还有元素那也唤醒一次消费者线程
c = count.getAndDecrement();
if (c > 1)
notEmpty.signal();
} finally {
takeLock.unlock();
}
// 队列满了才 唤醒生产者线程
// 原因是唤醒生产者是需要加putLock锁的，为了减少锁的次数，所以才在消费前队列满了才去唤醒生产者线程
// 锁分离后带来的代价，不能每一次消费完都去获取putLock 去唤醒生产者
if (c == capacity)
signalNotFull();
return x;
}
// head头节点不存储数据，取head.next.item的值返回，然后改变head指针的位置
private E dequeue() {
Node<E> h = head;
Node<E> first = h.next;
h.next = h;
head = first;
E x = first.item;
first.item = null;
return x;
}
DelayQueue
简介
DelayQueue 是一个支持延时获取元素的阻塞队列， 内部采用优先队列 PriorityQueue 存储元素，同时元素必须实现 Delayed 接口
创建元素时可以指定多久才可以从队列中获取当前元素，只有在延迟期满时才能从队列中提取元素。
延迟队列的特点是：不是先进先出，而是会按照延迟时间的长短来排序，下一个即将执行的任务会排到队列的最前面。
它是无界队列，放入的元素必须实现 Delayed 接口，而 Delayed 接口又继承了 Comparable 接口，所以自然就拥有了比较和排序的能力，代码如下：
public interface Delayed extends Comparable<Delayed> {
//getDelay 方法返回的是“还剩下多长的延迟时间才会被执行”，
//如果返回 0 或者负数则代表任务已过期。
//元素会根据延迟时间的长短被放到队列的不同位置，越靠近队列头代表越早过期。
long getDelay(TimeUnit unit);
}
最小堆数据结构演示
使用
延迟订单的案例
public class DelayQueueExample {
public static void main(String[] args) throws InterruptedException {
DelayQueue<Order> delayQueue = new DelayQueue<>();
// 添加三个订单，分别延迟 5 秒、2 秒和 3 秒
delayQueue.put(new Order("order1", System.currentTimeMillis(), 5000));
delayQueue.put(new Order("order2", System.currentTimeMillis(), 2000));
delayQueue.put(new Order("order3", System.currentTimeMillis(), 3000));
// 循环取出订单，直到所有订单都被处理完毕
while (!delayQueue.isEmpty()) {
Order order = delayQueue.take();
System.out.println("处理订单：" + order.getOrderId());
}
}
static class Order implements Delayed{
private String orderId;
private long createTime;
private long delayTime;
public Order(String orderId, long createTime, long delayTime) {
this.orderId = orderId;
this.createTime = createTime;
this.delayTime = delayTime;
}
public String getOrderId() {
return orderId;
}
@Override
public long getDelay(TimeUnit unit) {
long diff = createTime + delayTime - System.currentTimeMillis();
return unit.convert(diff, TimeUnit.MILLISECONDS);
}
@Override
public int compareTo(Delayed o) {
long diff = this.getDelay(TimeUnit.MILLISECONDS) - o.getDelay(TimeUnit.MILLISECONDS);
return Long.compare(diff, 0);
}
}
}
当指定订单的延迟时间到了之后才会从队列中取出来
原理
数据结构
//用于保证队列操作的线程安全
private final transient ReentrantLock lock = new ReentrantLock();
// 优先级队列,存储元素，用于保证延迟低的优先执行
private final PriorityQueue<E> q = new PriorityQueue<E>();
// 用于标记当前是否有线程在排队（仅用于取元素时） leader 指向的是第一个从队列获取元素阻塞的线程
private Thread leader = null;
// 条件，用于表示现在是否有可取的元素 当新元素到达，或新线程可能需要成为leader时被通知
private final Condition available = lock.newCondition();
public DelayQueue() {}
public DelayQueue(Collection<? extends E> c) {
this.addAll(c);
}
入队put()方法
public void put(E e) {
offer(e);
}
public boolean offer(E e) {
final ReentrantLock lock = this.lock;
lock.lock();
try {
// 入队
q.offer(e);
if (q.peek() == e) {
// 若入队的元素位于队列头部，说明当前元素延迟最小
// 将 leader 置空
leader = null;
// 准备唤醒阻塞在available上的线程
available.signal();
}
return true;
} finally {
lock.unlock(); // 解锁，真正唤醒阻塞的线程
}
}
出队take()方法
public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
for (;;) {
E first = q.peek();// 取出堆顶元素( 最早过期的元素，但是不弹出对象)
if (first == null)// 如果堆顶元素为空，说明队列中还没有元素，直接阻塞等待
available.await();//当前线程无限期等待，直到被唤醒，并且释放锁。
else {
long delay = first.getDelay(NANOSECONDS);// 堆顶元素的到期时间
if (delay <= 0)// 如果小于0说明已到期，直接调用poll()方法弹出堆顶元素
return q.poll();
// 如果delay大于0 ，则下面要阻塞了
// 将first置为空方便gc
first = null;
// 如果有线程争抢的Leader线程，则进行无限期等待。
if (leader != null)
available.await();
else {
// 如果leader为null，把当前线程赋值给它
Thread thisThread = Thread.currentThread();
leader = thisThread;
try {
// 等待剩余等待时间
available.awaitNanos(delay);
} finally {
// 如果leader还是当前线程就把它置为空，让其它线程有机会获取元素
if (leader == thisThread)
leader = null;
}
}
}
}
} finally {
// 成功出队后，如果leader为空且堆顶还有元素，就唤醒下一个等待的线程
if (leader == null && q.peek() != null)
// available条件队列转同步队列,准备唤醒阻塞在available上的线程
available.signal();
// 解锁，真正唤醒阻塞的线程
lock.unlock();
}
}
出队流程如下：
- 当获取元素时，先获取到锁对象。
- 获取最早过期的元素，但是并不从队列中弹出元素。
- 最早过期元素是否为空，如果为空则直接让当前线程无限期等待状态，并且让出当前锁对象。
- 如果最早过期的元素不为空
- 获取最早过期元素的剩余过期时间，如果已经过期则直接返回当前元素
- 如果没有过期，也就是说剩余时间还存在，则先获取Leader对象，如果Leader已经有线程在处理，则当前线程进行无限期等待，如果Leader为空，则首先将Leader设置为当前线程，并且让当前线程等待剩余时间。
- 最后将Leader线程设置为空
- 如果Leader已经为空，并且队列有内容则唤醒一个等待的队列。
如何选择适合的阻塞队列
选择策略
通常我们可以从以下 5 个角度考虑，来选择合适的阻塞队列：
功能
第 1 个需要考虑的就是功能层面，比如是否需要阻塞队列帮我们排序，如优先级排序、延迟执行等。如果有这个需要，我们就必须选择类似于PriorityBlockingQueue 之类的有排序能力的阻塞队列。
容量
第 2 个需要考虑的是容量，或者说是否有存储的要求，还是只需要“直接传递”。在考虑这一点的时候，我们知道前面介绍的那几种阻塞队列，有的是容量固定的，如 ArrayBlockingQueue；有的默认是容量无限的，如 LinkedBlockingQueue；而有的里面没有任何容量，如 SynchronousQueue；而对于 DelayQueue 而言，它的容量固定就是 Integer.MAX_VALUE。所以不同阻塞队列的容量是千差万别的，我们需要根据任务数量来推算出合适的容量，从而去选取合适的阻塞队列
能否扩容
第 3 个需要考虑的是能否扩容。因为有时我们并不能在初始的时候很好的准确估计队列的大小，因为业务可能有高峰期、低谷期。如果一开始就固定一个容量，可能无法应对所有的情况，也是不合适的，有可能需要动态扩容。如果我们需要动态扩容的话，那么就不能选择 ArrayBlockingQueue ，因为它的容量在创建时就确定了，无法扩容。相反，PriorityBlockingQueue 即使在指定了初始容量之后，后续如果有需要，也可以自动扩容。所以我们可以根据是否需要扩容来选取合适的队列。
内存结构
第 4 个需要考虑的点就是内存结构。我们分析过 ArrayBlockingQueue 的源码，看到了它的内部结构是“数组”的形式。和它不同的是，LinkedBlockingQueue 的内部是用链表实现的，所以这里就需要我们考虑到，ArrayBlockingQueue 没有链表所需要的“节点”，空间利用率更高。所以如果我们对性能有要求可以从内存的结构角度去考虑这个问题。
性能
第 5 点就是从性能的角度去考虑。比如 LinkedBlockingQueue 由于拥有两把锁，它的操作粒度更细，在并发程度高的时候，相对于只有一把锁的 ArrayBlockingQueue 性能会更好。另外，SynchronousQueue 性能往往优于其他实现，因为它只需要“直接传递”，而不需要存储的过程。如果我们的场景需要直接传递的话，可以优先考虑 SynchronousQueue。
线程池对于阻塞队列的选择
线程池有很多种，不同种类的线程池会根据自己的特点，来选择适合自己的阻塞队列。
Executors类下的线程池类型：
- FixedThreadPool（SingleThreadExecutor 同理）选取的是 LinkedBlockingQueue
- CachedThreadPool 选取的是 SynchronousQueue
- ScheduledThreadPool（SingleThreadScheduledExecutor同理）选取的是延迟队列