图解DelayQueue 数据结构设计与应用案例

肖哥弹架构
126 阅读5分钟

image.png

DelayQueue 是 Java 并发包中的一个延迟队列实现，主要用于管理需要在特定时间点执行的任务。它允许任务在预定的延迟后变得可用，而不是立即执行。DelayQueue 中的每个元素都必须实现 Delayed 接口，该接口规定了元素必须具备获取剩余延迟时间和比较到期顺序的能力。

这个队列是无界的，并且是线程安全的，使用 PriorityQueue 作为其内部数据结构来维护元素的到期顺序。当元素的延迟时间到期时，它们可以被取出和处理。DelayQueue 提供了 take() 和 poll() 方法来获取元素，其中 take() 会阻塞直到队列中有元素到期，而 poll() 则会立即返回，如果有到期的元素。

DelayQueue 适用于缓存失效、任务调度和订单超时等场景，它通过减少轮询和提高资源效率，为延迟任务提供了一种高效的处理方式。开发者可以轻松地将任务加入队列，并依赖 DelayQueue 来确保这些任务在正确的时间被执行。

1、 DelayQueue

DelayQueue 是 Java 并发包 java.util.concurrent 中的一个类，它主要用于处理需要在特定时间点执行的任务,为了满足在多线程环境中对任务进行有效延迟处理的需求，同时提供线程安全和高效的性能。以下是 DelayQueue 的设计：

设计思考：

  1. 需求场景
    • 在许多应用场景中，如任务调度、缓存失效、订单超时处理等，需要对任务或数据进行延迟处理。这些任务需要在指定的延迟时间后执行，而不是立即执行。
  2. 现有技术局限性
    • 传统的队列数据结构（如 LinkedList 或 ArrayList）可以存储元素，但不支持基于时间的延迟获取操作。
    • Timer 类可以调度任务，但它不是线程安全的，并且不支持大量的并发任务调度。
    • ScheduledExecutorService 支持定时任务，但它的实现复杂，且需要显式地管理线程池。
  3. 技术融合
    • 为了结合队列的先进先出（FIFO）特性和基于时间的延迟处理能力，DelayQueue 应运而生。它提供了一种机制，允许任务在指定的延迟时间后被处理，而不是立即执行。
  4. 设计理念
    • DelayQueue 底层使用优先队列 PriorityQueue 来存储元素，并保证线程安全。它要求队列中的元素必须实现 Delayed 接口，该接口规定了元素必须实现 getDelay 方法（计算剩余延迟时间）和 compareTo 方法（确定元素处理顺序）。
  5. 实现方式
    • DelayQueue 继承自 AbstractQueue 并实现了 BlockingQueue 接口，提供了线程安全的延迟队列实现。
    • 它内部维护了一个优先队列，根据元素的延迟时间进行排序。
    • 通过 ReentrantLock 和 Condition 对象来控制线程安全和线程间的等待/通知机制。

2、 数据结构

image.png

图说明：
  • 三个元素 E1、E2 和 E3，它们都实现了 Delayed 接口，并且具有不同的延迟时间。
  • 每个元素对应一个队列中的节点 Q1、Q2 和 Q3，它们在优先队列中按照到期时间排序。
  • 元素之间形成了一个双向链表，以维护它们的插入顺序。在这个例子中，E1 是最早插入的，其次是 E2，然后是 E3。

3、 执行流程

image.png

图说明：
  • 开始创建 DelayQueue 实例。
  • 决定是获取元素还是其他操作（如添加元素）。
  • 如果是获取元素，使用 take() 方法等待直到元素到期。
  • 返回已到期的元素。
  • 如果是检查队首元素的延迟时间，并且时间未到，则线程阻塞等待。
  • 如果时间已到，则从优先队列中移除元素并返回。
  • 结束流程。

优点

  • 线程安全：  提供了线程安全的延迟队列实现，可以在多线程环境中使用。
  • 性能：  通过使用优先队列和条件变量，DelayQueue 提供了高效的任务调度性能。
  • 灵活性：  允许任务在指定的延迟时间后执行，提供了灵活的任务调度能力。

缺点

  • 内存占用：  由于需要维护优先队列和条件变量，DelayQueue 可能会比简单的队列实现占用更多的内存。
  • 复杂性：  实现和使用 DelayQueue 需要理解其内部机制，对于初学者来说可能有一定的学习曲线。

使用场景

DelayQueue 适用于需要在特定时间点执行任务的场景，如：

  • 缓存系统：  管理缓存元素的有效期，自动删除过期的缓存项。
  • 任务调度：  调度需要在未来某个时间点执行的任务。
  • 订单处理：  自动处理超时未支付的订单。
  • 消息队列：  处理需要延迟送达的消息。

7、类设计

image.png

8、应用案例

电商平台用户下单后需要在一定时间内完成支付，否则订单将自动取消。我们可以使用 DelayQueue 来管理这些订单，确保在指定的时间内未支付的订单能够被自动处理。首先，我们定义一个 Order 类，它实现了 Delayed 接口，表示订单将在特定的时间后过期。

import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

public class Order implements Delayed {
    private String orderId;
    private long delayTime; // 订单过期时间（相对于系统当前时间的毫秒数）
    private long createTime; // 订单创建时间

    public Order(String orderId, long delayTime) {
        this.orderId = orderId;
        this.delayTime = delayTime;
        this.createTime = System.currentTimeMillis();
    }

    @Override
    public long getDelay(TimeUnit unit) {
        long delay = this.createTime + this.delayTime - System.currentTimeMillis();
        return unit.convert(delay, TimeUnit.MILLISECONDS);
    }

    @Override
    public int compareTo(Delayed other) {
        if (other instanceof Order) {
            return Long.compare(this.getDelay(TimeUnit.MILLISECONDS), other.getDelay(TimeUnit.MILLISECONDS));
        }
        return 0;
    }

    @Override
    public String toString() {
        return "Order{" +
                "orderId='" + orderId + ''' +
                ", delayTime=" + delayTime +
                ", createTime=" + createTime +
                '}';
    }
}

接下来，我们创建一个 DelayQueue 来管理这些订单，并使用一个线程来不断检查并处理过期的订单。

import java.util.concurrent.DelayQueue;
import java.util.concurrent.BlockingQueue;

public class OrderManager {
    private BlockingQueue<Order> orderQueue = new DelayQueue<>();

    public void addOrder(Order order) {
        orderQueue.offer(order);
    }

    public void processOrders() {
        Thread orderProcessor = new Thread(() -> {
            try {
                while (true) {
                    Order order = orderQueue.take(); // 阻塞直到有订单到期
                    System.out.println("Processing expired order: " + order);
                    // 处理过期的订单，例如取消订单，释放库存等
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
        orderProcessor.start();
    }
}

最后，我们在主程序中创建订单并启动订单处理线程。

public class Main {
    public static void main(String[] args) {
        OrderManager orderManager = new OrderManager();
        orderManager.processOrders(); // 启动订单处理线程

        //添加订单
        orderManager.addOrder(new Order("Order001", 30000)); // 30秒后过期
        orderManager.addOrder(new Order("Order002", 60000)); // 1分钟后过期
    }
}
avatar
文章
阅读
粉丝