架构视界
主页
企业架构
  • 方案总览
  • 业财一体
  • 企业中台
  • 组织与绩效
  • 流程治理
数据收集与分析
  • 转型总览
  • 信息化阶段
  • 数字化解决方案
  • 智数化解决方案
  • 智能化解决方案
  • 产品设计
  • 项目管理
全栈软件工程
AI 原生软件工程
方法论
博客
  • 资源导航
  • 效率工具
  • 展示专区
主页
企业架构
  • 方案总览
  • 业财一体
  • 企业中台
  • 组织与绩效
  • 流程治理
数据收集与分析
  • 转型总览
  • 信息化阶段
  • 数字化解决方案
  • 智数化解决方案
  • 智能化解决方案
  • 产品设计
  • 项目管理
全栈软件工程
AI 原生软件工程
方法论
博客
  • 资源导航
  • 效率工具
  • 展示专区
  • 标签索引
  • 2024年

    • 勇闯大A:美债与美元周期
    • 勇闯大A:交易纪律与自我管理
    • 勇闯大A:交易系统分层
    • 勇闯大A:买卖点与止损规则
    • 勇闯大A:债券与资金流向
    • 勇闯大A:微观、宏观与周期
    • Mac 开发环境:新机配置清单
    • 勇闯大A:内外盘与换手率
    • 会计管理:财报阅读与管理报表
    • 会计基础:记账原理与分录
    • 财务入门:财务体系全景
  • 2023年

    • 境外投资:泰国 BOI 申请实务
  • 2022年

    • 企业架构:故障管理与分级响应
    • 企业架构:技术债务的识别、度量与偿还
  • 2021年

    • Python 数据分析:员工分布可视化
    • Python 数据分析:IP 访问折线图
    • Python 数据分析:IP 词云图
    • Redis:RediSearch 全文检索
    • Rust 基础:第一个 CLI 程序
    • Rust 基础:所有权机制
    • Rust 基础:函数与控制流
    • Rust 基础:变量与数据类型
    • Rust 基础:入门与开发环境
    • 企业架构:分布式系统设计
    • 企业架构:编程式权限设计
    • JVM 调优:启动参数与 GC 日志
    • MyBatis 批量插入:三种写法对比
    • 测试:Spring Boot 分层 Mock
    • Redis:布隆过滤器判断元素存在
    • Jenkins:安装配置与应用部署
    • WebClient:非阻塞 HTTP 客户端
    • Drone:Docker 部署轻量 CI
    • Spring AOP:操作审计日志落库
    • Redisson:分布式锁与 RedLock
    • MyBatis 拦截器:雪花算法主键
    • Netty:线程模型与网络编程
    • Redis:SCAN 游标遍历大键空间
    • Jenkins:单机部署与升级脚本
    • Mac:Neo4j 与 Jupyter 安装
    • JavaFX:OpenJDK 11 环境配置
    • Mac:用 jenv 管理 JDK 版本
    • Redis:有序集合实现延时队列
    • Spring Boot 日志:MDC 串联链路
    • 定时任务:Spring 调度与 Cron
    • GoAccess:Nginx 日志分析
    • MyBatis 拦截器:慢 SQL 分析
    • Lucene:倒排索引与中文分词
    • 分布式锁:三种实现方案对比
    • 学习技巧:减少学习排斥心理
    • 动态数据源:多租户数据路由
    • Compose:Spring Boot 三件套
    • Java 阻塞队列:源码与用法
    • Redis:Docker Compose 哨兵
    • Redis:Docker Compose 主从
    • 网络通信:TCP/IP 与 HTTP 基础
  • 2020年

    • 延时队列:DelayQueue 与 Redis 实现
    • MySQL 基础:员工库导入实践
    • 雪花算法:分布式 ID 生成
    • Redis:地理位置查询
    • 抓包:Wireshark 与 Tcpdump
    • SPI:JDK 与 Spring 扩展机制
    • ZooKeeper:概念与集群搭建
    • Spring Boot:集成 JMH 基准测试
    • Wireshark:抓包工具入门
    • Compose:Redis 与 MySQL
    • CentOS 7:Docker 安装部署
    • Netty:源码阅读环境搭建
    • MySQL 基础:SQL 常见用法
    • CentOS 7:Selenium 运行环境
    • Nginx:HTTPS 证书配置
    • JMH:基准测试与 Spring Boot 集成
    • Spring Boot:指定 Tomcat 版本
    • Eureka:实例上下线告警
    • 钉钉告警:应用异常与实例上下线
    • JVM:内存布局、类加载与调优
    • Git:rebase 合并多次提交
    • CentOS 7:OpenResty 部署
  • 2019年

    • Redis CLI:macOS 安装与使用
    • Nginx:访问日志格式
    • 工程规范:可维护代码的写法
    • IntelliJ IDEA:常用插件
    • SkyWalking:源码阅读环境搭建
    • Spring Boot:Redis 超时配置
    • gRPC:ProtoBuf 定义与代码生成
    • Arthas:Java 线上问题诊断
    • Redis:缓存穿透与击穿防护
    • Docker 部署:Elasticsearch
    • Docker 部署:MySQL 5.7 单机
    • Spring Redis:字符串命令封装
    • Docker 部署:ZooKeeper 运行
    • Docker 部署:Redis 单机运行
    • Dubbo:Spring Boot 微服务集成
    • CentOS 7:CMake 源码编译安装
    • 性能度量:吞吐量与 QPS 指标
    • Java 递归:从笔试题到经典问题
    • CentOS 7:ELK 日志平台部署
    • CentOS 7:SonarQube 部署
    • Selenium:Chrome 浏览器自动化
    • JJWT:令牌生成与解析测试
    • Spring 源码:阅读环境搭建
    • JUnit 4:注解、断言与参数化
    • JWT:令牌结构与签名机制
    • FastDFS:架构与文件存取机制
    • XPath:XML 文档节点定位
    • Redis 基础:锁、队列与事务
    • Redis 基础:数据类型与命令
    • MyBatis:Slf4j 日志接入
    • MyBatis:H2 单元测试与 SQL 日志
    • 源码阅读:开源项目环境搭建
    • Git 配置:命令清单与作用域
    • Java 核心:面向对象与基础类型
    • Java 核心:关键字、异常与反射
    • Java 核心:多线程基础
    • Java 核心:同步关键字与线程池
    • Java 核心:锁与并发工具
    • Java 核心:语言基础与并发
    • Dubbo:远程调用与服务治理
    • Java 集合:框架总览与实现对比
    • Maven:生命周期与常用命令
    • MyBatis:执行流程与插件机制
    • Spring:IoC 容器与依赖注入
    • Spring:AOP 与自动装配
    • Spring:事务与启动流程
    • Spring:IoC、AOP 与事务
    • Spring MVC:请求分发与注解
    • MySQL:架构与索引
    • MySQL:事务、锁与 MVCC
    • MySQL:日志与 SQL 优化
    • MySQL:架构、事务与优化
    • Redis 基础:持久化与线程模型
  • 2018年

    • Java HashMap:扩容机制与哈希冲突
    • Java 集合:HashSet 去重原理
    • Java 基础:交换两个变量的值
    • Spring MVC:零 web.xml 改造
    • Mac 开发环境:新机配置清单
    • Log4j:日志分级与按业务拆分
    • Modbus:工业通信协议与 RTU 帧
    • MySQL 基础:子查询与连接查询
    • MySQL 基础:库与表操作
    • MySQL 基础:表操作与查询
    • MySQL 基础:约束、引擎与数据类型
    • MySQL 基础:库表、约束与类型
    • Java 集合:Vector 与 Stack
    • Java 集合:Vector 与 Stack
    • RabbitMQ:CentOS 7 单机部署
    • Redis:CentOS 7 单机部署
    • MongoDB:CentOS 7 单机部署
    • Linux:常用系统与运维命令
    • 注册中心:Eureka 与 ZooKeeper
    • MySQL:CentOS 7 单机部署
    • Git 分支:主分支与临时分支
    • CentOS 7:Java 开发环境部署
    • Java 集合:LinkedList 双向链表
    • Java 集合:ArrayList 动态数组
    • Spring AOP:注解方式实现切面
← 返回博客

延时队列:DelayQueue 与 Redis 实现

2020年12月30日 #后端开发 #Java

订单超时关闭一类的需求,常见做法是延时队列:消息先存储,到期后再被消费。这里先实现 JDK 自带的 DelayQueue,再给出 Redis 有序集合方案。

  • 延时队列是一种带有延迟功能的消息队列,通常具备消息存储、过期消息的实时获取、高可用与消费熔断能力。
  • 业务场景:订单未支付超时、订单发货提醒、短信提醒、自动收货、自动评论、自动取消订单等。
  • 常用方案:
    • 定时轮询任务,比如用 TimerThread 轮询数据库表或缓存中的数据。频繁轮询容易造成资源浪费,也会给数据与缓存带来压力,一般只作为补偿或初始化手段。
    • ScheduledExecutorService 周期性线程池。
    • 时间轮(Kafka、Netty 的 HashedWheelTimer)。
    • 使用 MySQL 时定时扫描表,找出符合条件的数据处理,消费成功再更新状态。
    • 使用 Redis 时用 zset 按分值排序,定时轮询取出符合条件的记录,消费后删除,失败则重新入队。
    • Java 的 java.util.concurrent.DelayQueue:JDK 实现,队列位于 JVM 内,不支持分布式与消息持久化。
    • RocketMQ 延时队列:支持消息持久化、重试与分布式,但不支持任意时间精度,只支持固定 level 级别的延时消息。

DelayQueue:JVM 内实现

DelayQueue 采用 Leader-Follower 模式,只有 leader 线程按到期时间等待,其余线程阻塞在条件变量上:

结构与源码

public class DelayQueue<E extends Delayed> extends AbstractQueue<E>
    implements BlockingQueue<E> {
    // 并发控制,可重入锁。
    private final transient ReentrantLock lock = new ReentrantLock();
    // 根据 Delay 时间排序,优先级队列。
    private final PriorityQueue<E> q = new PriorityQueue<E>();
    // 指定等待队列头部元素的线程,标记当前是否有线程在排队(仅用于取元素时)
    private Thread leader = null;
    // 条件对象,用于阻塞和通知,表示当前是否有可取的元素
    private final Condition available = lock.newCondition();
...
}

PriorityQueue

底层使用数组存储元素,默认容量 11,按比较器维持小顶堆:

public class PriorityQueue<E> extends AbstractQueue<E>
    implements java.io.Serializable {

    private static final long serialVersionUID = -7720805057305804111L;
    // 默认容器大小
    private static final int DEFAULT_INITIAL_CAPACITY = 11;

    // 用数组存储元素
    transient Object[] queue; // non-private to simplify nested class access

    // 记录元素个数
    private int size = 0;

    // 比较器
    private final Comparator<? super E> comparator;

    // 安全修改计数,Fail-Fast 机制。
    transient int modCount = 0; // non-private to simplify nested class access
...
}

offer 方法

// 添加元素到队列中
public boolean add(E e) {
    return 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.signal();
        }
        // 添加元素返回成功,可能 OOM
        return true;
    } finally {
        // 释放锁
        lock.unlock();
    }
}

take 方法

public E take() throws InterruptedException {
    // 获取锁
    final ReentrantLock lock = this.lock;
    // 可中断锁,避免 await() 抛中断异常导致直接异常退出
    lock.lockInterruptibly();
    try {
        // 死循环
        for (;;) {
            // 获取队头元素
            E first = q.peek();
            if (first == null)
                // 队头为 null,继续等待
                available.await();
            else {
                // 获取队头元素剩余时间
                long delay = first.getDelay(NANOSECONDS);
                // 时间已到,直接返回队头元素
                if (delay <= 0)
                    return q.poll();
                // 时间未到,释放当前引用
                first = null; // don't retain ref while waiting
                if (leader != null)
                    // leader 不为 null,说明已有线程在等队头,继续等待
                    available.await();
                else {
                    // 标记当前线程正在等待队头
                    Thread thisThread = Thread.currentThread();
                    leader = thisThread;
                    try {
                        // 继续等待队头元素
                        available.awaitNanos(delay);
                    } finally {
                        // 释放当前线程
                        if (leader == thisThread)
                            leader = null;
                    }
                }
            }
        }
    } finally {
        if (leader == null && q.peek() != null)
            // 当前线程出队成功,通知其他线程继续执行
            available.signal();
        // 释放锁
        lock.unlock();
    }
}

演示代码

示例工程

订单任务实现 Delayed,以到期时间计算剩余延迟:

/**
 * @author z201.coding@gmail.com
 **/
@Setter
@Getter
public class ItemDelayedI<T> implements Delayed {

    /**
     * 数据 id
     */
    private Long dataId;
    /**
     * 开始时间
     */
    private long startTime;
    /**
     * 到期时间
     */
    private long expire;
    /**
     * 泛型 data
     */
    private T data;

    private ItemDelayedI() {

    }

    public ItemDelayedI(Long dataId, long startTime, long expire) {
        super();
        this.dataId = dataId;
        this.startTime = startTime;
        this.expire = expire;
    }

    @Override
    public int compareTo(Delayed o) {
        // 入队时判断任务在队列中的位置,过期时间短的排在前面
        return (int) (this.getDelay(TimeUnit.MILLISECONDS) - o.getDelay(TimeUnit.MILLISECONDS));
    }

    @Override
    public long getDelay(TimeUnit unit) {
        // 和当前时间比较,判断是否过期
        return unit.convert(this.expire - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
    }

    // 重写 equals 与 hashCode,用 id 作为唯一标志,入队时做重复判断
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        ItemDelayedI<?> that = (ItemDelayedI<?>) o;

        return dataId.equals(that.dataId);
    }

    @Override
    public int hashCode() {
        return dataId.hashCode();
    }
}

工具类

/**
 * @author z201.coding@gmail.com
 **/
@Slf4j
@Lazy(false)
@Component
public class DelayOrderImpl implements DelayOrderI<OrderBo> {

    @Autowired
    @Qualifier("defExecutor")
    private ThreadPoolTaskExecutor threadPoolTaskExecutor;

    private final static DelayQueue<ItemDelayedI<OrderBo>> DELAY_QUEUE = new DelayQueue<>();

    /**
     * 初始化时启动一个线程,持续取到期订单
     */
    @PostConstruct
    public void init() {
        threadPoolTaskExecutor.execute(() -> {
            ItemDelayedI<OrderBo> orderDelayed;
            for (; ; ) {
                try {
                    orderDelayed = DELAY_QUEUE.take();
                    // 处理超时订单
                    log.info("处理超时订单 {} {}", orderDelayed.getDataId(), DateTool.conversionNowFormat());
                } catch (Exception e) {
                    log.error("执行自营超时订单的_延迟队列_异常:" + e);
                }
            }
        });
    }

    /**
     * 加入延迟消息队列
     **/
    @Override
    public boolean addToOrderDelayQueue(ItemDelayedI<OrderBo> itemDelayed) {
        return DELAY_QUEUE.add(itemDelayed);
    }

    /**
     * 加入延迟消息队列
     **/
    @Override
    public boolean addToDelayQueue(OrderBo order) {
        ItemDelayedI<OrderBo> orderDelayed = new ItemDelayedI<>(order.getId(), order.getCreateTime(), order.getOrderDeadlineTime());
        if (DELAY_QUEUE.contains(orderDelayed)) {
            return true;
        }
        log.info("添加订单超时队列 {} {}", JsonTool.toString(order), DateTool.conversionNowFormat());
        return DELAY_QUEUE.add(orderDelayed);
    }

    /**
     * 移除队列
     *
     * @param order
     */
    @Override
    public void removeToOrderDelayQueue(OrderBo order) {
        if (order == null) {
            return;
        }
        for (Iterator<ItemDelayedI<OrderBo>> iterator = DELAY_QUEUE.iterator(); iterator.hasNext(); ) {
            ItemDelayedI<OrderBo> queue = iterator.next();
            if (queue.getDataId().equals(order.getId())) {
                log.info("移除订单超时队列 {} {}", order, DateTool.conversionNowFormat());
                DELAY_QUEUE.remove(queue);
            }
        }
    }

    public void removeToOrderDelayQueueById(Long id) {
        if (id == null) {
            return;
        }
        log.info("移除订单超时队列 {} {}", id, DateTool.conversionNowFormat());
        for (Iterator<ItemDelayedI<OrderBo>> iterator = DELAY_QUEUE.iterator(); iterator.hasNext(); ) {
            ItemDelayedI<OrderBo> queue = iterator.next();
            if (queue.getDataId().equals(id)) {
                DELAY_QUEUE.remove(queue);
            }
        }
    }

    @Override
    public List<OrderBo> all() {
        List<OrderBo> list = new ArrayList<>();
        OrderBo orderBoTemp = null;
        for (Iterator<ItemDelayedI<OrderBo>> iterator = DELAY_QUEUE.iterator(); iterator.hasNext(); ) {
            ItemDelayedI<OrderBo> queue = iterator.next();
            orderBoTemp = OrderBo.builder()
                    .id(queue.getDataId())
                    .orderDeadlineTime(queue.getExpire())
                    .createTime(queue.getStartTime())
                    .build();
            list.add(orderBoTemp);
        }
        return list;
    }
}

测试代码

/**
 * @author z201.coding@gmail.com
 **/
@RestController
public class AppController {

    @Autowired
    private DelayOrderImpl delayOrder;

    @RequestMapping(value = "add/{id}")
    public Object add(@PathVariable(required = false) Long id) {
        if (null == id) {
            id = RandomUtil.randomLong(10, 1000);
        }
        OrderBo orderBo = OrderBo.builder()
                .id(id)
                .createTime(DateTool.currentTimeMillis())
                .orderDeadlineTime(DateTool.currentTimeMillis() + 1 * 60 * 1000).build();
        delayOrder.addToDelayQueue(orderBo);
        Map<String, Object> data = new HashMap<>();
        data.put("code", "200");
        data.put("data", JsonTool.toString(orderBo));
        return data;
    }

    @RequestMapping(value = "list")
    public Object list() {
        List<OrderBo> list = delayOrder.all();
        Map<String, Object> data = new HashMap<>();
        data.put("code", "200");
        data.put("data", list);
        return data;
    }

    @RequestMapping(value = "del/{id}")
    public Object del(@PathVariable(required = false) Long id) {
        delayOrder.removeToOrderDelayQueueById(id);
        List<OrderBo> list = delayOrder.all();
        Map<String, Object> data = new HashMap<>();
        data.put("code", "200");
        data.put("data", list);
        return data;
    }

}

控制台输出

➜  blog curl http://localhost:9016/delayed/add/1
➜  blog curl http://localhost:9016/delayed/add/1
➜  blog curl http://localhost:9016/delayed/add/2
➜  blog curl http://localhost:9016/delayed/add/2
➜  blog curl http://localhost:9016/delayed/list
# 相同 id 添加两次,不会重复入队
{"code":"200","data":[{"id":1,"createTime":1643699260192,"orderDeadlineTime":1643699320192},{"id":2,"createTime":1643699263491,"orderDeadlineTime":1643699323491}]}%

[XNIO-1 I/O-4]  添加订单超时队列 {"id":1,"createTime":1643699260192,"orderDeadlineTime":1643699320192} 2022-02-01 15:07:40
[XNIO-1 I/O-4]  添加订单超时队列 {"id":2,"createTime":1643699263491,"orderDeadlineTime":1643699323491} 2022-02-01 15:07:43
[def-Executor-1]  处理超时订单 1 2022-02-01 15:08:40
[def-Executor-1]  处理超时订单 2 2022-02-01 15:08:43

Redis:有序集合实现

DelayQueue 的数据只存在 JVM 内,多实例部署时不共享。实际开发中更常见的是用 Redis zset:以到期时间戳作为分值,轮询取出到期的成员。

  • 用 zrangebyscore 查询所有到期的待处理任务,循环执行;也可以每次只取最早的一条,判断执行时间是否已到。
  • zadd 写入成员与分数,成员已存在时更新分数并重新排序。
  • zrangebyscore 返回分数在 min 与 max 之间(含边界)的成员,按分数从低到高排列。
  • zrem 删除成员,返回实际删除的数量,不存在的成员不计入。

演示代码

示例工程

/**
 * @author z201.coding@gmail.com
 **/
@Slf4j
@Lazy(false)
@Component
public class DelayOrderImpl implements DelayOrderI<OrderBo> {

    private final static String ORDER_DELAY_KEY = "order:delay";

    public final static int ORDER_DELAY_TIME = 1;

    @Autowired
    @Qualifier("defExecutor")
    private ThreadPoolTaskExecutor threadPoolTaskExecutor;

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 初始化时启动一个线程,持续取出到期订单
     */
    @PostConstruct
    public void init() {
        threadPoolTaskExecutor.execute(() -> {
            log.info(" 待处理订单数量 count {} ", size());
            for (; ; ) {
                try {
                    // 取出所有已到期(分数小于等于当前时间)的成员
                    Set<Integer> data = redisTemplate.opsForZSet().rangeByScore(ORDER_DELAY_KEY, 0, DateTool.currentTimeMillis());
                    data.stream().forEach(i -> {
                        // 处理超时订单
                        log.info("处理订单 {}", i);
                        removeToOrderDelayQueueById(Long.valueOf(i));
                    });
                } catch (Exception e) {
                    log.error("执行订单的_延迟队列_异常:" + e);
                } finally {
                    try {
                        // 1 秒执行一次,实际可按精度调整
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        log.error("执行订单的_延迟队列_异常:" + e);
                    }
                }
            }
        });
    }

    @PreDestroy
    public void destroy() {
        threadPoolTaskExecutor.shutdown();
    }

    /**
     * 加入延迟消息队列
     **/
    @Override
    public boolean addToOrderDelayQueue(ItemDelayedI<OrderBo> itemDelayed) {
        log.info("添加订单超时队列 {} ", itemDelayed.getDataId());
        return redisTemplate.opsForZSet().add(ORDER_DELAY_KEY, itemDelayed.getDataId(), itemDelayed.getExpire());
    }

    /**
     * 加入延迟消息队列
     **/
    @Override
    public boolean addToDelayQueue(OrderBo order) {
        ItemDelayedI<OrderBo> orderDelayed = new ItemDelayedI<>(order.getId(), order.getCreateTime(), order.getOrderDeadlineTime());
        return addToOrderDelayQueue(orderDelayed);
    }

    /**
     * 移除队列
     *
     * @param order
     */
    @Override
    public void removeToOrderDelayQueue(OrderBo order) {
        if (null == order || null == order.getId()) {
            return;
        }
        removeToOrderDelayQueueById(order.getId());
    }

    public void removeToOrderDelayQueueById(Long id) {
        if (id == null) {
            return;
        }
        log.info("移除订单超时队列 {}", id);
        redisTemplate.opsForZSet().remove(ORDER_DELAY_KEY, id);
    }

    @Override
    public List<OrderBo> all() {
        List<OrderBo> list = new ArrayList<>();
        Map<String, Long> orderZSetMap = zScan(ORDER_DELAY_KEY, "*", 100);
        orderZSetMap.forEach((key, value) -> {
            list.add(OrderBo.builder()
                    .id(Long.valueOf(key))
                    .orderDeadlineTime(value)
                    .createTime(DateTool.conversion(DateTool.conversion(value).plusMinutes(-ORDER_DELAY_TIME)))
                    .build());
        });
        return list;
    }

    @Override
    public Long size() {
        return redisTemplate.opsForZSet().size(ORDER_DELAY_KEY);
    }

    /**
     * {@link = http://redisdoc.com/database/scan.html#zscan}
     * <p>
     * 可用版本: >= 2.8.0
     * 时间复杂度:增量式迭代每次执行的复杂度为 O(1),完整迭代为 O(N),N 为集合中的元素数量。
     *
     * @param key
     * @param pattern
     * @param count
     * @return
     */
    private Map<String, Long> zScan(String key, String pattern, Integer count) {
        Map<String, Long> map = new HashMap<>();
        RedisSerializer<String> stringRedisSerializer = redisTemplate.getStringSerializer();
        RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
        ScanOptions scanOptions = ScanOptions.scanOptions()
                .match(pattern)
                .count(count)
                .build();
        Cursor<RedisZSetCommands.Tuple> cursor = connection.zScan(stringRedisSerializer.serialize(key), scanOptions);
        while (cursor.hasNext()) {
            RedisZSetCommands.Tuple data = cursor.next();
            if (null != data) {
                map.put(stringRedisSerializer.deserialize(data.getValue()), data.getScore().longValue());
            }
        }
        return map;
    }
}

控制台输出

curl http://127.0.0.1:9033/add/3
{"code":"200","data":3}%
[XNIO-1 task-1] [DelayOrderImpl.java : 83] 添加订单超时队列 787
[XNIO-1 task-1] [DelayOrderImpl.java : 83] 添加订单超时队列 815
[XNIO-1 task-1] [DelayOrderImpl.java : 83] 添加订单超时队列 689
[def-Executor-1] [DelayOrderImpl.java : 57] 处理订单 787
[def-Executor-1] [DelayOrderImpl.java : 113] 移除订单超时队列 787
[def-Executor-1] [DelayOrderImpl.java : 57] 处理订单 815
[def-Executor-1] [DelayOrderImpl.java : 113] 移除订单超时队列 815
[def-Executor-1] [DelayOrderImpl.java : 57] 处理订单 689
[def-Executor-1] [DelayOrderImpl.java : 113] 移除订单超时队列 689

两种方案怎么选

维度DelayQueueRedis 有序集合
数据位置JVM 内存,单实例Redis,多实例共享
持久化无,重启丢失随 Redis 持久化策略保留
触发方式take 按到期时间精确阻塞定时轮询,精度取决于轮询间隔
重复消费单实例内去重多实例同时轮询会重复消费,需要额外互斥

只有单机任务时,DelayQueue 依赖 JDK、无外部组件,足够简单;需要跨实例或重启不丢任务时,用 Redis zset,并补上分布式锁或 zrem 的返回值判断,避免重复处理。

小结

DelayQueue 用优先级队列按到期时间排序,offer 在队头变化时唤醒等待线程,take 通过 leader 标记避免多个线程重复等待;Redis 方案以到期时间戳作分数,zadd 入队、rangeByScore 取到期成员、zrem 出队,代价是轮询精度与多实例互斥需要自己处理。

最近更新: 2026/11/20 22:30
Contributors: 庆峰
Prev
网络通信:TCP/IP 与 HTTP 基础
Next
MySQL 基础:员工库导入实践