并发编程-阻塞队列

最新推荐文章于 2025-03-20 18:04:48 发布

4u-020316

最新推荐文章于 2025-03-20 18:04:48 发布

阅读量572

点赞数 11

文章标签： java 开发语言

本文链接：https://blog.youkuaiyun.com/weixin_54624846/article/details/145271008

版权

1. 阻塞队列介绍

1.1 队列

是限定在一端进行插入，另一端进行删除的特殊线性表。

先进先出(FIFO)线性表。

允许出队的一端称为队头，允许入队的一端称为队尾。

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();
}

1.2 阻塞队列

BlockingQueue提供了线程

安全的队列访问方式：当阻塞队列插入数据时，如果队列已满，线程将会阻塞等待直到队列非满；从阻塞队列取数据时，如果队列已空，线程将会阻塞等待直到队列非空。并发包下很多高级同步类的实现都是基于BlockingQueue实现的。

BlockingQueue接口

1.3 JUC包下的阻塞队列

BlockingQueue 接口的实现类都被放在了 juc 包中，它们的区别主要体现在存储结构上或对元素操作上的不同，但是对于take与put操作的原理却是类似的。

BlockingQueue| ProcessOn免费在线作图,在线流程图,在线思维导图

2. ArrayBlockingQueue

ArrayBlockingQueue是最典型的有界阻塞队列，其内部是用数组存储元素的，初始化时需要指定

容量大小，利用 ReentrantLock 实现线程安全。

2.1 ArrayBlockingQueue使用

BlockingQueue queue = new ArrayBlockingQueue(1024); 
queue.put("1"); //向队列中添加元素 
Object object = queue.take(); //从队列中取出元素

2.2 ArrayBlockingQueue的原理

ArrayBlockingQueue使用独占锁ReentrantLock实现线程安全，入队和出队操作使用同一个锁对象，也就是只能有一个线程可以进行入队或者出队操作；这也就意味着生产者和消费者无法并行操作，在高并发场景下会成为性能瓶颈。

利用了Lock锁的Condition通知机制进行阻塞控制。

核心：一把锁，两个条件

入队put方法

出队take方法

为什么ArrayBlockingQueue对数组操作要设计成双指针（takeIndex和putIndenx）？

使用双指针的好处在于可以避免数组的复制操作（CopyOnwriteArrayList就是这样做）。如果使用单指针，每次删除元素时需要将后面的元

素全部向前移动，这样会导致时间复杂度为 O(n)。而使用双指针，我们可以直接将 takeIndex 指向下一个元素，而不需要将其前面的元素全部向前移动。同样地，插入新的元素时，我们可以直接将新元素插入到 putIndex 所指向的位置，而不需要将其后面的元素全部向后移动。这样可以使得插入和删除的时间复杂度都是 O(1) 级别，提高了队列的性能。

3. LinkedBlockingQueue

LinkedBlockingQueue是一个基于链表实现的阻塞队列，默认情况下，该阻塞队列的大小为

Integer.MAX_VALUE（2的三十一次方数-1），由于这个数值特别大，所以 LinkedBlockingQueue 也被称作无界队列，代表它几乎没有界限，队列可以随着元素的添加而动态增长，但是如果没有剩余内存，则队列将抛出OOM错误。所以为了避免队列过大造成机器负载或者内存爆满的情况出现，我们在使用的时候建议手动传一个队列的大小。

3.1 LinkedBlockingQueue使用

//指定队列的大小创建有界队列 
BlockingQueue<Integer> boundedQueue = new LinkedBlockingQueue<>(100); 
//无界队列 3
BlockingQueue<Integer> unboundedQueue = new LinkedBlockingQueue<>();

3.2 LinkedBlockingQueue原理

LinkedBlockingQueue内部由单链表实现，只能从head取元素，从tail添加元素。

LinkedBlockingQueue采用两把锁的锁分离技术实现入队出队互不阻塞，添加元素和获取元素都有独立的锁，也就是说LinkedBlockingQueue是读写分离的，读写操作可以并行执行。

private final int capacity;
// 元素数量
private final AtomicInteger count = new AtomicInteger();
// 链表头 本身是不存储任何元素的，初始化时item指向null
transient Node<E> head;
// 链表尾
private transient Node<E> last;
// take锁 锁分离，提高效率
private final ReentrantLock takeLock = new ReentrantLock();
// notEmpty条件
// 当队列无元素时，take锁会阻塞在notEmpty条件上，等待其它线程唤醒
private final Condition notEmpty = takeLock.newCondition();
// put锁
private final ReentrantLock putLock = new ReentrantLock();
// notFull条件
// 当队列满了时，put锁会阻塞在notFull上，等待其它线程唤醒
private final Condition notFull = putLock.newCondition();

// 典型的单链表结构
static class Node<E> {
    E item; // 存储元素
    Node<E> next; // 后继节点 单链表结构
    Node(E x) { item = x; }
}

构造器

public LinkedBlockingQueue() {
    // 如果没传容量，就使用最大int值初始化其容量
    this(Integer.MAX_VALUE);
}

public LinkedBlockingQueue(int capacity) {
    if (capacity <= 0) throw new IllegalArgumentException();
    this.capacity = capacity;
    // 初始化head和last指针为空值节点
    last = head = new Node<E>(null);
}

入队put方法

出队take方法

3.3 LinkedBlockingQueue与ArrayBlockingQueue对比

LinkedBlockingQueue是一个阻塞队列，内部由两个ReentrantLock来实现出入队列的线程安

全，由各自的Condition对象的await和signal来实现等待和唤醒功能。它和ArrayBlockingQueue的

不同点在于：

1.队列大小有所不同，ArrayBlockingQueue是有界的初始化必须指定大小，而LinkedBlockingQueue可以是有界的也可以是无界的(Integer.MAX_VALUE)，对于后者而言，当添加速度大于移除速度时，在无界的情况下，可能会造成内存溢出等问题。

2.数据存储容器不同 ，ArrayBlockingQueue采用的是数组作为数据存储容器，而LinkedBlockingQueue采用的则是以Node节点作为连接对象的链表。

由于ArrayBlockingQueue采用的是数组的存储容器，因此在插入或删除元素时不会产生或销毁任何额外的对象实例，而LinkedBlockingQueue则会生成一个额外的Node对象。这可能在长时间内需要高效并发地处理大批量数据的时，对于GC可能存在较大影响。

3.两者的实现队列添加或移除的锁不一样， ArrayBlockingQueue实现的队列中的锁是没有分离的，即添加操作和移除操作采用的同一个ReenterLock锁，而 LinkedBlockingQueue实现的队列中的锁是分离的，其添加采用的是 putLock，移除采用的则是takeLock，这样能大大提高队列的吞吐量，也意味着在高并发的情况下生产者和消费者可以并行地操作队列中的数据，以此来提高整个队列的并发性能。

4.1 DelayQueue使用

在实现一个延迟订单的场景中，我们可以定义一个 Order 类，其中包含订单的基本信息，例如订单编号、订单金额、订单创建时间等。同时，我们可以让 Order 类实现 Delayed 接口，重写getDelay 和compareTo 方法。在 getDelay 方法中，我们可以计算订单的剩余延迟时间，而在 compareTo 方法中，我们可以根据订单的延迟时间进行比较。

下面是一个简单的示例代码，演示了如何使用 DelayQueue 来实现一个延迟订单的场景：

public class DelayQueueExample {

    public static void main(String[] args) throws InterruptedException {
        // 创建一个 DelayQueue 用于存放延迟任务
        DelayQueue<Order> delayQueue = new DelayQueue<>();

        // 添加三个订单，分别延迟 5 秒、2 秒和 3 秒
        delayQueue.put(new Order("order1", System.currentTimeMillis(), 5000)); // 延迟 5 秒
        delayQueue.put(new Order("order2", System.currentTimeMillis(), 2000)); // 延迟 2 秒
        delayQueue.put(new Order("order3", System.currentTimeMillis(), 3000)); // 延迟 3 秒

        // 循环取出订单，直到所有订单都被处理完毕
        while (!delayQueue.isEmpty()) {
            // 从队列中取出到期的订单，如果队列为空或没有到期任务，则阻塞等待
            Order order = delayQueue.take();
            // 打印处理的订单 ID
            System.out.println("处理订单：" + order.getOrderId());
        }
    }

    // 定义一个 Order 类，表示订单任务，并实现 Delayed 接口
    static class Order implements Delayed {
        private String orderId;       // 订单 ID
        private long createTime;      // 订单创建时间
        private long delayTime;       // 订单延迟时间（单位：毫秒）

        // 构造函数，初始化订单 ID、创建时间和延迟时间
        public Order(String orderId, long createTime, long delayTime) {
            this.orderId = orderId;
            this.createTime = createTime;
            this.delayTime = delayTime;
        }

        // 获取订单 ID
        public String getOrderId() {
            return orderId;
        }

        // 实现 Delayed 接口的 getDelay 方法，计算剩余延迟时间
        @Override
        public long getDelay(TimeUnit unit) {
            // 计算剩余时间 = 创建时间 + 延迟时间 - 当前时间
            long diff = createTime + delayTime - System.currentTimeMillis();
            // 将剩余时间转换为指定的时间单位
            return unit.convert(diff, TimeUnit.MILLISECONDS);
        }

        // 实现 Delayed 接口的 compareTo 方法，用于比较两个订单的延迟时间
        @Override
        public int compareTo(Delayed o) {
            // 计算当前订单与另一个订单的剩余延迟时间差值
            long diff = this.getDelay(TimeUnit.MILLISECONDS) - o.getDelay(TimeUnit.MILLISECONDS);
            // 返回比较结果：正数表示当前订单延迟更长，负数表示更短，0 表示相等
            return Long.compare(diff, 0);
        }
    }
}

由于每个订单都有不同的延迟时间，因此它们将会按照延迟时间的顺序被取出。当延迟时间到达时，对应的订单对象将会被从队列中取出，并被处理。

原理：

import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
import java.util.PriorityQueue;

public class DelayQueue<E extends Delayed> {

    // 使用 PriorityQueue 作为底层数据结构，用于存储元素并按延迟时间排序
    private final PriorityQueue<E> q = new PriorityQueue<>();

    // 锁对象，用于保证线程安全
    private final ReentrantLock lock = new ReentrantLock();

    // 条件变量，用于实现阻塞等待
    private final Condition available = lock.newCondition();

    /**
     * 将元素添加到队列中。
     * 如果队列已满，则阻塞直到有空间可用。
     *
     * @param e 要添加的元素
     */
    public void put(E e) {
        lock.lock(); // 加锁
        try {
            q.offer(e); // 将元素添加到 PriorityQueue 中
            if (q.peek() == e) { // 如果新添加的元素是队列的第一个元素
                available.signal(); // 唤醒等待的线程
            }
        } finally {
            lock.unlock(); // 释放锁
        }
    }

    /**
     * 从队列中取出并移除到期的元素。
     * 如果队列为空或没有到期元素，则阻塞等待。
     *
     * @return 到期的元素
     * @throws InterruptedException 如果线程被中断
     */
    public E take() throws InterruptedException {
        lock.lock(); // 加锁
        try {
            while (true) {
                E first = q.peek(); // 获取队列的第一个元素
                if (first == null) { // 如果队列为空
                    available.await(); // 阻塞等待
                } else {
                    long delay = first.getDelay(TimeUnit.NANOSECONDS); // 获取剩余延迟时间
                    if (delay <= 0) { // 如果元素已到期
                        return q.poll(); // 移除并返回该元素
                    }
                    available.awaitNanos(delay); // 否则，阻塞等待剩余延迟时间
                }
            }
        } finally {
            lock.unlock(); // 释放锁
        }
    }

    /**
     * 返回队列中的元素数量。
     *
     * @return 元素数量
     */
    public int size() {
        lock.lock(); // 加锁
        try {
            return q.size(); // 返回 PriorityQueue 的大小
        } finally {
            lock.unlock(); // 释放锁
        }
    }
}