首页
所有分类
TAGS
文字工具 EMOJI BIBLE
数据库 Redis

基于Redis延迟队列的实现代码

Posted in Redis onMay 13, 2021

使用场景

工作中大家往往会遇到类似的场景：

1.对于红包场景，账户 A 对账户 B 发出红包通常在 1 天后会自动归还到原账户。

2.对于实时支付场景，如果账户 A 对商户 S 付款 100 元，5秒后没有收到支付方回调将自动取消订单。

解决方案分析

方案一：

采用通过定时任务采用数据库/非关系型数据库轮询方案。

优点：

1. 实现简单，对于项目前期这样是最容易的解决方案。

缺点：

1. DB 有效使用率低，需要将一部分的数据库的QPS分配给 JOB 的无效轮询。

2. 服务资源浪费，因为轮询需要对所有的数据做一次 SCAN 扫描 JOB 服务的资源开销很大。

方案二：

采用延迟队列：

优点：

1. 服务的资源使用率较高，能够精确的实现超时任务的执行。

2. 减少 DB 的查询次数，能够降低数据库的压力

缺点：

1. 对于延迟队列来说本身设计比较复杂，目前没有通用的比较好过的方案。

基于 Redis 的延迟队列实现

基于以上的分析，我决定通过 Redis 来实现分布式队列。

设计思路：

基于Redis延迟队列的实现代码

1. 第一步将需要发放的消息发送到延迟队列中。

2. 延迟队列将数据存入 Redis 的 ZSet 有序集合中score 为当前时间戳，member 存入需要发送的数据。

3. 添加一个 schedule 来进行对 Redis 有序队列的轮询。

4. 如果到达达到消息的执行时间，那么就进行业务的执行。

5. 如果没有达到消息的执行是将，那么消息等待下轮执行。

实现步骤：

由于本处篇幅有限，所以只列举部分代码，完整的代码可以在本文最后访问 GitHub 获取。由于本人阅历/水平有限，如有建议/或更正欢迎留言或提问。先在此谢谢大家驻足阅读 ? ? ?。

需要注意的问题：

单个 Redis 命令的执行是原子性的，但 Redis 没有在事务上增加任何维持原子性的机制，所以 Redis 事务的执行并不是原子性的。

事务可以理解为一个打包的批量执行脚本，但批量指令并非原子化的操作，中间某条指令的失败不会导致前面已做指令的回滚，也不会造成后续的指令不做。

我们可以通过 Redis 的 eval 命令来执行 lua 脚本来保证原子性实现Redis的事务。

实现步骤如下：

1. 延迟队列接口

/**
 * 延迟队列
 *
 * @author zhengsh
 * @date 2020-03-27
 */
public interface RedisDelayQueue<E extends DelayMessage> {

    String META_TOPIC_WAIT = "delay:meta:topic:wait";
    String META_TOPIC_ACTIVE = "delay:meta:topic:active";
    String TOPIC_ACTIVE = "delay:active:9999";
    /**
     * 拉取消息
     */
    void poll();

    /**
     * 推送延迟消息
     *
     * @param e
     */
    void push(E e);
}

2. 延迟队列消息

/**
 * 消息体
 *
 * @author zhengsh
 * @date 2020-03-27
 */
@Setter
@Getter
public class DelayMessage {
    /**
     * 消息唯一标识
     */
    private String id;
    /**
     * 消息主题
     */
    private String topic = "default";
    /**
     * 具体消息 json
     */
    private String body;
    /**
     * 延时时间, 格式为时间戳: 当前时间戳 + 实际延迟毫秒数
     */
    private Long delayTime = System.currentTimeMillis() + 30000L;
    /**
     * 消息发送时间
     */
    private LocalDateTime createTime;
}

3. 延迟队列实现

/**
 * 延迟队列实现
 *
 * @author zhengsh
 * @date 2020-03-27
 */
@Component
public class RedisDelayQueueImpl<E extends DelayMessage> implements RedisDelayQueue<E> {
    private Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private StringRedisTemplate redisTemplate;

    @Override
    public void poll() {
        // todo
    }

    /**
     * 发送消息
     *
     * @param e
     */
    @SneakyThrows
    @Override
    public void push(E e) {
        try {
            String jsonStr = JSON.toJSONString(e);
            String topic = e.getTopic();
            String zkey = String.format("delay:wait:%s", topic);
            String u =
                    "redis.call('sadd', KEYS[1], ARGV[1])\n" +
                            "redis.call('zadd', KEYS[2], ARGV[2], ARGV[3])\n" +
                            "return 1";

            Object[] keys = new Object[]{serialize(META_TOPIC_WAIT), serialize(zkey)};
            Object[] values = new Object[]{ serialize(zkey), serialize(String.valueOf(e.getDelayTime())),serialize(jsonStr)};

            Long result = redisTemplate.execute((RedisCallback<Long>) connection -> {
                Object nativeConnection = connection.getNativeConnection();

                if (nativeConnection instanceof RedisAsyncCommands) {
                    RedisAsyncCommands commands = (RedisAsyncCommands) nativeConnection;
                    return (Long) commands.getStatefulConnection().sync().eval(u, ScriptOutputType.INTEGER, keys, values);
                } else if (nativeConnection instanceof RedisAdvancedClusterAsyncCommands) {
                    RedisAdvancedClusterAsyncCommands commands = (RedisAdvancedClusterAsyncCommands) nativeConnection;
                    return (Long) commands.getStatefulConnection().sync().eval(u, ScriptOutputType.INTEGER, keys, values);
                }
                return 0L;
            });
            logger.info("延迟队列[1]，消息推送成功进入等待队列({}), topic: {}", result != null && result > 0, e.getTopic());
        } catch (Throwable t) {
            t.printStackTrace();
        }
    }

    private byte[] serialize(String key) {
        RedisSerializer<String> stringRedisSerializer =
                (RedisSerializer<String>) redisTemplate.getKeySerializer();
        //lettuce连接包下序列化键值，否则无法用默认的ByteArrayCodec解析
        return stringRedisSerializer.serialize(key);
    }
}

4. 定时任务

/**
 * 分发任务
 */
@Component
public class DistributeTask {

    private static final String LUA_SCRIPT;
    private Logger logger = LoggerFactory.getLogger(getClass());
    @Autowired
    private StringRedisTemplate redisTemplate;

    static {
        StringBuilder sb = new StringBuilder(128);
        sb.append("local val = redis.call('zrangebyscore', KEYS[1], '-inf', ARGV[1], 'limit', 0, 1)\n");
        sb.append("if(next(val) ~= nil) then\n");
        sb.append("    redis.call('sadd', KEYS[2], ARGV[2])\n");
        sb.append("    redis.call('zremrangebyrank', KEYS[1], 0, #val - 1)\n");
        sb.append("    for i = 1, #val, 100 do\n");
        sb.append("        redis.call('rpush', KEYS[3], unpack(val, i, math.min(i+99, #val)))\n");
        sb.append("    end\n");
        sb.append("    return 1\n");
        sb.append("end\n");
        sb.append("return 0");
        LUA_SCRIPT = sb.toString();
    }

    /**
     * 2秒钟扫描一次执行队列
     */
    @Scheduled(cron = "0/5 * * * * ?")
    public void scheduledTaskByCorn() {
        try {
            Set<String> members = redisTemplate.opsForSet().members(META_TOPIC_WAIT);
            assert members != null;
            for (String k : members) {
                if (!redisTemplate.hasKey(k)) {
                    // 如果 KEY 不存在元数据中删除
                    redisTemplate.opsForSet().remove(META_TOPIC_WAIT, k);
                    continue;
                }

                String lk = k.replace("delay:wait", "delay:active");
                Object[] keys = new Object[]{serialize(k), serialize(META_TOPIC_ACTIVE), serialize(lk)};
                Object[] values = new Object[]{serialize(String.valueOf(System.currentTimeMillis())), serialize(lk)};
                Long result = redisTemplate.execute((RedisCallback<Long>) connection -> {
                    Object nativeConnection = connection.getNativeConnection();

                    if (nativeConnection instanceof RedisAsyncCommands) {
                        RedisAsyncCommands commands = (RedisAsyncCommands) nativeConnection;
                        return (Long) commands.getStatefulConnection().sync().eval(LUA_SCRIPT, ScriptOutputType.INTEGER, keys, values);
                    } else if (nativeConnection instanceof RedisAdvancedClusterAsyncCommands) {
                        RedisAdvancedClusterAsyncCommands commands = (RedisAdvancedClusterAsyncCommands) nativeConnection;
                        return (Long) commands.getStatefulConnection().sync().eval(LUA_SCRIPT, ScriptOutputType.INTEGER, keys, values);
                    }
                    return 0L;
                });
                logger.info("延迟队列[2]，消息到期进入执行队列({}): {}", result != null && result > 0, TOPIC_ACTIVE);
            }
        } catch (Throwable t) {
            t.printStackTrace();
        }
    }

    private byte[] serialize(String key) {
        RedisSerializer<String> stringRedisSerializer =
                (RedisSerializer<String>) redisTemplate.getKeySerializer();
        //lettuce连接包下序列化键值，否则无法用默认的ByteArrayCodec解析
        return stringRedisSerializer.serialize(key);
    }
}

GitHub 地址

https://github.com/zhengsh/redis-delay-queue

参考地址

1.https://www.runoob.com/redis/redis-transactions.html

到此这篇关于基于Redis延迟队列的实现代码的文章就介绍到这了,更多相关Redis 延迟队列内容请搜索三水点靠木以前的文章或继续浏览下面的相关文章希望大家以后多多支持三水点靠木！

基于Redis延迟队列的实现代码

- Author -

程序员老郑

声明：登载此文出于传递更多信息之目的，并不意味着赞同其观点或证实其描述。

Redis 相关文章推荐
Redis Cluster 字段模糊匹配及删除
May 27 Redis
浅谈Redis主从复制以及主从复制原理
May 29 Redis
SpringBoot 集成Redis 过程
Jun 02 Redis
Redis性能监控的实现
Jul 09 Redis
Redis Cluster集群动态扩容的实现
Jul 15 Redis
关于使用Redisson订阅数问题
Jan 18 Redis
redis调用二维码时的不断刷新排查分析
Apr 01 Redis
Grafana可视化监控系统结合SpringBoot使用
Apr 19 Redis
muduo TcpServer模块源码分析
Apr 26 Redis
Redis 报错 error:NOAUTH Authentication required
May 15 Redis
浅谈Redis变慢的原因及排查方法
Jun 21 Redis
如何使用注解方式实现 Redis 分布式锁
Jul 23 Redis
基于Redis实现分布式锁的方法（lua脚本版）
redis三种高可用方式部署的实现
May 11 #Redis
Redis数据结构之链表与字典的使用
基于Redis位图实现用户签到功能
May 08 #Redis
基于Redis过期事件实现订单超时取消
May 08 #Redis
Redis实现订单自动过期功能的示例代码
May 08 #Redis
redis 限制内存使用大小的实现
矿石收音机(1) 沃尔沃(1) 军机(1) 66-XI(1) S900(1) ETON(1) R601SW(1) VOLVO(1) E1-XM(1) 放大器(1)
You might like
ThinkPHP 连接Oracle数据库的详细教程[全]
2012/07/16 PHP
PHP入门之常量简介和系统常量
2014/05/12 PHP
ThinkPHP框架实现session跨域问题的解决方法
2014/07/01 PHP
Laravel 5框架学习之Eloquent （laravel 的ORM）
2015/04/08 PHP
PHP实现数组array转换成xml的方法
2016/07/19 PHP
PHP实现的redis主从数据库状态检测功能示例
2017/07/20 PHP
PHP实现链式操作的三种方法详解
2017/11/16 PHP
在IE6下发生Internet Explorer cannot open the Internet site错误
2010/06/21 Javascript
jQuery Tab插件 用于在Tab中显示iframe，附源码和详细说明
2011/06/27 Javascript
js定时器(执行一次、重复执行)
2014/03/07 Javascript
node.js中的querystring.parse方法使用说明
2014/12/10 Javascript
深入理解JavaScript系列（29）：设计模式之装饰者模式详解
2015/03/03 Javascript
学习JavaScript事件流和事件处理程序
2016/01/25 Javascript
基于JavaScript实现全屏透明遮罩div层锁屏效果
2016/01/26 Javascript
jQuery实现鼠标经过时高亮,同时其他同级元素变暗的效果
2016/09/18 Javascript
Angular限制input框输入金额（是小数的话只保留两位小数点）
2017/07/13 Javascript
vue.js的手脚架vue-cli项目搭建的步骤
2017/08/30 Javascript
vue-router路由懒加载的实现（解决vue项目首次加载慢）
2018/08/28 Javascript
小程序云开发之用户注册登录
2019/05/18 Javascript
Element Card 卡片的具体使用
2020/07/26 Javascript
Javascript var变量删除原理及实现
2020/08/26 Javascript
three.js中多线程的使用及性能测试详解
2021/01/07 Javascript
python处理圆角图片、圆形图片的例子
2014/04/25 Python
Tensorflow 自带可视化Tensorboard使用方法(附项目代码)
2018/02/10 Python
Python进阶之全面解读高级特性之切片
2019/02/19 Python
python代码实现将列表中重复元素之间的内容全部滤除
2020/05/22 Python
Python3爬虫中识别图形验证码的实例讲解
2020/07/30 Python
Pytorch实验常用代码段汇总
2020/11/19 Python
铣床操作工岗位职责
2014/06/13 职场文书
大学生党员自我批评思想汇报
2014/10/10 职场文书
给老婆的检讨书（搞笑版）
2015/05/06 职场文书
2015年乡镇财政工作总结
2015/05/19 职场文书
吃通javascript正则表达式
2021/04/21 Javascript
HTML基础详解(上)
2021/10/16 HTML / CSS
Android Flutter实现图片滑动切换效果
2022/04/07 Java/Android
图神经网络GNN算法
2022/05/11 Python