在现代分布式系统中，延迟队列是一种至关重要的组件。它允许我们将消息或任务放入队列，直到指定的延迟时间到达后才被消费。这种机制广泛应用于订单超时自动取消、支付后定时发送通知、任务重试等场景。
虽然RabbitMQ和RocketMQ等专业消息中间件都支持延迟消息，但在很多轻量级场景下，利用Redis来实现延迟队列是一个更简单、高效的选择。本教程将带你深入理解Redis延迟队列的原理，并手把手教你用Java实现一个高可用的延迟队列。
核心原理：有序集合的巧妙应用
实现Redis延迟队列的核心在于利用Redis的**有序集合（Sorted Set，简称ZSET）**数据结构。
ZSET中的每个成员（Member）都关联一个分数（Score），这个分数是一个浮点数，Redis会根据分数对成员进行自动排序。利用这一特性，我们可以将任务的执行时间戳作为Score ，将任务内容或ID作为Member。
工作流程如下：
- 生产消息（入队） ：当需要添加一个延迟任务时，计算出它的执行时间（当前时间 + 延迟时间），然后使用
ZADD命令将其添加到ZSET中。 - 消费消息（出队） ：消费者不断轮询ZSET，使用
ZRANGEBYSCORE命令获取所有分数（执行时间）小于等于当前时间的任务。这些就是已经"到期"的任务。 - 处理与删除 ：消费者获取到到期任务后，进行处理，处理完成后使用
ZREM命令将其从ZSET中移除。
这种实现方式利用了ZSET的自动排序特性，使得获取最早到期的任务变得非常高效。
基础实现：基于Jedis的手动封装
为了让你更清晰地理解底层原理，我们首先使用Jedis客户端手动实现一个延迟队列。
Maven依赖
首先，确保你的项目中包含了Jedis的依赖。
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>4.3.1</version>
</dependency>核心代码实现
下面是一个完整的延迟队列工具类，它封装了入队、出队和监听的核心逻辑。
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.Tuple;
import java.util.Set;
public class RedisDelayQueue {
private final JedisPool jedisPool;
private final String queueKey;
public RedisDelayQueue(String host, int port, String queueKey) {
this.jedisPool = new JedisPool(new JedisPoolConfig(), host, port);
this.queueKey = queueKey;
}
/**
* 添加延迟任务
* @param task 任务内容
* @param delayMillis 延迟时间（毫秒）
*/
public void addTask(String task, long delayMillis) {
try (Jedis jedis = jedisPool.getResource()) {
// Score为当前时间 + 延迟时间
long score = System.currentTimeMillis() + delayMillis;
// Member为任务内容
jedis.zadd(queueKey, score, task);
System.out.println("任务已添加: " + task + ", 将在 " + delayMillis + "ms 后执行");
}
}
/**
* 获取并移除一个到期的任务
* @return 到期的任务内容，如果没有到期任务则返回null
*/
public String getTask() {
try (Jedis jedis = jedisPool.getResource()) {
long now = System.currentTimeMillis();
// 获取所有分数小于等于当前时间的任务（即已到期任务）
// 我们只取第一个，保证一次只处理一个
Set<Tuple> tasks = jedis.zrangeByScoreWithScores(queueKey, 0, now, 0, 1);
if (tasks != null && !tasks.isEmpty()) {
Tuple taskTuple = tasks.iterator().next();
String task = taskTuple.getElement();
// 获取后立即从队列中移除
jedis.zrem(queueKey, task);
return task;
}
return null;
}
}
/**
* 启动消费者监听
*/
public void startConsumer() {
System.out.println("消费者已启动，正在监听队列...");
new Thread(() -> {
while (true) {
String task = getTask();
if (task != null) {
// 处理任务
handleTask(task);
} else {
// 没有任务，短暂休眠以避免CPU空转
try {
Thread.sleep(100);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
break;
}
}
}
}).start();
}
private void handleTask(String task) {
System.out.println("正在处理任务: " + task);
// 模拟业务处理耗时
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("任务处理完成: " + task);
}
public static void main(String[] args) {
RedisDelayQueue queue = new RedisDelayQueue("localhost", 6379, "my_delay_queue");
// 启动消费者
queue.startConsumer();
// 添加一些测试任务
queue.addTask("订单1超时取消", 3000); // 3秒后
queue.addTask("订单2超时取消", 5000); // 5秒后
queue.addTask("订单3超时取消", 3000); // 3秒后
}
}进阶方案：使用Redisson实现生产级队列
虽然手动实现有助于理解原理，但在生产环境中，我们更推荐使用Redisson 。Redisson是一个强大的Java驻内存数据网格客户端，它为我们提供了开箱即用的RDelayedQueue，解决了手动实现中的许多痛点。
Redisson的优势
- 简化开发：无需手动编写轮询和删除逻辑。
- 原子性保障：内部使用Lua脚本保证获取和删除操作的原子性，避免并发问题。
- 高性能：底层基于发布/订阅模式，消费者可以阻塞等待新任务，无需频繁轮询，大大降低了CPU和网络开销。
Maven依赖
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson</artifactId>
<version>3.21.3</version>
</dependency>核心代码实现
Redisson的实现方式非常优雅，它将延迟队列（RDelayedQueue）和最终的执行队列（RBlockingQueue）分离。
import org.redisson.Redisson;
import org.redisson.api.RBlockingQueue;
import org.redisson.api.RDelayedQueue;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import java.util.concurrent.TimeUnit;
public class RedissonDelayQueueDemo {
public static void main(String[] args) throws InterruptedException {
// 1. 创建Redisson客户端
Config config = new Config();
config.useSingleServer().setAddress("redis://127.0.0.1:6379");
RedissonClient redissonClient = Redisson.create(config);
// 2. 获取一个阻塞队列，它将作为延迟任务的最终目的地
RBlockingQueue<String> blockingQueue = redissonClient.getBlockingQueue("my_task_queue");
// 3. 基于阻塞队列创建一个延迟队列
RDelayedQueue<String> delayedQueue = redissonClient.getDelayedQueue(blockingQueue);
// 4. 启动消费者线程，从阻塞队列中获取任务
new Thread(() -> {
while (true) {
try {
// take()方法会阻塞，直到有任务可用
String task = blockingQueue.take();
System.out.println("消费者收到任务: " + task);
// 处理任务...
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
break;
}
}
}).start();
// 5. 生产者添加延迟任务
System.out.println("添加延迟任务...");
delayedQueue.offer("订单A-5秒后执行", 5, TimeUnit.SECONDS);
delayedQueue.offer("订单B-2秒后执行", 2, TimeUnit.SECONDS);
delayedQueue.offer("订单C-10秒后执行", 10, TimeUnit.SECONDS);
// 保持主线程运行
Thread.sleep(20000);
// 关闭客户端
redissonClient.shutdown();
}
}生产环境的挑战与解决方案
在实际应用中，我们必须考虑一些边界情况，以确保队列的可靠性。
如何保证消息不丢失？
在手动实现中，如果消费者获取到任务后，在处理完成前进程崩溃，那么这个任务就会永久丢失。一个常见的解决方案是引入二次确认机制。
- 消费者获取到期任务后，不立即删除，而是将其移动到一个"处理中"的临时集合。
- 处理完成后，再从"处理中"集合删除。
- 同时，需要一个独立的"看门狗"线程，定期检查"处理中"集合里的任务是否超时。如果超时，则将其重新放回主队列，实现自动重试。
如何避免并发问题？
在多线程环境下，多个消费者可能同时获取到同一个到期任务，导致任务被重复执行。
- Redisson方案 ：Redisson的
RBlockingQueue.take()操作是原子的，天然支持多消费者竞争，不会有重复消费的问题。 - 手动方案 ：可以使用Redis的
ZREMRANGEBYSCORE命令，该命令会原子性地移除指定分数范围的成员并返回被移除的成员。这样，获取和删除就合并成了一个原子操作。
如何监控队列状态？
运维监控是生产环境不可或缺的一环。你可以轻松地通过Redis命令来监控队列。
- 查看队列长度 ：
ZCARD my_delay_queue - 查看下一个即将执行的任务 ：
ZRANGE my_delay_queue 0 0 WITHSCORES - 查看积压的未到期任务 ：
ZCOUNT my_delay_queue (当前时间戳 +inf