知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 08 - 延迟任务的实现方案 > 导读:用一问一答的方式,围绕"订单 30 分钟未支付自动取消"这道经典题,逐一拆解 DelayQueue、ScheduledExecutorService、Redis ZSet、时间轮、消息队列五种延迟任务方案,并给出选型对比与生产取舍。适合需要落地定时/延迟业务的后端读者。 ## 一、先建立全局认知 ### Q:这道题的面试原题是什么?一共有哪些实现思路? A:面试官通常这样问: > "订单 30 分钟未支付自动取消,如何实现?" 这类需求本质是"延迟任务":在未来的某个时间点执行一个动作。常见的落地思路按"单机 → 分布式"演进,共五种: 1. **DelayQueue**:JDK 内置的延迟队列,单机内存方案; 2. **ScheduledExecutorService**:JDK 内置的定时线程池,单机方案; 3. **Redis ZSet**:用有序集合存到期时间戳,配合定时扫描,生产常用; 4. **时间轮**:如 Netty 的 `HashedWheelTimer`,适合海量短延迟任务; 5. **消息队列延迟消息**:如 RocketMQ 的延迟级别、RabbitMQ 的延迟插件,分布式高可靠方案。 ### Q:选延迟任务方案时,要权衡哪些维度? A:核心是四个维度,理解了它们,下面的逐方案分析就有共同的坐标系: - **精度**:任务实际触发时间与预期到期时间的偏差,是毫秒级、秒级还是更粗。 - **持久化**:服务重启后任务是否还在(内存方案会丢)。 - **分布式**:能否多实例部署、多实例之间不重复处理(幂等/抢占问题)。 - **规模**:能承载多少任务、单机内存和时间轮槽位是否够用。 ## 二、理解核心机制 ### Q:方案一——DelayQueue 怎么用?原理是什么? A:`DelayQueue` 是 JDK 内置的、无界阻塞队列,队列元素必须实现 `Delayed` 接口。完整用法如下: ```java import java.util.concurrent.*; // 1. 实现 Delayed 接口 class OrderTask implements Delayed { private final String orderId; private final long expireTime; // 到期时间(毫秒时间戳) public OrderTask(String orderId, long delayMs) { this.orderId = orderId; this.expireTime = System.currentTimeMillis() + delayMs; } @Override public long getDelay(TimeUnit unit) { // 返回剩余延迟时间(负数表示已到期) return unit.convert(expireTime - System.currentTimeMillis(), TimeUnit.MILLISECONDS); } @Override public int compareTo(Delayed other) { return Long.compare(this.expireTime, ((OrderTask) other).expireTime); } } // 2. 使用 DelayQueue public class OrderCancelService { private final DelayQueue<OrderTask> queue = new DelayQueue<>(); // 下单时添加延迟任务 public void addOrder(String orderId) { queue.put(new OrderTask(orderId, 30 * 60 * 1000L)); // 30 分钟 } // 消费者线程 public void startConsumer() { new Thread(() -> { while (true) { try { OrderTask task = queue.take(); // 阻塞直到有到期任务 cancelOrder(task.orderId); } catch (InterruptedException e) { Thread.currentThread().interrupt(); break; } } }).start(); } private void cancelOrder(String orderId) { System.out.println("取消订单: " + orderId); } } ``` **原理**:DelayQueue 底层是 PriorityQueue(最小堆),按到期时间排序,`take()` 时检查堆顶元素是否到期,未到期则等待。 **关键点与取舍**: - `getDelay` 返回"还剩多久到期",负数表示已到期,这是 `DelayQueue` 判断能否出队的关键方法。 - `compareTo` 按到期时间排序,决定了堆顶永远是"最早到期"的任务。要保证"越早到期越靠前",否则取出的顺序会错。 - **缺点**:数据在内存中,服务重启后任务丢失。 - 适用场景:单机、任务量少、丢失可容忍或不重要的场景。 ### Q:方案二——ScheduledExecutorService 怎么做? A:用 JDK 的定时线程池,提交任务时直接指定延迟时间: ```java ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(5); // 下单时提交延迟任务 public void addOrder(String orderId) { scheduler.schedule( () -> cancelOrder(orderId), 30, TimeUnit.MINUTES ); } ``` **取舍分析**: - 优点是 API 最简单,不必自己实现 `Delayed` 接口,适合"任务数量有限、单机"的简单场景。 - **缺点**:同样是内存存储,重启丢失;大量任务时内存占用高。 - 另一个隐含问题是:任务量很大时,线程池内部维护的延迟任务队列会膨胀,且单个 `ScheduledThreadPoolExecutor` 的调度精度在任务堆积时可能下降。对"海量延迟任务"不够友好,此时应考虑时间轮。 ### Q:方案三——Redis ZSet 怎么做?为什么是生产常用方案? A:把"订单到期时间戳"当成 score 存进有序集合,用一个定时任务扫描已到期的元素: ```java // 下单时,将订单 ID 存入 ZSet,score = 到期时间戳 public void addOrder(String orderId) { long expireTime = System.currentTimeMillis() + 30 * 60 * 1000L; redis.zadd("delay:orders", expireTime, orderId); } // 定时扫描(每秒执行一次) @Scheduled(fixedRate = 1000) public void scanExpiredOrders() { long now = System.currentTimeMillis(); // 获取所有 score <= now 的元素(已到期的订单) Set<String> expiredOrders = redis.zrangebyscore("delay:orders", 0, now); for (String orderId : expiredOrders) { // 用 Lua 脚本保证原子性(防止多实例重复处理) boolean removed = redis.zrem("delay:orders", orderId); if (removed) { cancelOrder(orderId); } } } ``` **优点**:持久化,服务重启不丢失;支持分布式多实例。 **缺点**:有 1 秒的误差(扫描间隔);大量到期任务时扫描压力大。 **取舍分析**: - 这里的核心技巧是"**用 `zrem` 的返回值做幂等/抢占**":`zrem` 返回被成功删除的元素个数,删到 1 说明"这个任务归我处理",删到 0 说明别的实例已经处理过。这样多实例部署时不会重复取消订单。 - 原文注释里写的是"用 Lua 脚本保证原子性"。要说明的是:单条 `zrem key member` 命令本身就是原子的,仅靠它的返回值就足以做幂等抢占;只有当"读取 + 判断 + 删除"需要作为一个整体执行时,才需要把多条命令封装进 Lua 脚本。具体用法需结合实际业务场景确认。 - 扫描间隔决定了精度(原文为每秒一次,即秒级误差)。间隔越短精度越高,但空扫描次数和 Redis 压力也越大。 - 适用场景:分布式、任务量中等、可接受秒级精度的场景。 ### Q:方案四——时间轮怎么实现? A:时间轮用"环形数组 + 指针转动"来组织任务,添加和执行都是 O(1): ```java // 时间轮原理: // 将时间划分为若干槽(如 512 个槽,每槽 100ms) // 任务根据延迟时间放入对应的槽 // 指针每 100ms 转动一格,执行当前槽的所有任务 // ┌──┬──┬──┬──┬──┬──┬──┬──┐ // │0 │1 │2 │3 │4 │5 │6 │7 │ ← 槽(每槽 100ms) // └──┴──┴──┴──┴──┴──┴──┴──┘ // ↑ 当前指针 HashedWheelTimer timer = new HashedWheelTimer( 100, TimeUnit.MILLISECONDS, // 每格时间 512 // 槽数量 ); // 添加延迟任务 timer.newTimeout(timeout -> { cancelOrder(orderId); }, 30, TimeUnit.MINUTES); ``` **优点**:O(1) 添加和执行任务,适合大量短延迟任务。 **缺点**:精度受槽大小限制;长延迟任务需要多圈(round)计数。 **取舍分析**: - 时间轮的精髓是用"槽数量 × 每格时间"覆盖一个时间范围,超出范围的延迟任务记一个 `round`(剩余圈数),指针每转一圈就减一,减到 0 才真正执行。这样"添加任务"和"取出到期任务"都是 O(1)。 - 槽越大精度越低、内存占用越大;每格时间越大越省内存、精度越差。原文的 512 槽 × 100ms 只是一个示例配置。 - `HashedWheelTimer` 属于 Netty,引入它意味着把 Netty 的依赖带进项目;如果只是想要时间轮能力而不想引 Netty,也可以自行实现。 - 适用场景:单机、海量短延迟任务(如会话超时、连接保活)。 ### Q:方案五——消息队列的延迟消息怎么做? A:以 RocketMQ 为例,发送消息时设置延迟级别,消息在投递时天然已经延迟: ```java // RocketMQ 延迟消息(支持 18 个固定延迟级别) Message msg = new Message("OrderTopic", orderId.getBytes()); msg.setDelayTimeLevel(16); // 30 分钟(level 16 = 30min) producer.send(msg); // 消费者收到消息时,订单已到期,执行取消逻辑 ``` **取舍分析**: - 优点是消息队列本身支持持久化和分布式,可靠性高,消费端天然具备重试和幂等基础;生产者只需发一条消息,不需要自己维护"什么时候到期"。 - 限制是延迟级别是**固定档位**(原例为 18 个级别),不支持任意精度延迟;具体档位与对应延迟时间需结合所用版本确认,不同版本可能调整。RabbitMQ 则需要借助延迟插件或死信队列实现类似能力。 - 适用场景:分布式、高可靠要求、对精度要求不苛刻(秒级档位可接受)的延迟业务。 ## 三、放进真实场景 ### Q:五种方案怎么对比?到底该选哪个? A:先看对比表: | 方案 | 精度 | 持久化 | 分布式 | 适用场景 | |------|------|--------|--------|---------| | DelayQueue | 高 | ✗ | ✗ | 单机,任务量少 | | ScheduledExecutor | 高 | ✗ | ✗ | 单机,简单场景 | | Redis ZSet | 秒级 | ✓ | ✓ | 分布式,任务量中等 | | 时间轮 | 高 | ✗ | ✗ | 单机,大量短延迟任务 | | 消息队列 | 秒级 | ✓ | ✓ | 分布式,高可靠要求 | **生产推荐**:Redis ZSet(简单可靠)或 RocketMQ 延迟消息(高可靠)。  [编辑 Excalidraw 源图](/images/java-interview-copy/concurrent/08-delay-task-delay-task-solution-selection-diagram.excalidraw) ### Q:选型的决策逻辑是什么? A:可以用一组问题快速收敛: 1. **必须分布式吗?** 需要多实例部署、任务不能丢 → 排除 DelayQueue、ScheduledExecutor、时间轮这三个内存方案。 2. **精度要求多高?** 要求毫秒级且是分布式 → Redis ZSet 的秒级扫描可能不够,需要更密的扫描或专门的时间轮服务。 3. **任务量多大?** 海量短延迟任务(如百万级连接超时)→ 时间轮在海量短延迟上的 O(1) 优势更突出。 4. **可靠性要求?** 要求"绝不丢"→ 消息队列的持久化 + 重试机制更稳。 生产上最常见的组合是:**Redis ZSet 做通用延迟调度**(简单、够用、可分片),**要求高可靠时用 RocketMQ 延迟消息**(把可靠性交给 MQ)。 ### Q:分布式方案(Redis ZSet / MQ)在落地时要注意什么? A:内存方案的主要风险是"丢任务",分布式方案的主要风险则变成"重复处理"和"扫描抖动": - **防重复处理**:多个实例同时扫描,同一个到期订单可能被多个实例拿到。Redis 方案用 `zrem` 返回值抢占(删到 1 才处理);MQ 方案则要保证消费端幂等。二者本质都是"用一次成功的原子操作决定归属"。 - **扫描抖动**:Redis 方案用 `@Scheduled(fixedRate = 1000)` 定时扫描,间隔越大精度越差,间隔越小压力越大。任务量上升后,可以把到期时间分片到多个 ZSet,或缩短单次扫描的数据量。 - **业务幂等**:无论哪种方案,取消订单这个动作本身都应当幂等——先判断订单状态是否仍是"待支付",已支付/已取消的直接跳过,避免延迟任务和用户支付这两条路径互相打架。 ## 四、总结与自测 ### Q:面试里怎么答这道题? A:建议按"需求拆解 → 方案枚举 → 权衡选型"三步作答: 1. **拆解需求**:这是延迟任务,关键指标是精度、持久化、分布式、任务规模四项。 2. **枚举方案**:单机可讲 `DelayQueue`(DelayQueue 底层是优先级队列)和 `ScheduledExecutorService`;海量短延迟讲时间轮(Netty `HashedWheelTimer`);分布式讲 Redis ZSet 和 RocketMQ/RabbitMQ 延迟消息。 3. **给结论**:生产推荐 Redis ZSet(简单可靠,用 `zrem` 抢占防重复)或 RocketMQ 延迟消息(高可靠);并补充幂等和精度两个工程注意点。 能说出"内存方案丢任务、分布式方案要防重复"这一组对称的风险,比单纯背五种方案更有说服力。 ### Q:这道题最容易踩的坑有哪些? A: - 用 `DelayQueue`/`ScheduledExecutorService` 却忽略了"服务重启任务全丢",线上事故的常见来源。 - Redis 方案里"先查到期再删"而不是用 `zrem` 的返回值抢占 → 多实例重复取消订单。 - 扫描间隔设置不当 → 精度不够或 Redis 压力过大。 - 取消订单不幂等 → 与支付回调并发时,出现"已支付却被取消"。 - RocketMQ 延迟消息只有固定档位,误以为能设任意延迟时间。 - 时间轮里长延迟任务忘记处理 `round` 计数 → 任务提前或延迟触发。 --- ## 自测 1. 用四个维度(精度、持久化、分布式、规模)分别评价 DelayQueue、Redis ZSet、时间轮三种方案。 2. Redis ZSet 方案里,为什么用 `zrem` 的返回值就能防止多实例重复处理?这属于哪一类并发控制思想? 3. 时间轮为什么能对"添加任务"和"执行任务"都做到 O(1)?长延迟任务又是怎么处理的?
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入