redssion 延迟队列源码分析

最新推荐文章于 2025-04-04 18:14:10 发布
最新推荐文章于 2025-04-04 18:14:10 发布
阅读量3k 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： JAVA redis 文章标签： redis 数据库 database
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/xuyw10000/article/details/121311133
本文详细探讨了Redisson延迟队列的工作原理，通过一个简单的Java demo展示了其使用方式。Redisson延迟队列基于Redis实现，利用ZSet存储延迟触发时间，并结合Lua脚本确保操作原子性。在客户端，数据首先被添加到延迟队列，然后定时任务会检查并处理已到期的延迟任务，将它们推送到阻塞队列供消费者消费。整个流程高效且易于使用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

         redssion 是个优秀的开源框架，里面实现了很多常用的redis操作。例 分布式锁及分布式延时队列，api使用操作简单，功能十分强大。

 如果想进一步了解可访问目录 · redisson/redisson Wiki · GitHub

        本次主要研究分析延迟队列的实现，废话不多说先上个简单的demo。

package com.xuyw.redisson;

import lombok.extern.slf4j.Slf4j;
import org.redisson.Redisson;
import org.redisson.api.RBlockingDeque;
import org.redisson.api.RDelayedQueue;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;

import java.util.concurrent.TimeUnit;

/**
 * Date: 2021-11-13 下午 9:44 <br>
 * Copyright (c) 2021 0ne.xu
 *
 * @author xuyw
 */
@Slf4j
public class DelayedQueueTest {
    public static void main(String[] args) throws InterruptedException {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379");
        RedissonClient redissonClient = Redisson.create(config);
        RBlockingDeque<String> blockingDeque = redissonClient.getBlockingDeque("one.delayed.queue");
        RDelayedQueue<String> delayedQueue = redissonClient.getDelayedQueue(blockingDeque);
        //添加延时消息
        delayedQueue.offer("测试消息1", 10, TimeUnit.SECONDS);
        delayedQueue.offerAsync("测试消息offerAsync", 20, TimeUnit.SECONDS);
        //获取延时消息
        while (true) {
            String msg = blockingDeque.take();
            log.debug("获取延时队列消息:{}",msg);
        }
    }
}

上述代码已经是一个简单的api使用，短短十来行代码就实现了一个延迟队列的功能。阅读源码发现大概执行过程是这样的

  • 延时队列list：数据入队的队列
  • 目标队列list：过期数据所在的队列
  • timeoutSet过期时间zset：分数值为延时触发时间毫秒数

那么redssion 都帮我们干了些什么事呢？我们来调试分析。执行代码控制台输出日志，都是执行lua脚本。

3:36:37.535 [redisson-netty-1-2] DEBUG io.netty.util.ResourceLeakDetectorFactory - Loaded default ResourceLeakDetector: io.netty.util.ResourceLeakDetector@1d0b9f08
23:36:37.569 [redisson-3-1] DEBUG org.redisson.command.CommandAsyncService - acquired connection for command (EVAL) and params [local expiredValues = redis.call('zrangebyscore', KEYS[2], 0, ARGV[1], 'limit', 0, ARGV[2]); if #exp..., 3, one.delayed.queue, redisson_delay_queue_timeout:{one.delayed.queue}, redisson_delay_queue:{one.delayed.queue}, 1636817797562, 100] from slot NodeSource [slot=null, addr=null, redisClient=null, redirect=null, entry=MasterSlaveEntry [masterEntry=[freeSubscribeConnectionsAmount=0, freeSubscribeConnectionsCounter=value:49:queue:0, freeConnectionsAmount=31, freeConnectionsCounter=value:63:queue:0, freezed=false, freezeReason=null, client=[addr=redis://127.0.0.1:6379], nodeType=MASTER, firstFail=0]]] using node 127.0.0.1/127.0.0.1:6379... RedisConnection@132632920 [redisClient=[addr=redis://127.0.0.1:6379], channel=[id: 0x7aa30e46, L:/127.0.0.1:57187 - R:127.0.0.1/127.0.0.1:6379], command=null]
23:36:37.577 [redisson-3-1] DEBUG org.redisson.command.CommandAsyncService - connection released for command (EVAL) and params [local expiredValues = redis.call('zrangebyscore', KEYS[2], 0, ARGV[1], 'limit', 0, ARGV[2]); if #exp..., 3, one.delayed.queue, redisson_delay_queue_timeout:{one.delayed.queue}, redisson_delay_queue:{one.delayed.queue}, 1636817797562, 100] from slot NodeSource [slot=null, addr=null, redisClient=null, redirect=null, entry=MasterSlaveEntry [masterEntry=[freeSubscribeConnectionsAmount=0, freeSubscribeConnectionsCounter=value:49:queue:0, freeConnectionsAmount=32, freeConnectionsCounter=value:64:queue:0, freezed=false, freezeReason=null, client=[addr=redis://127.0.0.1:6379], nodeType=MASTER, firstFail=0]]] using connection RedisConnection@132632920 [redisClient=[addr=redis://127.0.0.1:6379], channel=[id: 0x7aa30e46, L:/127.0.0.1:57187 - R:127.0.0.1/127.0.0.1:6379], command=null]
23:36:37.611 [main] DEBUG org.redisson.command.CommandAsyncService - acquired connection for command (EVAL) and params [local value = struct.pack('dLc0', tonumber(ARGV[2]), string.len(ARGV[3]), ARGV[3]);redis.call('zadd'..., 4, one.delayed.queue, redisson_delay_queue_timeout:{one.delayed.queue}, redisson_delay_queue:{one.delayed.queue}, redisson_delay_queue_channel:{one.delayed.queue}, 1636817807586, 3140263111307140513, PooledUnsafeDirectByteBuf(ridx: 0, widx: 15, cap: 256)] from slot NodeSource [slot=null, addr=null, redisClient=null, redirect=null, entry=MasterSlaveEntry [masterEntry=[freeSubscribeConnectionsAmount=0, freeSubscribeConnectionsCounter=value:49:queue:0, freeConnectionsAmount=31, freeConnectionsCounter=value:63:queue:0, freezed=false, freezeReason=null, client=[addr=redis://127.0.0.1:6379], nodeType=MASTER, firstFail=0]]] using node 127.0.0.1/127.0.0.1:6379... RedisConnection@1470699934 [redisClient=[addr=redis://127.0.0.1:6379], channel=[id: 0x9b0b1d00, L:/127.0.0.1:57189 - R:127.0.0.1/127.0.0.1:6379], command=null]
23:36:37.614 [redisson-netty-1-3] DEBUG org.redisson.command.CommandAsyncService - connection released for command (EVAL) and params [local value = struct.pack('dLc0', tonumber(ARGV[2]), string.len(ARGV[3]), ARGV[3]);redis.call('zadd'..., 4, one.delayed.queue, redisson_delay_queue_timeout:{one.delayed.queue}, redisson_delay_queue:{one.delayed.queue}, redisson_delay_queue_channel:{one.delayed.queue}, 1636817807586, 3140263111307140513, PooledUnsafeDirectByteBuf(ridx: 0, widx: 15, cap: 256)] from slot NodeSource [slot=null, addr=null, redisClient=null, redirect=null, entry=MasterSlaveEntry [masterEntry=[freeSubscribeConnectionsAmount=0, freeSubscribeConnectionsCounter=value:49:queue:0, freeConnectionsAmount=32, freeConnectionsCounter=value:64:queue:0, freezed=false, freezeReason=null, client=[addr=redis://127.0.0.1:6379], nodeType=MASTER, firstFail=0]]] using connection RedisConnection@1470699934 [redisClient=[addr=redis://127.0.0.1:6379], channel=[id: 0x9b0b1d00, L:/127.0.0.1:57189 - R:127.0.0.1/127.0.0.1:6379], command=CommandData [promise=RedissonPromise [promise=ImmediateEventExecutor$ImmediatePromise@39d57856(success)], command=(EVAL), params=[local value = struct.pack('dLc0', tonumber(ARGV[2]), string.len(ARGV[3]), ARGV[3]);redis.call('zadd'..., 4, one.delayed.queue, redisson_delay_queue_timeout:{one.delayed.queue}, redisson_delay_queue:{one.delayed.queue}, redisson_delay_queue_channel:{one.delayed.queue}, 1636817807586, 3140263111307140513, PooledUnsafeDirectByteBuf(ridx: 0, widx: 15, cap: 256)], codec=org.redisson.codec.FstCodec]]
23:36:37.615 [main] DEBUG org.redisson.command.CommandAsyncService - acquired connection for command (EVAL) and params [local value = struct.pack('dLc0', tonumber(ARGV[2]), string.len(ARGV[3]), ARGV[3]);redis.call('zadd'..., 4, one.delayed.queue, redisson_delay_queue_timeout:{one.delayed.queue}, redisson_delay_queue:{one.delayed.queue}, redisson_delay_queue_channel:{one.delayed.queue}, 1636817817615, 7572321326843145784, PooledUnsafeDirectByteBuf(ridx: 0, widx: 24, cap: 256)] from slot NodeSource [slot=null, addr=null, redisClient=null, redirect=null, entry=MasterSlaveEntry [masterEntry=[freeSubscribeConnectionsAmount=0, freeSubscribeConnectionsCounter=value:49:queue:0, freeConnectionsAmount=31, freeConnectionsCounter=value:63:queue:0, freezed=false, freezeReason=null, client=[addr=redis://127.0.0.1:6379], nodeType=MASTER, firstFail=0]]] using node 127.0.0.1/127.0.0.1:6379... RedisConnection@1265052639 [redisClient=[addr=redis://127.0.0.1:6379], channel=[id: 0x0945bf7b, L:/127.0.0.1:57190 - R:127.0.0.1/127.0.0.1:6379], command=null]
23:36:37.616 [main] DEBUG org.redisson.command.CommandAsyncService - acquired connection for command (BLPOP) and params [one.delayed.queue, 0] from slot NodeSource [slot=null, addr=null, redisClient=null, redirect=null, entry=MasterSlaveEntry [masterEntry=[freeSubscribeConnectionsAmount=0, freeSubscribeConnectionsCounter=value:49:queue:0, freeConnectionsAmount=30, freeConnectionsCounter=value:62:queue:0, freezed=false, freezeReason=null, client=[addr=redis://127.0.0.1:6379], nodeType=MASTER, firstFail=0]]] using node 127.0.0.1/127.0.0.1:6379... RedisConnection@1217958627 [redisClient=[addr=redis://127.0.0.1:6379], channel=[id: 0x167bf181, L:/127.0.0.1:57191 - R:127.0.0.1/127.0.0.1:6379], command=null]
23:36:37.623 [redisson-netty-1-6] DEBUG org.redisson.command.CommandAsyncService - connection released for command (EVAL) and params [local value = struct.pack('dLc0', tonumber(ARGV[2]), string.len(ARGV[3]), ARGV[3]);redis.call('zadd'..., 4, one.delayed.queue, redisson_delay_queue_timeout:{one.delayed.queue}, redisson_delay_queue:{one.delayed.queue}, redisson_delay_queue_channel:{one.delayed.queue}, 1636817817615, 7572321326843145784, PooledUnsafeDirectByteBuf(ridx: 0, widx: 24, cap: 256)] from slot NodeSource [slot=null, addr=null, redisClient=null, redirect=null, entry=MasterSlaveEntry [masterEntry=[freeSubscribeConnectionsAmount=0, freeSubscribeConnectionsCounter=value:49:queue:0, freeConnectionsAmount=31, freeConnectionsCounter=value:63:queue:0, freezed=false, freezeReason=null, client=[addr=redis://127.0.0.1:6379], nodeType=MASTER, firstFail=0]]] using connection RedisConnection@1265052639 [redisClient=[addr=redis://127.0.0.1:6379], channel=[id: 0x0945bf7b, L:/127.0.0.1:57190 - R:127.0.0.1/127.0.0.1:6379], command=CommandData [promise=RedissonPromise [promise=ImmediateEventExecutor$ImmediatePromise@302dbc5a(success)], command=(EVAL), params=[local value = struct.pack('dLc0', tonumber(ARGV[2]), string.len(ARGV[3]), ARGV[3]);redis.call('zadd'..., 4, one.delayed.queue, redisson_delay_queue_timeout:{one.delayed.queue}, redisson_delay_queue:{one.delayed.queue}, redisson_delay_queue_channel:{one.delayed.queue}, 1636817817615, 7572321326843145784, PooledUnsafeDirectByteBuf(ridx: 0, widx: 24, cap: 256)], codec=org.redisson.codec.FstCodec]]
23:36:47.611 [pool-1-thread-1] DEBUG org.redisson.command.CommandAsyncService - acquired connection for command (EVAL) and params [local expiredValues = redis.call('zrangebyscore', KEYS[2], 0, ARGV[1], 'limit', 0, ARGV[2]); if #exp..., 3, one.delayed.queue, redisson_delay_queue_timeout:{one.delayed.queue}, redisson_delay_queue:{one.delayed.queue}, 1636817807611, 100] from slot NodeSource [slot=null, addr=null, redisClient=null, redirect=null, entry=MasterSlaveEntry [masterEntry=[freeSubscribeConnectionsAmount=0, freeSubscribeConnectionsCounter=value:49:queue:0, freeConnectionsAmount=30, freeConnectionsCounter=value:62:queue:0, freezed=false, freezeReason=null, client=[addr=redis://127.0.0.1:6379], nodeType=MASTER, firstFail=0]]] using node 127.0.0.1/127.0.0.1:6379... RedisConnection@1012049217 [redisClient=[addr=redis://127.0.0.1:6379], channel=[id: 0x0f0824cf, L:/127.0.0.1:57188 - R:127.0.0.1/127.0.0.1:6379], command=null]
23:36:47.624 [redisson-netty-1-19] DEBUG org.redisson.command.CommandAsyncService - connection released for command (EVAL) and params [local expiredValues = redis.call('zrangebyscore', KEYS[2], 0, ARGV[1], 'limit', 0, ARGV[2]); if #exp..., 3, one.delayed.queue, redisson_delay_queue_timeout:{one.delayed.queue}, redisson_delay_queue:{one.delayed.queue}, 1636817807611, 100] from slot NodeSource [slot=null, addr=null, redisClient=null, redirect=null, entry=MasterSlaveEntry [masterEntry=[freeSubscribeConnectionsAmount=0, freeSubscribeConnectionsCounter=value:49:queue:0, freeConnectionsAmount=31, freeConnectionsCounter=value:63:queue:0, freezed=false, freezeReason=null, client=[addr=redis://127.0.0.1:6379], nodeType=MASTER, firstFail=0]]] using connection RedisConnection@1012049217 [redisClient=[addr=redis://127.0.0.1:6379], channel=[id: 0x0f0824cf, L:/127.0.0.1:57188 - R:127.0.0.1/127.0.0.1:6379], command=CommandData [promise=RedissonPromise [promise=ImmediateEventExecutor$ImmediatePromise@52344caf(success: 1636817817615)], command=(EVAL), params=[local expiredValues = redis.call('zrangebyscore', KEYS[2], 0, ARGV[1], 'limit', 0, ARGV[2]); if #exp..., 3, one.delayed.queue, redisson_delay_queue_timeout:{one.delayed.queue}, redisson_delay_queue:{one.delayed.queue}, 1636817807611, 100], codec=org.redisson.client.codec.LongCodec]]
23:36:47.636 [redisson-netty-1-26] DEBUG org.redisson.command.CommandAsyncService - connection released for command (BLPOP) and params [one.delayed.queue, 0] from slot NodeSource [slot=null, addr=null, redisClient=null, redirect=null, entry=MasterSlaveEntry [masterEntry=[freeSubscribeConnectionsAmount=0, freeSubscribeConnectionsCounter=value:49:queue:0, freeConnectionsAmount=32, freeConnectionsCounter=value:64:queue:0, freezed=false, freezeReason=null, client=[addr=redis://127.0.0.1:6379], nodeType=MASTER, firstFail=0]]] using connection RedisConnection@1217958627 [redisClient=[addr=redis://127.0.0.1:6379], channel=[id: 0x167bf181, L:/127.0.0.1:57191 - R:127.0.0.1/127.0.0.1:6379], command=CommandData [promise=RedissonPromise [promise=ImmediateEventExecutor$ImmediatePromise@d6ad958(success: 测试消息1)], command=(BLPOP), params=[one.delayed.queue, 0], codec=org.redisson.codec.FstCodec]]
23:36:47.637 [main] DEBUG com.example.spring_api.redisson.DelayedQueueTest - 获取延时队列消息:测试消息1
23:36:47.638 [main] DEBUG org.redisson.command.CommandAsyncService - acquired connection for command (BLPOP) and params [one.delayed.queue, 0] from slot NodeSource [slot=null, addr=null, redisClient=null, redirect=null, entry=MasterSlaveEntry [masterEntry=[freeSubscribeConnectionsAmount=0, freeSubscribeConnectionsCounter=value:49:queue:0, freeConnectionsAmount=31, freeConnectionsCounter=value:63:queue:0, freezed=false, freezeReason=null, client=[addr=redis://127.0.0.1:6379], nodeType=MASTER, firstFail=0]]] using node 127.0.0.1/127.0.0.1:6379... RedisConnection@1901855448 [redisClient=[addr=redis://127.0.0.1:6379], channel=[id: 0xd013455f, L:/127.0.0.1:57198 - R:127.0.0.1/127.0.0.1:6379], command=null]
23:36:57.711 [pool-1-thread-1] DEBUG org.redisson.command.CommandAsyncService - acquired connection for command (EVAL) and params [local expiredValues = redis.call('zrangebyscore', KEYS[2], 0, ARGV[1], 'limit', 0, ARGV[2]); if #exp..., 3, one.delayed.queue, redisson_delay_queue_timeout:{one.delayed.queue}, redisson_delay_queue:{one.delayed.queue}, 1636817817710, 100] from slot NodeSource [slot=null, addr=null, redisClient=null, redirect=null, entry=MasterSlaveEntry [masterEntry=[freeSubscribeConnectionsAmount=0, freeSubscribeConnectionsCounter=value:49:queue:0, freeConnectionsAmount=30, freeConnectionsCounter=value:62:queue:0, freezed=false, freezeReason=null, client=[addr=redis://127.0.0.1:6379], nodeType=MASTER, firstFail=0]]] using node 127.0.0.1/127.0.0.1:6379... RedisConnection@1633518428 [redisClient=[addr=redis://127.0.0.1:6379], channel=[id: 0x30e6c529, L:/127.0.0.1:57194 - R:127.0.0.1/127.0.0.1:6379], command=null]
23:36:57.722 [redisson-netty-1-10] DEBUG org.redisson.command.CommandAsyncService - connection released for command (EVAL) and params [local expiredValues = redis.call('zrangebyscore', KEYS[2], 0, ARGV[1], 'limit', 0, ARGV[2]); if #exp..., 3, one.delayed.queue, redisson_delay_queue_timeout:{one.delayed.queue}, redisson_delay_queue:{one.delayed.queue}, 1636817817710, 100] from slot NodeSource [slot=null, addr=null, redisClient=null, redirect=null, entry=MasterSlaveEntry [masterEntry=[freeSubscribeConnectionsAmount=0, freeSubscribeConnectionsCounter=value:49:queue:0, freeConnectionsAmount=31, freeConnectionsCounter=value:63:queue:0, freezed=false, freezeReason=null, client=[addr=redis://127.0.0.1:6379], nodeType=MASTER, firstFail=0]]] using connection RedisConnection@1633518428 [redisClient=[addr=redis://127.0.0.1:6379], channel=[id: 0x30e6c529, L:/127.0.0.1:57194 - R:127.0.0.1/127.0.0.1:6379], command=CommandData [promise=RedissonPromise [promise=ImmediateEventExecutor$ImmediatePromise@2fda92b1(success: 1636849100849)], command=(EVAL), params=[local expiredValues = redis.call('zrangebyscore', KEYS[2], 0, ARGV[1], 'limit', 0, ARGV[2]); if #exp..., 3, one.delayed.queue, redisson_delay_queue_timeout:{one.delayed.queue}, redisson_delay_queue:{one.delayed.queue}, 1636817817710, 100], codec=org.redisson.client.codec.LongCodec]]
23:36:57.731 [redisson-netty-1-5] DEBUG org.redisson.command.CommandAsyncService - connection released for command (BLPOP) and params [one.delayed.queue, 0] from slot NodeSource [slot=null, addr=null, redisClient=null, redirect=null, entry=MasterSlaveEntry [masterEntry=[freeSubscribeConnectionsAmount=0, freeSubscribeConnectionsCounter=value:49:queue:0, freeConnectionsAmount=32, freeConnectionsCounter=value:64:queue:0, freezed=false, freezeReason=null, client=[addr=redis://127.0.0.1:6379], nodeType=MASTER, firstFail=0]]] using connection RedisConnection@1901855448 [redisClient=[addr=redis://127.0.0.1:6379], channel=[id: 0xd013455f, L:/127.0.0.1:57198 - R:127.0.0.1/127.0.0.1:6379], command=CommandData [promise=RedissonPromise [promise=ImmediateEventExecutor$ImmediatePromise@5f0c0d5b(success: 测试消息offerAsync)], command=(BLPOP), params=[one.delayed.queue, 0], codec=org.redisson.codec.FstCodec]]
23:36:57.732 [main] DEBUG com.example.spring_api.redisson.DelayedQueueTest - 获取延时队列消息:测试消息offerAsync
23:36:57.732 [main] DEBUG org.redisson.command.CommandAsyncService - acquired connection for command (BLPOP) and params [one.delayed.queue, 0] from slot NodeSource [slot=null, addr=null, redisClient=null, redirect=null, entry=MasterSlaveEntry [masterEntry=[freeSubscribeConnectionsAmount=0, freeSubscribeConnectionsCounter=value:49:queue:0, freeConnectionsAmount=31, freeConnectionsCounter=value:63:queue:0, freezed=false, freezeReason=null, client=[addr=redis://127.0.0.1:6379], nodeType=MASTER, firstFail=0]]] using node 127.0.0.1/127.0.0.1:6379... RedisConnection@2032788060 [redisClient=[addr=redis://127.0.0.1:6379], channel=[id: 0x73f01205, L:/127.0.0.1:57196 - R:127.0.0.1/127.0.0.1:6379], command=null]

初始化RedissonClient 客户端之后，我们创建了一个队列名为one.delayed.queue的阻塞队列。且得到一个对应的延时队列。往延时队列添加了两条延时消息，接着就是从阻塞队列获取延迟消息。

打开redis客户端会发现Redisson会创建一个名字为redisson_delay_queue:{one.delayed.queue}的list结构的key

 还有一个名字为redisson_delay_queue_timeout:{one.delayed.queue}的zset数据结构的key

 还有一个我们申明的one.delayed.queue list数据结构

 

那么先看看RDelayedQueue

走读代码发现实现类是RedissonDelayedQueue

  protected RedissonDelayedQueue(QueueTransferService queueTransferService, Codec codec, final CommandAsyncExecutor commandExecutor, String name) {
        super(codec, commandExecutor, name);
        QueueTransferTask task = new QueueTransferTask(commandExecutor.getConnectionManager()) {
            protected RFuture<Long> pushTaskAsync() {
                return commandExecutor.evalWriteAsync(RedissonDelayedQueue.this.getName(), LongCodec.INSTANCE, RedisCommands.EVAL_LONG, "local expiredValues = redis.call('zrangebyscore', KEYS[2], 0, ARGV[1], 'limit', 0, ARGV[2]); if #expiredValues > 0 then for i, v in ipairs(expiredValues) do local randomId, value = struct.unpack('dLc0', v);redis.call('rpush', KEYS[1], value);redis.call('lrem', KEYS[3], 1, v);end; redis.call('zrem', KEYS[2], unpack(expiredValues));end; local v = redis.call('zrange', KEYS[2], 0, 0, 'WITHSCORES'); if v[1] ~= nil then return v[2]; end return nil;", Arrays.asList(RedissonDelayedQueue.this.getName(), RedissonDelayedQueue.this.timeoutSetName, RedissonDelayedQueue.this.queueName), new Object[]{System.currentTimeMillis(), Integer.valueOf(100)});
            }

            protected RTopic getTopic() {
                return new RedissonTopic(LongCodec.INSTANCE, commandExecutor, RedissonDelayedQueue.this.channelName);
            }
        };
        queueTransferService.schedule(this.queueName, task);
        this.queueTransferService = queueTransferService;
    }

实例化发现有个定时执行的lua脚本，这是核心我们聚焦一下这个脚本


--[[
 
struct.pack 不熟悉可以自行学习充电 https://www.cnblogs.com/aquester/p/9891466.html
我理解的大概意思就是保存多个字段到一个对象，有点像python的元组类型

Arrays.asList(RedissonDelayedQueue.this.getName(), RedissonDelayedQueue.this.timeoutSetName, RedissonDelayedQueue.this.queueName), new Object[]{System.currentTimeMillis(), Integer.valueOf(100)}
参数对应
ARGV[1]:当前系统时间毫秒数
ARGV[2]:批量获取size
key对应
KEYS[1]:申明的name
KEYS[2]:延时队列zset名,redisson_delay_queue_timeout:{申明的name}
KEYS[3]:list名,redisson_delay_queue:{申明的name}

首先获取redisson_delay_queue_timeout:{申明的name} 集合中失效时间在0-当前系统时间毫秒数的前100条记录
如果记录不为空则循环处理
  1 将redisson_delay_queue_timeout:{申明的name} 集合数据存入{申明的name}集合中
  2 移除redisson_delay_queue:{申明的name}集合中数据

lrem 语法 LREM key count VALUE

count > 0 : 从表头开始向表尾搜索，移除与 VALUE 相等的元素，数量为 COUNT 。
count < 0 : 从表尾开始向表头搜索，移除与 VALUE 相等的元素，数量为 COUNT 的绝对值。
count = 0 : 移除表中所有与 VALUE 相等的值。

最后移除本次从redisson_delay_queue_timeout:{申明的name} 集合获取的数据

重新获取redisson_delay_queue_timeout:{申明的name} 集合下一个延时触发时间

---]]

local expiredValues = redis.call('zrangebyscore', KEYS[2], 0, ARGV[1], 'limit', 0, ARGV[2]); 
if #expiredValues > 0
then 
 for i, v in ipairs(expiredValues) 
     do local randomId, value = struct.unpack('dLc0', v);
     redis.call('rpush', KEYS[1], value);
     redis.call('lrem', KEYS[3], 1, v);
  end; 
  redis.call('zrem', KEYS[2], unpack(expiredValues));
end; 
local v = redis.call('zrange', KEYS[2], 0, 0, 'WITHSCORES'); 
if v[1] ~= nil then 
return v[2]; 
end 
return nil;"

上面返回了一个最近的一个延时时间，redssion 会根据这个时间计算出下一次触发任务时间。利用

netty的HashedWheelTimer 自动触发
代码在 QueueTransferService
  private void scheduleTask(Long startTime) {
        QueueTransferTask.TimeoutTask oldTimeout = (QueueTransferTask.TimeoutTask)this.lastTimeout.get();
        if (startTime != null) {
            if (oldTimeout != null) {
                oldTimeout.getTask().cancel();
            }

            long delay = startTime.longValue() - System.currentTimeMillis();
            if (delay > 10L) {
                Timeout timeout = this.connectionManager.newTimeout(new TimerTask() {
                    public void run(Timeout timeout) throws Exception {
                        QueueTransferTask.this.pushTask();
                        QueueTransferTask.TimeoutTask currentTimeout = (QueueTransferTask.TimeoutTask)QueueTransferTask.this.lastTimeout.get();
                        if (currentTimeout.getTask() == timeout) {
                            QueueTransferTask.this.lastTimeout.compareAndSet(currentTimeout, (Object)null);
                        }

                    }
                }, delay, TimeUnit.MILLISECONDS);
                if (!this.lastTimeout.compareAndSet(oldTimeout, new QueueTransferTask.TimeoutTask(startTime.longValue(), timeout))) {
                    timeout.cancel();
                }
            } else {
                this.pushTask();
            }

        }
    }


offer方法都干了啥？

 RedissonDelayedQueue.java
public void offer(V e, long delay, TimeUnit timeUnit) {
        this.get(this.offerAsync(e, delay, timeUnit));
    }

    public RFuture<Void> offerAsync(V e, long delay, TimeUnit timeUnit) {
        long delayInMs = timeUnit.toMillis(delay);
        long timeout = System.currentTimeMillis() + delayInMs;
        long randomId = ThreadLocalRandom.current().nextLong();
        return this.commandExecutor.evalWriteAsync(this.getName(), this.codec, RedisCommands.EVAL_VOID, "local value = struct.pack('dLc0', tonumber(ARGV[2]), string.len(ARGV[3]), ARGV[3]);redis.call('zadd', KEYS[2], ARGV[1], value);redis.call('rpush', KEYS[3], value);local v = redis.call('zrange', KEYS[2], 0, 0); if v[1] == value then redis.call('publish', KEYS[4], ARGV[1]); end;", Arrays.asList(this.getName(), this.timeoutSetName, this.queueName, this.channelName), new Object[]{timeout, randomId, this.encode(e)});
    }

其实发现就是计算延时时间并且执行了一段lua脚本，使用lua脚本可以保证redis操作的原子性。

我们来看一下这脚本

--[[
 
struct.pack 不熟悉可以自行学习充电 https://www.cnblogs.com/aquester/p/9891466.html
我理解的大概意思就是保存多个字段到一个对象，有点像python的元组类型
Arrays.asList(this.getName(), this.timeoutSetName, this.queueName, this.channelName),
 new Object[]{timeout, randomId, this.encode(e)}
参数对应
ARGV[1]:timeout延时的时间
ARGV[2]:randomId随机id
ARGV[3]:内容
key对应
KEYS[1]:申明的name
KEYS[2]:延时队列zset名,redisson_delay_queue_timeout:{申明的name}
KEYS[3]:list名,redisson_delay_queue:{申明的name}
KEYS[4]:发布渠道名,redisson_delay_queue_channel:{申明的name}

解读代码：

申明一个对象value,第一个值是随机id，第二个值是内容长度，第三个值是具体内容
往延时队列redisson_delay_queue_timeout:{申明的name}添加value，且分值为超时时间
同时往redisson_delay_queue:{申明的name}list里添加了value
zrange redisson_delay_queue_timeout:{one.delayed.queue} 0 0
下标参数 start 和 stop 都以 0 为底，也就是说，以 0 表示有序集第一个成员
如果第一个元素等于value则
publish redisson_delay_queue_channel:{申明的name} 延时时间
---]]
local value = struct.pack('dLc0', tonumber(ARGV[2]), string.len(ARGV[3]), ARGV[3]);
redis.call('zadd', KEYS[2], ARGV[1], value);
redis.call('rpush', KEYS[3], value);
local v = redis.call('zrange', KEYS[2], 0, 0); 
if v[1] == value 
then 
   redis.call('publish', KEYS[4], ARGV[1]); 
end;
  • 首先对名为redisson_delay_queue_timeout:{申明的name}的zset做zadd操作，score为当前时间+延时时间的毫秒数。
  • 再对名为redisson_delay_queue:{申明的name}的list做rpush操作。
  • 之后判断redisson_delay_queue_timeout:{申明的name}第一个值是否是当前结构体，是的话发布延时消息。

总结一下

  • 客户端启动后在offer数据之前，会自动订阅一个名字为 redisson_delay_queue_channel:{你申明的name}的队列，同时 BLPOP key 0 无限监听一个阻塞队列
  • offer 数据不是直接投递用到了中转队列，取出最近一个延迟时间，然后发送消息通知
  • 客户端延时任务到期从redisson_delay_queue_timeout:{申明的name}获取数据，rpush到阻塞队列也就是定时执行的那段lua脚本逻辑
SpringBoot集成Redisson实现延迟队列
屈晓磊的博客
06-28 358
使用场景 1、下单成功，30分钟未支付。支付超时，自动取消订单 2、订单签收，签收后7天未进行评价。订单超时未评价，系统默认好评 3、下单成功，商家5分钟未接单，订单取消 4、配送超时，推送短信提醒… 对于延时比较长的场景、实时性不高的场景，我们可以采用任务调度的方式定时轮询处理。 如：xxl-job。今天我们采用一种比较简单、轻量级的方式，使用 Redis 的延迟队列来进行处理。 当然有更好的解决方案，可根据公司的技术选型和业务体系选择最优方案。 如：使用消息中间件Kafka、RabbitMQ 的延迟队列
Redisson延迟队列执行流程源码分析一下
weixin_64314555的博客
01-19 3428
在实际分布式项目中延迟任务一般不会使用JDK自带的延迟队列，因为它是基于JVM内存存储，没有持久化操作，所以当服务重启后就会丢失任务。 在项目中可以使用MQ死信队列或redisson延迟队列进行处理延迟任务，本篇文章将讲述redisson延迟队列的使用demo和其执行源码。 demo示例 通过脚手架创建一个简易springboot项目，引入redisson的maven依赖，并简单配置redisson连接属性。 <!-- redisson引用 --> <dependen
Redisson延迟队列执行流程源码分析一下，2024年最新设计类毕业设计选题
2401_84166811的博客
04-08 656
}@PostMapping(“redissonQueue”)public String redissonQueue (@RequestParam String data, @RequestParam Long expire) {RedisDataEntity entity = new RedisDataEntity(data, expire, System.currentTimeMillis());log.info(“本次添加数据：{}”, entity);redisHandle.offer(entity)
Redis通过Redisson实现延迟队列
weixin_39098944的博客
02-04 3110
前言 实现延迟队列的方式有很多种，有本地自己jdk方式实现、Quartz 定时任务实现、RabbitMQ 延时队列实现，还有Redis方式实现。综合自己的生产情况，Redis是符合分布式服务及开发成本较小的一种方式。基本的机制如下图 本文将通过工具包Redisson用极简单的方式来实现一个延迟队列。同时提供一下比较完备的例子。 一、延迟队列的使用场景 背景： 1、当订单一直处于未支付状态时，如何及时地关闭订单 2、如何定期检查处于退款状态的订单是否已经退款成功 3、在订单长时间没有收到下游系统的状态通知的
Redission延迟队列解析
2301_78976656的博客
09-09 1710
正常使用 redis 可以通过 zset 去实现延迟队列，将 key 设置为延时对象字符串，value 设置为到期的时间戳 通过多个线程不断的去循环判断是否存在到期的任务，如果有就拿出来消费。伪代码如下java代码解读复制代码但上面的代码会有一个问题：多个线程同时获取的values,但是只有一个线程能zrem成功。会增加的消耗。这个问题，可以通过 lua 去解决，让和zrem同时执行。
聊聊redisson的DelayedQueue
weixin_34342905的博客
09-22 1352
序 本文主要研究一下redisson的DelayedQueue maven <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifa...
Redisson全面解析:从使用方法到工作原理的深度探索
禅与计算机程序设计的艺术
02-08 1269
Redisson是基于原生redis操作指令上进一步的封装，屏蔽了redis数据结构的实现细节，开发可以像操作普通java对象一样使用redis，而本文将针对Redisson中各种使用的数据结构和工具包使用及其实现进行详尽的分析，希望对你有帮助。因为近期收到很多读者的私信，所以也专门创建了一个交流群，感兴趣的读者可以通过上方的公众号获取笔者的联系方式完成好友添加，点击备注。因为近期收到很多读者的私信，所以也专门创建了一个交流群，感兴趣的读者可以通过上方的公众号获取笔者的联系方式完成好友添加，点击备注。
2022Java最新真实面试题汇总
m0_67698950的博客
03-16 1306
一、面经 适当夸夸面试官（或所在公司）不会有坏处 如果某个问题完全不会（或稍微懂点），直接承认（或略作回答）并把话题引导向类似话题（redis集群的槽机制 -> 一致性哈希） 第二条如果完全不会，可以在表达自己不会之后给与面试官一点反问，表现出自己的求知欲与关注度 所有话题都可以适当性的发散，不要太发散以免显得有备而来 所有问题（熟悉或不熟悉）的回答不要太快，给面试官反应与打断的时间，同时方便自己梳理逻辑，显得沉稳；回答太快容易显得有备而来 一定要乐观向上（至...
Redisson分布式延时队列 RedissonDelayedQueue
m0_57042151的博客
02-23 2292
在RedissonDelayedQueue的构造方法会触发任务的调度，在这个任务里面会动态的触发定时任务的执行，这些定时任务会在任务过期时调用pushTaskAsync()方法，执行上面的Redis命令，将过期数据放入目标延迟队列供消费者消费。Redisson往这个List里面放的时候使用的rpush命令，rpush命令的意思是往List的右边放。take()这个方法的核心原理非常简单，核心代码就是使用Redis的BLPOP命令，从Redis的List数据结构里面取数据，取不到就阻塞，一直等到有数据进来。
redisson源码-加锁
奋斗的青年
02-23 858
//获取锁 public void lock() { try { //获取锁释放时间为永远不 lock(-1, null, false); } catch (InterruptedException e) { throw new IllegalStateException(); } } // private void lock(long leaseTime, TimeUnit un..
《伸手系列》之分布式锁Redssion入门和源码解析
御前提笔小书童
06-30 1286
Redisson简介 Javaer都知道Jedis，Jedis是Redis的Java实现的客户端，其API提供了比较全面的Redis命令的支持。Redission也是Redis的客户端，相比于Jedis功能简单。Jedis简单使用阻塞的I/O和redis交互，Redission通过Netty支持非阻塞I/O。Jedis最新版本2.9.0是2016年的快3年了没有更新，而Redission最新版本是2018.10月更新。 Redission封装了锁的实现，其继承了java.util.concurrent.lo
Redission延迟消息队列解决方案
renkai721的专栏
07-21 2436
redis key过期后callback的功能，Redission延迟消息队列
【Redis】基于Redisson实现分布式锁（代码实现）
m0_64210833的博客
06-19 2279
基于Redisson实现分布式锁解决商品秒杀超卖的场景,包含测试代码。
Redssion - 限流器
最新发布
qq_44768571的博客
04-04 466
关键代码为一串 lua 脚本，通过 redis 的 hash 结构存储限流器信息，包括限流器类型、速率、时间间隔等。关键也是一串 lua 脚本。
分布式锁简单入门以及三种实现方式介绍
AlbenXie的博客
10-12 675
很多小伙伴在学习Java的时候，总是感觉Java多线程在实际的业务中很少使用，以至于不会花太多的时间去学习，技术债不断累积！等到了一定程度的时候对于与Java多线程相关的东西就很难理解，今天需要探讨的东西也是一样的和Java多线程相关的！做好准备，马上开车！ 学过Java多线程的应该都知道什么是锁，没学过的也不用担心，Java中的锁可以简单的理解为多线程情况下访问临界资源的一种线程同步机制。 在学习或者使用Java的过程中进程会遇到各种各样的锁的概念：公平锁、非公平锁、自旋锁、可重入锁、偏向锁、轻量级锁
Redssion中分布式锁的应用
孔明的博客
03-10 1980
文章目录Redisson概述适用场景实际应用1、导入依赖2、编写配置文件3、自定义分布式锁 lock4、业务逻辑中调用锁 Redisson概述 ​ Redisson是架设在Redis基础上的一个Java驻内存数据网格（In-Memory Data Grid）。充分的利用了Redis键值数据库提供的一系列优势，基于Java实用工具包中常用接口，为使用者提供了一系列具有分布式特性的常用工具类...
RedisTimeoutException: Unable to send command
qq_38461475的博客
07-21 4717
应用访问redis报错如下： org.redisson.client.RedisTimeoutException: Unable to send command! Try to increase 'nettyThreads' and/or connection pool size settings Node source: NodeSource [slot=0, addr=null, redisClient=null, redirect=null, entry=MasterSlaveEntry [maste
浅析 Redisson 的分布式延时队列 RedissonDelayedQueue 运行流程
m0_73311735的博客
09-27 7033
因为工作中需要用到分布式的延时队列，调研了一段时间，选择使用 RedissonDelayedQueue，为了搞清楚内部运行流程，特记录下来。总体流程大概是图中的这个样子，初看一眼有点不知从何下手，接下来我会通过以下几点来分析流程，相信看完本文你能了解整个运行流程。基本使用内部数据结构介绍基本流程发送延时消息获取延时消息初始化延时队列redisson 源码里一共创建了三个队列：【消息延时队列】、【消息顺序队列】、【消息目标队列】。
redssion使用场景
07-27
Redis是一种高性能的内存数据库，而Redis的分布式锁库Redssion是基于Redis实现的。Redssion可以用于解决分布式环境下的并发控制问题，例如分布式锁、分布式限流、分布式集合等场景。 以下是Redssion的一些常见使用场景： 1. 分布式锁：在分布式系统中，往往需要保证某个资源在同一时间只能被一个进程或线程访问，这时可以使用Redssion的分布式锁来实现。比如在秒杀场景中，使用分布式锁可以确保同一商品只能被一个用户购买。 2. 分布式限流：在高并发场景下，为了保护系统的稳定性，需要对请求进行限流。Redssion提供了一些分布式限流算法的实现，例如漏桶算法、令牌桶算法等，可以用于控制请求的访问频率。 3. 分布式集合：Redssion提供了一些分布式集合的实现，如分布式队列、分布式列表、分布式Set等。这些分布式集合可以在多个节点之间共享数据，方便实现一些分布式场景。 4. 分布式任务调度：Redssion提供了分布式任务调度的功能，可以实现在分布式环境中对任务进行调度和执行。比如可以使用Redssion的分布式任务调度来实现定时任务的分布式执行。 总之，Redssion可以在分布式系统中解决并发控制、限流、共享数据等问题，提供了一些常用的分布式算法和数据结构的实现。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值