【RuoYi-Vue-Plus】学习笔记 17 - Redisson（二） 优先队列 Priority Queue 添加队列数据（Redisson 源码 + Lua 脚本）

最新推荐文章于 2024-04-25 14:28:08 发布
最新推荐文章于 2024-04-25 14:28:08 发布
阅读量1.5k 收藏 1
点赞数
分类专栏： 框架学习 - 若依 / RuoYi-Vue-Plus # Redisson 文章标签： lua java RuoYi-Vue-Plus 后端 redisson
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Michelle_Zhong/article/details/123382422
版权

文章目录

前言

继上一篇延迟队列之后，这一篇文章来说一下优先队列。不过 Redisson 提供的分布式队列是比较轻量级的，如果需要大量使用队列的场景的话，还是建议用专业的MQ。

我个人队列使用得比较少，但是其实队列在生产环境中也很重要，所以我也在补全这方面的知识。

这篇文章主要是记录一下底层 lua 脚本的执行过程。对于 Redisson 源码的部分我还没完整梳理出来，如果后面有机会再分享一下。

参考目录

代码实现

官方文档的demo（比较简单）：

在这里插入图片描述

框架实现：

添加队列数据

PriorityQueueController#add
在这里插入图片描述
框架中的逻辑主要是：

  1. 创建一个自定义比较器的优先队列。
  2. 循环随机生成10条数据（10以内的的 int 型数据），每生成一条数据就把该数据加入到优先队列中。
自定义比较器

PriorityDemoComparator
在这里插入图片描述

比较对象

PriorityDemo
在这里插入图片描述
比较器比较的是对象中的 orderNum 参数。
在这里插入图片描述

设置比较器

QueueUtils#trySetPriorityQueueComparator
在这里插入图片描述

添加队列数据

QueueUtils#addPriorityQueueObject
在这里插入图片描述

功能调用

流程：
1、登录前端页面，获取 token，设置接口文档全局参数。
在这里插入图片描述
2、接口文档中调用【优先队列 - 添加队列数据】接口
在这里插入图片描述
3、查看控制台参数打印
在这里插入图片描述

4、接口文档中调用【优先队列 - 获取队列数据】接口
在这里插入图片描述
5、查看控制台参数打印
在这里插入图片描述
可以看到消息按照 orderNum 从小到大进行排列输出。
注：当 orderNum 相同时，消息的顺序是随机的。

源码分析

添加数据

RedissonPriorityQueue#add
在这里插入图片描述

Lua 脚本分析

和上一篇类似，我用了测试中的其中一份数据来进行分析，文末有 Redis monitor 模式下控制台输出的内容。（操作方式见上一篇）

脚本调用的方法参数对照表：

脚本参数名Java参数名参数值
KEYS[1]getRawName()“zlyx”
ARGV[1]index插入值的下标
ARGV[2]encode(value)解码的参数值

发送数据：
在这里插入图片描述
获取数据：
在这里插入图片描述
脚本执行分析：

local len = redis.call('llen', KEYS[1]);
## "llen" "zlyx"

if tonumber(ARGV[1]) < len then 
    local pivot = redis.call('lindex', KEYS[1], ARGV[1]);
##1 "lindex" "zlyx" "0"
##3 "lindex" "zlyx" "2"
##5 "lindex" "zlyx" "1"
##6 "lindex" "zlyx" "3"
##7 "lindex" "zlyx" "5"
##8 "lindex" "zlyx" "4"
##9 "lindex" "zlyx" "7"
	
    redis.call('linsert', KEYS[1], 'before', pivot, ARGV[2]);
##1 "linsert" "zlyx" "before" 
##  "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-0\",\"orderNum\":2}" 
##  "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-1\",\"orderNum\":0}"
###1 [1-0, 0-2] 
##3 "linsert" "zlyx" "before" 
##  "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-2\",\"orderNum\":4}" 
##  "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-3\",\"orderNum\":2}"
###3 [1-0, 0-2, 3-2, 2-4] 
##5 "linsert" "zlyx" "before" 
##  "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-0\",\"orderNum\":2}" 
##  "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-5\",\"orderNum\":0}"
###5 [1-0, 5-0, 0-2, 3-2, 2-4, 4-8]
##6 "linsert" "zlyx" "before" 
##  "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-3\",\"orderNum\":2}" 
##  "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-6\",\"orderNum\":2}"
###6 [1-0, 5-0, 0-2, 6-2, 3-2, 2-4, 4-8]
##7 "linsert" "zlyx" "before" 
##  "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-2\",\"orderNum\":4}" 
##  "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-7\",\"orderNum\":3}"
###7 [1-0, 5-0, 0-2, 6-2, 3-2, 7-3, 2-4, 4-8]
##8 "linsert" "zlyx" "before" 
##  "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-3\",\"orderNum\":2}" 
##  "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-8\",\"orderNum\":2}"
###8 [1-0, 5-0, 0-2, 6-2, 8-2, 3-2, 7-3, 2-4, 4-8]
##9 "linsert" "zlyx" "before" 
##  "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-2\",\"orderNum\":4}" 
##  "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-9\",\"orderNum\":3}"
###9 [1-0, 5-0, 0-2, 6-2, 8-2, 3-2, 7-3, 9-3, 2-4, 4-8]
	
    return;
end;

redis.call('rpush', KEYS[1], ARGV[2]);
##0 "rpush" "zlyx" "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-0\",\"orderNum\":2}"
###0 [0-2] 
##2 "rpush" "zlyx" "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-2\",\"orderNum\":4}"
###2 [1-0, 0-2, 2-4] 
##4 "rpush" "zlyx" "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-4\",\"orderNum\":8}"
###4 [1-0, 0-2, 3-2, 2-4, 4-8]

说明：

  • 这是附文简化提炼出来分析的执行内容。
  • 为了方便查看所以在中间的循环中把命令分行了，执行是没有分行的。
  • ##(数值) 代表执行到第几个元素，从0开始，后面紧跟着的是底层执行的命令。
  • ###(数值) 代表当前队列中的元素的集合，从0开始。

执行情况：

  1. 第一个元素（data-0，orderNum=2）直接插入队列最后面（参考 ##0 "rpush"）。
    [0-2]
  2. 第二个元素（data-1，orderNum=0）判断比上一个元素小，所以获取到需要插入的下标位置（参考 ##1 "lindex"），再执行插入方法（参考 ##1 "linsert"）。
    [1-0, 0-2]
  3. 第三个元素（data-2，orderNum=4）判断比前两个元素大，直接插入到队列最后面（参考 ##2 "rpush"）。
    [1-0, 0-2, 2-4]
  4. 第四个元素（data-3，orderNum=2）判断比 data-1 大，比 data-2 小，插入到下标为 2（参考 ##3 "lindex"），再执行插入方法（参考 ##3 "linsert"）。
    [1-0, 0-2, 3-2, 2-4]
  5. 第五个元素（data-4，orderNum=8），参考步骤 3。
    [1-0, 0-2, 3-2, 2-4, 4-8]
  6. 第六个元素（data-5，orderNum=0）判断排序值最小，获取到需要插入的下标位置（参考 ##5 "lindex"），再执行插入方法（参考 ##5 "linsert"）插入到 data-0 后面。
    [1-0, 5-0, 0-2, 3-2, 2-4, 4-8]
  7. 第七个元素（data-6，orderNum=2）判断比 data-1 大，比 data-2 小，插入到下标为 3（参考 ##6 "lindex"），再执行插入方法（参考 ##6 "linsert"）。
    注意这里没有按照顺序插入到 data-3 后面，这里可以证明在相同的排序条件下，不同的没有顺序可言。（有兴趣的话可以自行测试一下）
    [1-0, 5-0, 0-2, 6-2, 3-2, 2-4, 4-8]
  8. 第八个元素（data-7，orderNum=3），参考步骤 3。
    [1-0, 5-0, 0-2, 6-2, 3-2, 7-3, 2-4, 4-8]
  9. 第九个元素（data-8，orderNum=2），参考步骤 7。
    [1-0, 5-0, 0-2, 6-2, 8-2, 3-2, 7-3, 2-4, 4-8]
  10. 第十个元素（data-9，orderNum=3），参考步骤 6。
    [1-0, 5-0, 0-2, 6-2, 8-2, 3-2, 7-3, 9-3, 2-4, 4-8]

至此全部数据插入完成并完成排序，获取数据时就按照该顺序进行输出。

附文

Redis monitor 模式下控制台输出完整内容

1646811971.584176 [0 127.0.0.1:59375] "DEL" "zlyx" "{zlyx}:redisson_sortedset_comparator"
1646811971.584709 [0 127.0.0.1:59372] "SETNX" "{zlyx}:redisson_sortedset_comparator" "com.ruoyi.demo.controller.queue.PriorityDemoComparator:77a5f57e5635883a9e3177484600654474ba78e9"
1646811971.585341 [0 127.0.0.1:59371] "EVAL" "if (redis.call('exists', KEYS[1]) == 0) then redis.call('hincrby', KEYS[1], ARGV[2], 1); redis.call('pexpire', KEYS[1], ARGV[1]); return nil; end; if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then redis.call('hincrby', KEYS[1], ARGV[2], 1); redis.call('pexpire', KEYS[1], ARGV[1]); return nil; end; return redis.call('pttl', KEYS[1]);" "1" "redisson_sortedset_lock:{zlyx}" "30000" "218ff15e-1019-4f97-8704-a6ba525b6d08:86"
1646811971.585436 [0 lua] "exists" "redisson_sortedset_lock:{zlyx}"
1646811971.585448 [0 lua] "hincrby" "redisson_sortedset_lock:{zlyx}" "218ff15e-1019-4f97-8704-a6ba525b6d08:86" "1"
1646811971.585465 [0 lua] "pexpire" "redisson_sortedset_lock:{zlyx}" "30000"
1646811971.585782 [0 127.0.0.1:59373] "GET" "{zlyx}:redisson_sortedset_comparator"
1646811971.586064 [0 127.0.0.1:59374] "GET" "{zlyx}:redisson_sortedset_comparator"
1646811971.586892 [0 127.0.0.1:59369] "LLEN" "zlyx"
1646811971.587458 [0 127.0.0.1:59370] "EVAL" "local len = redis.call('llen', KEYS[1]);if tonumber(ARGV[1]) < len then local pivot = redis.call('lindex', KEYS[1], ARGV[1]);redis.call('linsert', KEYS[1], 'before', pivot, ARGV[2]);return;end;redis.call('rpush', KEYS[1], ARGV[2]);" "1" "zlyx" "0" "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-0\",\"orderNum\":2}"
1646811971.587621 [0 lua] "llen" "zlyx"
1646811971.587634 [0 lua] "rpush" "zlyx" "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-0\",\"orderNum\":2}"
1646811971.588151 [0 127.0.0.1:59376] "EVAL" "if (redis.call('hexists', KEYS[1], ARGV[3]) == 0) then return nil;end; local counter = redis.call('hincrby', KEYS[1], ARGV[3], -1); if (counter > 0) then redis.call('pexpire', KEYS[1], ARGV[2]); return 0; else redis.call('del', KEYS[1]); redis.call('publish', KEYS[2], ARGV[1]); return 1; end; return nil;" "2" "redisson_sortedset_lock:{zlyx}" "redisson_lock__channel:redisson_sortedset_lock:{zlyx}" "0" "30000" "218ff15e-1019-4f97-8704-a6ba525b6d08:86"
1646811971.588484 [0 lua] "hexists" "redisson_sortedset_lock:{zlyx}" "218ff15e-1019-4f97-8704-a6ba525b6d08:86"
1646811971.588545 [0 lua] "hincrby" "redisson_sortedset_lock:{zlyx}" "218ff15e-1019-4f97-8704-a6ba525b6d08:86" "-1"
1646811971.588620 [0 lua] "del" "redisson_sortedset_lock:{zlyx}"
1646811971.588675 [0 lua] "publish" "redisson_lock__channel:redisson_sortedset_lock:{zlyx}" "0"
1646811971.589947 [0 127.0.0.1:59375] "EVAL" "if (redis.call('exists', KEYS[1]) == 0) then redis.call('hincrby', KEYS[1], ARGV[2], 1); redis.call('pexpire', KEYS[1], ARGV[1]); return nil; end; if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then redis.call('hincrby', KEYS[1], ARGV[2], 1); redis.call('pexpire', KEYS[1], ARGV[1]); return nil; end; return redis.call('pttl', KEYS[1]);" "1" "redisson_sortedset_lock:{zlyx}" "30000" "218ff15e-1019-4f97-8704-a6ba525b6d08:86"
1646811971.590128 [0 lua] "exists" "redisson_sortedset_lock:{zlyx}"
1646811971.590156 [0 lua] "hincrby" "redisson_sortedset_lock:{zlyx}" "218ff15e-1019-4f97-8704-a6ba525b6d08:86" "1"
1646811971.590243 [0 lua] "pexpire" "redisson_sortedset_lock:{zlyx}" "30000"
1646811971.590664 [0 127.0.0.1:59372] "GET" "{zlyx}:redisson_sortedset_comparator"
1646811971.591208 [0 127.0.0.1:59371] "GET" "{zlyx}:redisson_sortedset_comparator"
1646811971.591615 [0 127.0.0.1:59373] "LLEN" "zlyx"
1646811971.591873 [0 127.0.0.1:59374] "LINDEX" "zlyx" "0"
1646811971.592474 [0 127.0.0.1:59369] "EVAL" "local len = redis.call('llen', KEYS[1]);if tonumber(ARGV[1]) < len then local pivot = redis.call('lindex', KEYS[1], ARGV[1]);redis.call('linsert', KEYS[1], 'before', pivot, ARGV[2]);return;end;redis.call('rpush', KEYS[1], ARGV[2]);" "1" "zlyx" "0" "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-1\",\"orderNum\":0}"
1646811971.592608 [0 lua] "llen" "zlyx"
1646811971.592623 [0 lua] "lindex" "zlyx" "0"
1646811971.592638 [0 lua] "linsert" "zlyx" "before" "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-0\",\"orderNum\":2}" "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-1\",\"orderNum\":0}"
1646811971.593110 [0 127.0.0.1:59370] "EVAL" "if (redis.call('hexists', KEYS[1], ARGV[3]) == 0) then return nil;end; local counter = redis.call('hincrby', KEYS[1], ARGV[3], -1); if (counter > 0) then redis.call('pexpire', KEYS[1], ARGV[2]); return 0; else redis.call('del', KEYS[1]); redis.call('publish', KEYS[2], ARGV[1]); return 1; end; return nil;" "2" "redisson_sortedset_lock:{zlyx}" "redisson_lock__channel:redisson_sortedset_lock:{zlyx}" "0" "30000" "218ff15e-1019-4f97-8704-a6ba525b6d08:86"
1646811971.593329 [0 lua] "hexists" "redisson_sortedset_lock:{zlyx}" "218ff15e-1019-4f97-8704-a6ba525b6d08:86"
1646811971.593380 [0 lua] "hincrby" "redisson_sortedset_lock:{zlyx}" "218ff15e-1019-4f97-8704-a6ba525b6d08:86" "-1"
1646811971.593428 [0 lua] "del" "redisson_sortedset_lock:{zlyx}"
1646811971.593453 [0 lua] "publish" "redisson_lock__channel:redisson_sortedset_lock:{zlyx}" "0"
1646811971.594555 [0 127.0.0.1:59376] "EVAL" "if (redis.call('exists', KEYS[1]) == 0) then redis.call('hincrby', KEYS[1], ARGV[2], 1); redis.call('pexpire', KEYS[1], ARGV[1]); return nil; end; if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then redis.call('hincrby', KEYS[1], ARGV[2], 1); redis.call('pexpire', KEYS[1], ARGV[1]); return nil; end; return redis.call('pttl', KEYS[1]);" "1" "redisson_sortedset_lock:{zlyx}" "30000" "218ff15e-1019-4f97-8704-a6ba525b6d08:86"
1646811971.594743 [0 lua] "exists" "redisson_sortedset_lock:{zlyx}"
1646811971.594770 [0 lua] "hincrby" "redisson_sortedset_lock:{zlyx}" "218ff15e-1019-4f97-8704-a6ba525b6d08:86" "1"
1646811971.594811 [0 lua] "pexpire" "redisson_sortedset_lock:{zlyx}" "30000"
1646811971.595201 [0 127.0.0.1:59375] "GET" "{zlyx}:redisson_sortedset_comparator"
1646811971.595480 [0 127.0.0.1:59372] "GET" "{zlyx}:redisson_sortedset_comparator"
1646811971.595865 [0 127.0.0.1:59371] "LLEN" "zlyx"
1646811971.596243 [0 127.0.0.1:59373] "LINDEX" "zlyx" "0"
1646811971.596606 [0 127.0.0.1:59374] "LINDEX" "zlyx" "1"
1646811971.597064 [0 127.0.0.1:59369] "EVAL" "local len = redis.call('llen', KEYS[1]);if tonumber(ARGV[1]) < len then local pivot = redis.call('lindex', KEYS[1], ARGV[1]);redis.call('linsert', KEYS[1], 'before', pivot, ARGV[2]);return;end;redis.call('rpush', KEYS[1], ARGV[2]);" "1" "zlyx" "2" "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-2\",\"orderNum\":4}"
1646811971.597183 [0 lua] "llen" "zlyx"
1646811971.597198 [0 lua] "rpush" "zlyx" "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-2\",\"orderNum\":4}"
1646811971.597612 [0 127.0.0.1:59370] "EVAL" "if (redis.call('hexists', KEYS[1], ARGV[3]) == 0) then return nil;end; local counter = redis.call('hincrby', KEYS[1], ARGV[3], -1); if (counter > 0) then redis.call('pexpire', KEYS[1], ARGV[2]); return 0; else redis.call('del', KEYS[1]); redis.call('publish', KEYS[2], ARGV[1]); return 1; end; return nil;" "2" "redisson_sortedset_lock:{zlyx}" "redisson_lock__channel:redisson_sortedset_lock:{zlyx}" "0" "30000" "218ff15e-1019-4f97-8704-a6ba525b6d08:86"
1646811971.597747 [0 lua] "hexists" "redisson_sortedset_lock:{zlyx}" "218ff15e-1019-4f97-8704-a6ba525b6d08:86"
1646811971.597783 [0 lua] "hincrby" "redisson_sortedset_lock:{zlyx}" "218ff15e-1019-4f97-8704-a6ba525b6d08:86" "-1"
1646811971.597803 [0 lua] "del" "redisson_sortedset_lock:{zlyx}"
1646811971.597811 [0 lua] "publish" "redisson_lock__channel:redisson_sortedset_lock:{zlyx}" "0"
1646811971.598981 [0 127.0.0.1:59376] "EVAL" "if (redis.call('exists', KEYS[1]) == 0) then redis.call('hincrby', KEYS[1], ARGV[2], 1); redis.call('pexpire', KEYS[1], ARGV[1]); return nil; end; if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then redis.call('hincrby', KEYS[1], ARGV[2], 1); redis.call('pexpire', KEYS[1], ARGV[1]); return nil; end; return redis.call('pttl', KEYS[1]);" "1" "redisson_sortedset_lock:{zlyx}" "30000" "218ff15e-1019-4f97-8704-a6ba525b6d08:86"
1646811971.599187 [0 lua] "exists" "redisson_sortedset_lock:{zlyx}"
1646811971.599209 [0 lua] "hincrby" "redisson_sortedset_lock:{zlyx}" "218ff15e-1019-4f97-8704-a6ba525b6d08:86" "1"
1646811971.599239 [0 lua] "pexpire" "redisson_sortedset_lock:{zlyx}" "30000"
1646811971.599672 [0 127.0.0.1:59375] "GET" "{zlyx}:redisson_sortedset_comparator"
1646811971.600015 [0 127.0.0.1:59372] "GET" "{zlyx}:redisson_sortedset_comparator"
1646811971.600546 [0 127.0.0.1:59371] "LLEN" "zlyx"
1646811971.600858 [0 127.0.0.1:59373] "LINDEX" "zlyx" "1"
1646811971.601565 [0 127.0.0.1:59374] "EVAL" "local len = redis.call('llen', KEYS[1]);if tonumber(ARGV[1]) < len then local pivot = redis.call('lindex', KEYS[1], ARGV[1]);redis.call('linsert', KEYS[1], 'before', pivot, ARGV[2]);return;end;redis.call('rpush', KEYS[1], ARGV[2]);" "1" "zlyx" "2" "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-3\",\"orderNum\":2}"
1646811971.601641 [0 lua] "llen" "zlyx"
1646811971.601663 [0 lua] "lindex" "zlyx" "2"
1646811971.601669 [0 lua] "linsert" "zlyx" "before" "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-2\",\"orderNum\":4}" "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-3\",\"orderNum\":2}"
1646811971.602177 [0 127.0.0.1:59369] "EVAL" "if (redis.call('hexists', KEYS[1], ARGV[3]) == 0) then return nil;end; local counter = redis.call('hincrby', KEYS[1], ARGV[3], -1); if (counter > 0) then redis.call('pexpire', KEYS[1], ARGV[2]); return 0; else redis.call('del', KEYS[1]); redis.call('publish', KEYS[2], ARGV[1]); return 1; end; return nil;" "2" "redisson_sortedset_lock:{zlyx}" "redisson_lock__channel:redisson_sortedset_lock:{zlyx}" "0" "30000" "218ff15e-1019-4f97-8704-a6ba525b6d08:86"
1646811971.602329 [0 lua] "hexists" "redisson_sortedset_lock:{zlyx}" "218ff15e-1019-4f97-8704-a6ba525b6d08:86"
1646811971.602358 [0 lua] "hincrby" "redisson_sortedset_lock:{zlyx}" "218ff15e-1019-4f97-8704-a6ba525b6d08:86" "-1"
1646811971.602446 [0 lua] "del" "redisson_sortedset_lock:{zlyx}"
1646811971.602460 [0 lua] "publish" "redisson_lock__channel:redisson_sortedset_lock:{zlyx}" "0"
1646811971.603543 [0 127.0.0.1:59370] "EVAL" "if (redis.call('exists', KEYS[1]) == 0) then redis.call('hincrby', KEYS[1], ARGV[2], 1); redis.call('pexpire', KEYS[1], ARGV[1]); return nil; end; if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then redis.call('hincrby', KEYS[1], ARGV[2], 1); redis.call('pexpire', KEYS[1], ARGV[1]); return nil; end; return redis.call('pttl', KEYS[1]);" "1" "redisson_sortedset_lock:{zlyx}" "30000" "218ff15e-1019-4f97-8704-a6ba525b6d08:86"
1646811971.603738 [0 lua] "exists" "redisson_sortedset_lock:{zlyx}"
1646811971.603758 [0 lua] "hincrby" "redisson_sortedset_lock:{zlyx}" "218ff15e-1019-4f97-8704-a6ba525b6d08:86" "1"
1646811971.603796 [0 lua] "pexpire" "redisson_sortedset_lock:{zlyx}" "30000"
1646811971.604413 [0 127.0.0.1:59376] "GET" "{zlyx}:redisson_sortedset_comparator"
1646811971.604868 [0 127.0.0.1:59375] "GET" "{zlyx}:redisson_sortedset_comparator"
1646811971.605400 [0 127.0.0.1:59372] "LLEN" "zlyx"
1646811971.605814 [0 127.0.0.1:59371] "LINDEX" "zlyx" "1"
1646811971.606247 [0 127.0.0.1:59373] "LINDEX" "zlyx" "2"
1646811971.606556 [0 127.0.0.1:59374] "LINDEX" "zlyx" "3"
1646811971.607056 [0 127.0.0.1:59369] "EVAL" "local len = redis.call('llen', KEYS[1]);if tonumber(ARGV[1]) < len then local pivot = redis.call('lindex', KEYS[1], ARGV[1]);redis.call('linsert', KEYS[1], 'before', pivot, ARGV[2]);return;end;redis.call('rpush', KEYS[1], ARGV[2]);" "1" "zlyx" "4" "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-4\",\"orderNum\":8}"
1646811971.607189 [0 lua] "llen" "zlyx"
1646811971.607211 [0 lua] "rpush" "zlyx" "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-4\",\"orderNum\":8}"
1646811971.607738 [0 127.0.0.1:59370] "EVAL" "if (redis.call('hexists', KEYS[1], ARGV[3]) == 0) then return nil;end; local counter = redis.call('hincrby', KEYS[1], ARGV[3], -1); if (counter > 0) then redis.call('pexpire', KEYS[1], ARGV[2]); return 0; else redis.call('del', KEYS[1]); redis.call('publish', KEYS[2], ARGV[1]); return 1; end; return nil;" "2" "redisson_sortedset_lock:{zlyx}" "redisson_lock__channel:redisson_sortedset_lock:{zlyx}" "0" "30000" "218ff15e-1019-4f97-8704-a6ba525b6d08:86"
1646811971.607853 [0 lua] "hexists" "redisson_sortedset_lock:{zlyx}" "218ff15e-1019-4f97-8704-a6ba525b6d08:86"
1646811971.607886 [0 lua] "hincrby" "redisson_sortedset_lock:{zlyx}" "218ff15e-1019-4f97-8704-a6ba525b6d08:86" "-1"
1646811971.607951 [0 lua] "del" "redisson_sortedset_lock:{zlyx}"
1646811971.607976 [0 lua] "publish" "redisson_lock__channel:redisson_sortedset_lock:{zlyx}" "0"
1646811971.608980 [0 127.0.0.1:59376] "EVAL" "if (redis.call('exists', KEYS[1]) == 0) then redis.call('hincrby', KEYS[1], ARGV[2], 1); redis.call('pexpire', KEYS[1], ARGV[1]); return nil; end; if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then redis.call('hincrby', KEYS[1], ARGV[2], 1); redis.call('pexpire', KEYS[1], ARGV[1]); return nil; end; return redis.call('pttl', KEYS[1]);" "1" "redisson_sortedset_lock:{zlyx}" "30000" "218ff15e-1019-4f97-8704-a6ba525b6d08:86"
1646811971.609055 [0 lua] "exists" "redisson_sortedset_lock:{zlyx}"
1646811971.609070 [0 lua] "hincrby" "redisson_sortedset_lock:{zlyx}" "218ff15e-1019-4f97-8704-a6ba525b6d08:86" "1"
1646811971.609099 [0 lua] "pexpire" "redisson_sortedset_lock:{zlyx}" "30000"
1646811971.609472 [0 127.0.0.1:59375] "GET" "{zlyx}:redisson_sortedset_comparator"
1646811971.609777 [0 127.0.0.1:59372] "GET" "{zlyx}:redisson_sortedset_comparator"
1646811971.610396 [0 127.0.0.1:59371] "LLEN" "zlyx"
1646811971.610715 [0 127.0.0.1:59373] "LINDEX" "zlyx" "2"
1646811971.611298 [0 127.0.0.1:59374] "LINDEX" "zlyx" "0"
1646811971.611942 [0 127.0.0.1:59369] "EVAL" "local len = redis.call('llen', KEYS[1]);if tonumber(ARGV[1]) < len then local pivot = redis.call('lindex', KEYS[1], ARGV[1]);redis.call('linsert', KEYS[1], 'before', pivot, ARGV[2]);return;end;redis.call('rpush', KEYS[1], ARGV[2]);" "1" "zlyx" "1" "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-5\",\"orderNum\":0}"
1646811971.612032 [0 lua] "llen" "zlyx"
1646811971.612047 [0 lua] "lindex" "zlyx" "1"
1646811971.612061 [0 lua] "linsert" "zlyx" "before" "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-0\",\"orderNum\":2}" "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-5\",\"orderNum\":0}"
1646811971.612776 [0 127.0.0.1:59370] "EVAL" "if (redis.call('hexists', KEYS[1], ARGV[3]) == 0) then return nil;end; local counter = redis.call('hincrby', KEYS[1], ARGV[3], -1); if (counter > 0) then redis.call('pexpire', KEYS[1], ARGV[2]); return 0; else redis.call('del', KEYS[1]); redis.call('publish', KEYS[2], ARGV[1]); return 1; end; return nil;" "2" "redisson_sortedset_lock:{zlyx}" "redisson_lock__channel:redisson_sortedset_lock:{zlyx}" "0" "30000" "218ff15e-1019-4f97-8704-a6ba525b6d08:86"
1646811971.612953 [0 lua] "hexists" "redisson_sortedset_lock:{zlyx}" "218ff15e-1019-4f97-8704-a6ba525b6d08:86"
1646811971.613006 [0 lua] "hincrby" "redisson_sortedset_lock:{zlyx}" "218ff15e-1019-4f97-8704-a6ba525b6d08:86" "-1"
1646811971.613040 [0 lua] "del" "redisson_sortedset_lock:{zlyx}"
1646811971.613060 [0 lua] "publish" "redisson_lock__channel:redisson_sortedset_lock:{zlyx}" "0"
1646811971.614961 [0 127.0.0.1:59376] "EVAL" "if (redis.call('exists', KEYS[1]) == 0) then redis.call('hincrby', KEYS[1], ARGV[2], 1); redis.call('pexpire', KEYS[1], ARGV[1]); return nil; end; if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then redis.call('hincrby', KEYS[1], ARGV[2], 1); redis.call('pexpire', KEYS[1], ARGV[1]); return nil; end; return redis.call('pttl', KEYS[1]);" "1" "redisson_sortedset_lock:{zlyx}" "30000" "218ff15e-1019-4f97-8704-a6ba525b6d08:86"
1646811971.615119 [0 lua] "exists" "redisson_sortedset_lock:{zlyx}"
1646811971.615145 [0 lua] "hincrby" "redisson_sortedset_lock:{zlyx}" "218ff15e-1019-4f97-8704-a6ba525b6d08:86" "1"
1646811971.615179 [0 lua] "pexpire" "redisson_sortedset_lock:{zlyx}" "30000"
1646811971.615706 [0 127.0.0.1:59375] "GET" "{zlyx}:redisson_sortedset_comparator"
1646811971.616552 [0 127.0.0.1:59372] "GET" "{zlyx}:redisson_sortedset_comparator"
1646811971.617291 [0 127.0.0.1:59371] "LLEN" "zlyx"
1646811971.617631 [0 127.0.0.1:59373] "LINDEX" "zlyx" "2"
1646811971.618308 [0 127.0.0.1:59374] "EVAL" "local len = redis.call('llen', KEYS[1]);if tonumber(ARGV[1]) < len then local pivot = redis.call('lindex', KEYS[1], ARGV[1]);redis.call('linsert', KEYS[1], 'before', pivot, ARGV[2]);return;end;redis.call('rpush', KEYS[1], ARGV[2]);" "1" "zlyx" "3" "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-6\",\"orderNum\":2}"
1646811971.618395 [0 lua] "llen" "zlyx"
1646811971.618408 [0 lua] "lindex" "zlyx" "3"
1646811971.618419 [0 lua] "linsert" "zlyx" "before" "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-3\",\"orderNum\":2}" "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-6\",\"orderNum\":2}"
1646811971.619088 [0 127.0.0.1:59369] "EVAL" "if (redis.call('hexists', KEYS[1], ARGV[3]) == 0) then return nil;end; local counter = redis.call('hincrby', KEYS[1], ARGV[3], -1); if (counter > 0) then redis.call('pexpire', KEYS[1], ARGV[2]); return 0; else redis.call('del', KEYS[1]); redis.call('publish', KEYS[2], ARGV[1]); return 1; end; return nil;" "2" "redisson_sortedset_lock:{zlyx}" "redisson_lock__channel:redisson_sortedset_lock:{zlyx}" "0" "30000" "218ff15e-1019-4f97-8704-a6ba525b6d08:86"
1646811971.619261 [0 lua] "hexists" "redisson_sortedset_lock:{zlyx}" "218ff15e-1019-4f97-8704-a6ba525b6d08:86"
1646811971.619360 [0 lua] "hincrby" "redisson_sortedset_lock:{zlyx}" "218ff15e-1019-4f97-8704-a6ba525b6d08:86" "-1"
1646811971.619582 [0 lua] "del" "redisson_sortedset_lock:{zlyx}"
1646811971.619600 [0 lua] "publish" "redisson_lock__channel:redisson_sortedset_lock:{zlyx}" "0"
1646811971.621290 [0 127.0.0.1:59370] "EVAL" "if (redis.call('exists', KEYS[1]) == 0) then redis.call('hincrby', KEYS[1], ARGV[2], 1); redis.call('pexpire', KEYS[1], ARGV[1]); return nil; end; if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then redis.call('hincrby', KEYS[1], ARGV[2], 1); redis.call('pexpire', KEYS[1], ARGV[1]); return nil; end; return redis.call('pttl', KEYS[1]);" "1" "redisson_sortedset_lock:{zlyx}" "30000" "218ff15e-1019-4f97-8704-a6ba525b6d08:86"
1646811971.621523 [0 lua] "exists" "redisson_sortedset_lock:{zlyx}"
1646811971.621554 [0 lua] "hincrby" "redisson_sortedset_lock:{zlyx}" "218ff15e-1019-4f97-8704-a6ba525b6d08:86" "1"
1646811971.621596 [0 lua] "pexpire" "redisson_sortedset_lock:{zlyx}" "30000"
1646811971.622329 [0 127.0.0.1:59376] "GET" "{zlyx}:redisson_sortedset_comparator"
1646811971.622987 [0 127.0.0.1:59375] "GET" "{zlyx}:redisson_sortedset_comparator"
1646811971.623716 [0 127.0.0.1:59372] "LLEN" "zlyx"
1646811971.624050 [0 127.0.0.1:59371] "LINDEX" "zlyx" "3"
1646811971.625229 [0 127.0.0.1:59373] "LINDEX" "zlyx" "5"
1646811971.626963 [0 127.0.0.1:59374] "LINDEX" "zlyx" "4"
1646811971.627910 [0 127.0.0.1:59369] "EVAL" "local len = redis.call('llen', KEYS[1]);if tonumber(ARGV[1]) < len then local pivot = redis.call('lindex', KEYS[1], ARGV[1]);redis.call('linsert', KEYS[1], 'before', pivot, ARGV[2]);return;end;redis.call('rpush', KEYS[1], ARGV[2]);" "1" "zlyx" "5" "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-7\",\"orderNum\":3}"
1646811971.628032 [0 lua] "llen" "zlyx"
1646811971.628044 [0 lua] "lindex" "zlyx" "5"
1646811971.628052 [0 lua] "linsert" "zlyx" "before" "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-2\",\"orderNum\":4}" "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-7\",\"orderNum\":3}"
1646811971.628521 [0 127.0.0.1:59370] "EVAL" "if (redis.call('hexists', KEYS[1], ARGV[3]) == 0) then return nil;end; local counter = redis.call('hincrby', KEYS[1], ARGV[3], -1); if (counter > 0) then redis.call('pexpire', KEYS[1], ARGV[2]); return 0; else redis.call('del', KEYS[1]); redis.call('publish', KEYS[2], ARGV[1]); return 1; end; return nil;" "2" "redisson_sortedset_lock:{zlyx}" "redisson_lock__channel:redisson_sortedset_lock:{zlyx}" "0" "30000" "218ff15e-1019-4f97-8704-a6ba525b6d08:86"
1646811971.628680 [0 lua] "hexists" "redisson_sortedset_lock:{zlyx}" "218ff15e-1019-4f97-8704-a6ba525b6d08:86"
1646811971.628722 [0 lua] "hincrby" "redisson_sortedset_lock:{zlyx}" "218ff15e-1019-4f97-8704-a6ba525b6d08:86" "-1"
1646811971.628756 [0 lua] "del" "redisson_sortedset_lock:{zlyx}"
1646811971.628774 [0 lua] "publish" "redisson_lock__channel:redisson_sortedset_lock:{zlyx}" "0"
1646811971.629405 [0 127.0.0.1:59376] "EVAL" "if (redis.call('exists', KEYS[1]) == 0) then redis.call('hincrby', KEYS[1], ARGV[2], 1); redis.call('pexpire', KEYS[1], ARGV[1]); return nil; end; if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then redis.call('hincrby', KEYS[1], ARGV[2], 1); redis.call('pexpire', KEYS[1], ARGV[1]); return nil; end; return redis.call('pttl', KEYS[1]);" "1" "redisson_sortedset_lock:{zlyx}" "30000" "218ff15e-1019-4f97-8704-a6ba525b6d08:86"
1646811971.629552 [0 lua] "exists" "redisson_sortedset_lock:{zlyx}"
1646811971.629569 [0 lua] "hincrby" "redisson_sortedset_lock:{zlyx}" "218ff15e-1019-4f97-8704-a6ba525b6d08:86" "1"
1646811971.629592 [0 lua] "pexpire" "redisson_sortedset_lock:{zlyx}" "30000"
1646811971.629953 [0 127.0.0.1:59375] "GET" "{zlyx}:redisson_sortedset_comparator"
1646811971.630249 [0 127.0.0.1:59372] "GET" "{zlyx}:redisson_sortedset_comparator"
1646811971.630631 [0 127.0.0.1:59371] "LLEN" "zlyx"
1646811971.630945 [0 127.0.0.1:59373] "LINDEX" "zlyx" "3"
1646811971.632219 [0 127.0.0.1:59374] "EVAL" "local len = redis.call('llen', KEYS[1]);if tonumber(ARGV[1]) < len then local pivot = redis.call('lindex', KEYS[1], ARGV[1]);redis.call('linsert', KEYS[1], 'before', pivot, ARGV[2]);return;end;redis.call('rpush', KEYS[1], ARGV[2]);" "1" "zlyx" "4" "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-8\",\"orderNum\":2}"
1646811971.632401 [0 lua] "llen" "zlyx"
1646811971.632425 [0 lua] "lindex" "zlyx" "4"
1646811971.632443 [0 lua] "linsert" "zlyx" "before" "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-3\",\"orderNum\":2}" "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-8\",\"orderNum\":2}"
1646811971.634645 [0 127.0.0.1:59369] "EVAL" "if (redis.call('hexists', KEYS[1], ARGV[3]) == 0) then return nil;end; local counter = redis.call('hincrby', KEYS[1], ARGV[3], -1); if (counter > 0) then redis.call('pexpire', KEYS[1], ARGV[2]); return 0; else redis.call('del', KEYS[1]); redis.call('publish', KEYS[2], ARGV[1]); return 1; end; return nil;" "2" "redisson_sortedset_lock:{zlyx}" "redisson_lock__channel:redisson_sortedset_lock:{zlyx}" "0" "30000" "218ff15e-1019-4f97-8704-a6ba525b6d08:86"
1646811971.634853 [0 lua] "hexists" "redisson_sortedset_lock:{zlyx}" "218ff15e-1019-4f97-8704-a6ba525b6d08:86"
1646811971.634948 [0 lua] "hincrby" "redisson_sortedset_lock:{zlyx}" "218ff15e-1019-4f97-8704-a6ba525b6d08:86" "-1"
1646811971.635033 [0 lua] "del" "redisson_sortedset_lock:{zlyx}"
1646811971.635052 [0 lua] "publish" "redisson_lock__channel:redisson_sortedset_lock:{zlyx}" "0"
1646811971.638259 [0 127.0.0.1:59370] "EVAL" "if (redis.call('exists', KEYS[1]) == 0) then redis.call('hincrby', KEYS[1], ARGV[2], 1); redis.call('pexpire', KEYS[1], ARGV[1]); return nil; end; if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then redis.call('hincrby', KEYS[1], ARGV[2], 1); redis.call('pexpire', KEYS[1], ARGV[1]); return nil; end; return redis.call('pttl', KEYS[1]);" "1" "redisson_sortedset_lock:{zlyx}" "30000" "218ff15e-1019-4f97-8704-a6ba525b6d08:86"
1646811971.638512 [0 lua] "exists" "redisson_sortedset_lock:{zlyx}"
1646811971.638556 [0 lua] "hincrby" "redisson_sortedset_lock:{zlyx}" "218ff15e-1019-4f97-8704-a6ba525b6d08:86" "1"
1646811971.638615 [0 lua] "pexpire" "redisson_sortedset_lock:{zlyx}" "30000"
1646811971.639866 [0 127.0.0.1:59376] "GET" "{zlyx}:redisson_sortedset_comparator"
1646811971.640295 [0 127.0.0.1:59375] "GET" "{zlyx}:redisson_sortedset_comparator"
1646811971.641206 [0 127.0.0.1:59372] "LLEN" "zlyx"
1646811971.641763 [0 127.0.0.1:59371] "LINDEX" "zlyx" "4"
1646811971.642598 [0 127.0.0.1:59373] "LINDEX" "zlyx" "6"
1646811971.643221 [0 127.0.0.1:59374] "EVAL" "local len = redis.call('llen', KEYS[1]);if tonumber(ARGV[1]) < len then local pivot = redis.call('lindex', KEYS[1], ARGV[1]);redis.call('linsert', KEYS[1], 'before', pivot, ARGV[2]);return;end;redis.call('rpush', KEYS[1], ARGV[2]);" "1" "zlyx" "7" "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-9\",\"orderNum\":3}"
1646811971.643409 [0 lua] "llen" "zlyx"
1646811971.643419 [0 lua] "lindex" "zlyx" "7"
1646811971.643437 [0 lua] "linsert" "zlyx" "before" "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-2\",\"orderNum\":4}" "{\"@class\":\"com.ruoyi.demo.controller.queue.PriorityDemo\",\"name\":\"data-9\",\"orderNum\":3}"
1646811971.644189 [0 127.0.0.1:59369] "EVAL" "if (redis.call('hexists', KEYS[1], ARGV[3]) == 0) then return nil;end; local counter = redis.call('hincrby', KEYS[1], ARGV[3], -1); if (counter > 0) then redis.call('pexpire', KEYS[1], ARGV[2]); return 0; else redis.call('del', KEYS[1]); redis.call('publish', KEYS[2], ARGV[1]); return 1; end; return nil;" "2" "redisson_sortedset_lock:{zlyx}" "redisson_lock__channel:redisson_sortedset_lock:{zlyx}" "0" "30000" "218ff15e-1019-4f97-8704-a6ba525b6d08:86"
1646811971.644424 [0 lua] "hexists" "redisson_sortedset_lock:{zlyx}" "218ff15e-1019-4f97-8704-a6ba525b6d08:86"
1646811971.644475 [0 lua] "hincrby" "redisson_sortedset_lock:{zlyx}" "218ff15e-1019-4f97-8704-a6ba525b6d08:86" "-1"
1646811971.644511 [0 lua] "del" "redisson_sortedset_lock:{zlyx}"
1646811971.644546 [0 lua] "publish" "redisson_lock__channel:redisson_sortedset_lock:{zlyx}" "0"
MichelleChung
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
传输加解密 RuoYi-Vue-PLus 4.x
10-17
传输加解密 RuoYi-Vue-PLus 4.x
若依ruoyi ruoyi-vue ruoyi-cloud 微服务全网最全视频教程网盘资源
12-25
若依ruoyi ，ruoyi-vue， ruoyi-cloud， 微服务全网最全视频教程网盘资源 RuoYi-Cloud 微服务版本视频课程目录 ├──01 项目概述.mp4 20.77M ├──02 微架构概念.mp4 20.99M ├──03 微架构及选型.mp4 21.19M ├──04 目录文件介绍.mp4 17.16M ├──05 项目运行.mp4 108.31M ├──06 构建发布到Linux.mp4 70.13M ├──07 开发环境运行.mp4 82.35M ├──08 服务网关介绍.mp4 23.32M ├──09 使用服务网关.mp4 35.82M ├──10 网关路由规则.mp4 27.60M ├──11 网关路由配置.mp4 15.71M ├──12 网关限流配置.mp4 34.21M ├──13 网关熔断降级.mp4 30.85M ├──14 网关跨域配置.mp4 35.81M ├──15 网关黑名单配置.mp4 10.88M ├
在若依Ruoyi-Vue中集成mybatisplus实现mybatis增强
最新发布
字节叔叔
04-25 1487
MyBatisPlus是基于MyBatis的一款优秀持久层框架增强工具，它在MyBatis的基础上提供了丰富而强大的CRUD操作、条件构造器、全局通用操作、代码生成器等特性，极大地简化了开发过程，提升了开发效率。MyBatisPlus通过无侵入式的设计理念，使得在享受其带来的便利同时，无需对现有MyBatis项目进行大规模改造。
本项目基于 RuoYi-Vue-Plus 进行二次开发扩展Flowable工作流功能，支持在线表单设计和丰富的工作流程设计能力
01-06
本项目基于 RuoYi-Vue-Plus 进行二次开发扩展Flowable工作流功能，支持在线表单设计和丰富的工作流程设计能力。本项目主要针对Flowable工作流场景开发，脚手架功能同步更新 RuoYi-Vue-Plus 项目。采用MIT开源协议，完全免费给个人及企业使用。项目处于开发阶段，工作流流程还存在不足。因此，目前仅推荐用于学习、毕业设计等个人使用。
ruoyi-vue-pro yudao 项目报表设计器 积木报表模块启用及相关SQL脚本
08-20
ruoyi-vue-pro yudao 项目报表设计器 积木报表模块启用及相关SQL脚本, 模块开启可以参考博文
RuoYi-Vue-Plus 是重写 RuoYi-Vue 针对 分布式集群与多租户 场景全方位升级(不兼容原框架)
06-02
RuoYi-Vue-Plus 是重写 RuoYi-Vue 针对 分布式集群与多租户 场景全方位升级(不兼容原框架)
redisson-priority-queue
03-21
redisson-priority-queue
一个简单的优先级队列实现
Smart的专栏
08-11 1447
优先级队列底层使用堆来实现。因为堆可以在O(1)的时间内找出优先级最高的元素。 代码如下：#ifndef _PRIORITY_ #define _PRIORITY_#include<iostream> #include"../Heap/Heap.h" using namespace std;template<typename T,typename U> class PriorityQu
模板：优先队列(priority_queue)
weixin_34014277的博客
02-24 140
1 #include <iostream> 2 #include <cstdio> 3 #include <queue> 4 #include <vector> 5 6 using namespace std; 7 8 struct node 9 { 10 int priortity; 11 ...
【RuoYi-Vue-Plus】学习笔记 15 - Redisson（一） 延迟队列 Delayed Queue 添加队列数据（Redisson 源码 + Lua 脚本）
MichelleChung的星球
02-22 2466
本文简单分析了 Redisson 延迟队列的源码以及源码中使用 Lua 脚本。
java使用堆结构实现优先队列
云守护的专栏
05-30 1233
package com.structures.tree; import java.util.NoSuchElementException; /* * 小顶堆 java使用堆结构实现优先队列 * http://www.oschina.net/code/snippet_855019_15069 */ public class JPriorityQueue { class QueueNo
Redisson之几种分布式队列
热门推荐
湖人•总冠军
03-28 1万+
前言： 消息队列很好理解，顾明思议就是排队执行。Redisson 队列类似实现Java接口，例如Queue和BlockingQueue基于Redisson Api 来处理一些复杂的业务逻辑。 1.Queue Redisson中的RQueue对象实现了java.util.Queue接口。队列用于首先从最旧的元素开始处理元素的情况（也称为“先进先出”或FIFO）。与普通Java一样，...
使用Redisson操作分布式队列的注意事项
奋斗
05-23 2170
先说结论: 使用Redisson提供了集合操作时, 比较操作不使用对象的equals, 而是使用二制进行比较. 最近做一个定时任务的服务, 需要用到分布式优先级队列, 选择了Redisson库. Redisson的队列有很多, 也都继承了java包的Queue接口, 看起来非常方便. 修改代码后, 发现一个很奇怪的问题, 将一个元素加进去之后, 移除不了, remove 返回了false. 元素...
Redisson-分布式对象、分布式集合
dreamsofa的专栏
11-14 253
这类映射的使用主要用于在特定的场景下，映射缓存（MapCache）上的高度频繁的读取操作，使网络通信都被视为瓶颈的情况。Write-behind（数据异步写入）策略：对映射的数据的更改会首先写入到Redis，然后再使用异步的方式，通过MapWriter对象写入到外部储存系统。Read-through策略：如果一个被请求的数据不存在于Redisson的映射中的时候，Redisson将通过预先配置好的MapLoader对象加载数据。当本地缓存映射的某条元素发生变动时，同时驱逐所有相同本地缓存映射内的该元素。
lua 代码实现队列 queue
jiahuan
10-28 1592
local queue = {} function queue.new() return setmetatable({first = 1, last = 0}, {__index = queue}) end function queue.offer(self, …) for i, v in ipairs({…}) do self.last = self.last + 1 self[self.las...
优先队列priority_queue的使用
代码菌的blog
04-03 768
#include #include #include using my_pair_t = std::pair; using my_container_t = std::vector; void test_priority_queue() { auto my_comp = [](const my_pair_t e1, const my_pair_t& e2) {
C语言实现优先级队列——priqueue
AnSwEr不是答案
10-22 2880
C语言实现优先级队列在回顾一个学长的项目时，发现他在串口的多线程操作时不是单纯的使用互斥量在读写操作时来共享串口，而是使用了一个优先级队列，在共享串口的基础上，可以设定读或写命令的优先级来决定命令执行序列。在这里，我来分享这个优先级队列的源代码，虽然自己还不是吃的很透，但是现在这里留下记录，希望下次使用时能更进一步，也欢迎大家在下面讨论，交流。源码：priqueue反馈与建议 微博：@AnSwEr不
Lua 实现 冒泡 插入 选择排序
QWBin的博客
11-26 570
Lua 实现 冒泡  插入 选择排序  下面的运行程序可以搜索菜鸟教程去运行练习。 选择排序： temp=0; array = {10,8,6,7,2,9} for i=1,6 do     index=i     for j=i+1,6 do         if(array[j]&lt;array[index])             then             index=j ...
最短路径——优先队列优化版（其实稠密图不优化）
Rachel Zhang的专栏
08-11 2818
Input 输入包含多组，每组首先包含一个n（n 输完后有不定数目组s,t代表起始点地址和终点地址，以0 0 结束 n=0时代表结束，这组数据不需要任何输出。 Output 每对s,t对应一个整数输出，表示s到t的最短距离。 每组数据后加一个空行分隔。 Sample Input 5 0 3 6 8 9 5 0 6 9 4 1 3 0 84 1 45 1
ruoyi-vue-plus和ruiyi-vue区别
05-27
Ruoyi-Vue-Plus 是在 Ruoyi-Vue 的基础上进行了功能扩展和性能优化的版本，它增加了一些新的功能模块，如数据权限管理、在线用户监控、Redis 缓存管理等，同时也对原有功能进行了优化和改进。另外，Ruoyi-Vue-Plus 还添加了一些实用的工具类和代码生成器模板，使开发人员能够更快捷地进行开发。 总的来说，Ruoyi-Vue-Plus 是在 Ruoyi-Vue 的基础上做了一些增强和改进，功能更加完善，性能更加优化，同时也提供了更多的实用工具和模板，方便开发人员进行快速开发。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

MichelleChung

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值