1:C 31 Mar 2025 10:15:53.909 # WARNING Memory overcommit must be enabled! Without it, a background save or replication may fail under low memory condition. Being disabled, it can also cause failures without low memory condition, see https://github.com/jemalloc/jemalloc/issues/1328. To fix this issue add 'vm.overcommit_memory = 1' to /etc/sysctl.conf and then reboot or run the command 'sysctl vm.overcommit_memory=1' for this to take effect.
1:C 31 Mar 2025 10:15:53.909 * oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
1:C 31 Mar 2025 10:15:53.909 * Redis version=7.4.1, bits=64, commit=00000000, modified=0, pid=1, just started
1:C 31 Mar 2025 10:15:53.909 * Configuration loaded
1:M 31 Mar 2025 10:15:53.909 * monotonic clock: POSIX clock_gettime
1:M 31 Mar 2025 10:15:53.910 # Failed to write PID file: Permission denied
1:M 31 Mar 2025 10:15:53.910 * Running mode=standalone, port=6379.
1:M 31 Mar 2025 10:15:53.910 # WARNING: The TCP backlog setting of 511 cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of 128.
1:M 31 Mar 2025 10:15:53.910 * Server initialized
1:M 31 Mar 2025 10:15:53.910 * Reading RDB base file on AOF loading...
1:M 31 Mar 2025 10:15:53.910 * Loading RDB produced by version 7.4.1
1:M 31 Mar 2025 10:15:53.910 * RDB age 159448 seconds
1:M 31 Mar 2025 10:15:53.910 * RDB memory usage when created 3.08 Mb
1:M 31 Mar 2025 10:15:53.910 * RDB is base AOF
1:M 31 Mar 2025 10:15:53.915 * Done loading RDB, keys loaded: 1103, keys expired: 0.
1:M 31 Mar 2025 10:15:53.916 * DB loaded from base file appendonly.aof.12754.base.rdb: 0.006 seconds
1:M 31 Mar 2025 10:15:54.042 # Bad file format reading the append only file appendonly.aof.12754.incr.aof: make a backup of your AOF file, then use ./redis-check-aof --fix <filename.manifest> ]]>
最终基本上实现了这个功能，当时也做了一个基于 SpringBoot 的 Demo ，后来又改了一版基于 Jedis 版本的，因为可以自己定义和操作多线程，更加灵活自由的实现一些细节。
最近提离职后正在交接期，自己的时间比较多，又翻出这个早起的 Demo ，想改造一下，用到我的心情记录员项目中，如果精力和时间有的话我更想将它完善为一个完整的、可复用的项目。
心情记录员小程序为什么要用到这个？以及为什么不用其他成熟的 RabbitMQ ，首先不用其他成熟的原因是我不想搞太多中间件，一个项目中 Redis 安装是大多数情况，因此我想在保持单体应用的基础上实现一个 MQ ，另外的一个原因就是折腾，这也是我本人的一个“缺点”，什么都喜欢自己折腾一下，验证可行性。接下来说说应用场景吧，心情记录员这款小程序目前调用的 AI 是 Kimi 的平台，目前因为是前期，因此是免费版本，并发数限制到了 1 ，这就会导致一个问题，如果同时有两个或者多个（意淫一下，哈哈哈）同时点了记录的时候，这时候有一个肯定会报错，这时候就可以用到消息队列了，将请求的数据先放入队列，等前一个 AI 生成结束后再次调用，就这？……，一个队列不就搞定了吗？当然还有场景了，那就是目前 AI 生成我采用的是 Stream 流式返回，而我是在点击记录后就开始生成，点击记录后会跳转到结果页面，为了使用户跳过去立马就感觉到在生成，因此我就将调用 AI 接口的动作提前到跳转页面前点击记录按钮后，然后给一定到 Loading 延迟在跳转，跳转到结果页后建立 WebSocket 连接，根据 openId 标识接收消息，这时候这个消息其实已经在上一步中在生成了，这里就可以用到消息队列了，根据对应的 openId 到消息队列中取内容，服务端的 WebSocket 只需要根据标识从消息队列中缓存的生成结果进行返回即可，提升了响应速度。
大概流程就像下图这样：
4 年前这个项目的库和博客：
Gitee-redismq （原谅我以前使用 Gitee 的行为，哈哈哈）
]]>- 存数据在服务消费方还是服务提供方；
- 存组合对象，A,B 对象更新，组合对象都需要去更新或者删除再加载；
- 对于分页查询或者 list 查询后，缓存每一条数据，如果通过注解，是否需要详情接口，再去缓存，而不是直接缓存集合数据
这两个系统虽然几乎没什么人用了，但需要的时候可以自取，已开源： https://github.com/Jobcrazy/Redis-WinLegacy
]]>如题
]]>所以请问还有其他好用的 Redis GUI 工具么？ ]]>
HEXPIREandHPEXPIRE：设置秒级和毫秒级生存时间HEXPIREATandHPEXPIREAT：设置秒级和毫秒级 UNIX 过期时间戳HPERSIST：移除过期时间HEXPIRETIMEandHPEXPIRETIME：获取秒级和毫秒级 UNIX 过期时间戳HTTLandHPTTL：获取秒级和毫秒级生存时间
https://github.com/redis/redis/releases/tag/7.4-rc1
这么多年了，终于来了
]]>难道每次执行什么 get,set 操作，都会检测一遍密码吗？ 我理解不能像 mysql 一样，有个连接池，初始化一些长连接，之后就不用再认证/鉴权什么的了
- Redis 大部分测试约 17w qps
- 单 CPU 时，Garnet 大部分测试约 3w qps
- 不限制 CPU （共 10 核）时，CPU 占用率约 300%，大部分测试约 4w qps
难道要用 C# 跑测试才能发挥 Garnet 的性能？ https://microsoft.github.io/garnet/docs/benchmarking/results-resp-bench
]]>Timeout awaiting response (outbound=1KiB, inbound=0KiB, 5728ms elapsed, timeout is 5000ms), command=SET, next: EVAL, inst: 0, qu: 0, qs: 15, aw: False, bw: SpinningDown, rs: ReadAsync, ws: Idle, in: 76, in-pipe: 0, out-pipe: 0, serverEndpoint: 127.0.0.1:6379, mc: 1/1/0, mgr: 10 of 10 available, clientName: AppProductionEnvServer1(SE.Redis- v2.5.43.42402), IOCP: (Busy=0,Free=10000,Min=9000,Max=10000), WORKER: (Busy=236,Free=32531,Min=10000,Max=32767), POOL: (Threads=236,Queueditems=50,Completeditems=8751117254), v: 2.5.43.42402 (Please take a look at this article for some common client-side issues that can cause timeouts: https://stackexchange.github.io/StackExchange.Redis/Timeouts) 出错的时候看了下也就三百多并发，比较怀疑是下面这段代码引起的：
while (!await redis.GetDatabase().LockTakeAsync($"PlaceOrder:{user.UserId}", "1", TimeSpan.FromSeconds(180))) { await Task.Delay(1); } 作用是确保同一用户只有一个订单未写入数据库（系统下单逻辑涉及几十个函数，全是一些莫名奇妙的判断逻辑，混淆后可读性大幅提升的那种（当然是开玩笑的）），屎山作者已经跑路了，没人能看懂他代码，一个用户下多个订单数据会混乱。更牛逼的这套系统除了性能极差，运行 3 年没出错一次。一次调用 API 只能下一单，客户端随硬件交付，已经写死了，不能更新，然后客户端一次多少个订单就多少并发调用 API 提交，没有队列功能。目前要求 500 订单 10 秒内全部下单完成返回订单号（单独提交的话每个订单 0.01 秒左右能写入完数据拿到订单号）。
预分配订单号行不通，不运行一遍这部分屎山代码不能确定这个订单能不能提交，返回订单号就代表这个订单提交成功了，不能取消。目前打算改造成 Sub/Pub ，不知道能不能提升性能，或者 V 友有没有更好的改造方案？只要能让这屎山跑起来就行，代码多脏都没关系，改动需要尽可能小，不能把系统改炸。目前加硬件到 256GB 内存都没解决。
]]>PersonInfo person_info; person_info.age = 20; strcpy(person_info.addr, "sz");
redisContext * cc;
std::string name = "JACK";
如果要将上面的 name 和 person_info 传给 lua 脚本,应该怎么做呢? 下面的写法是不完整的, 但是又不知道该怎么写才对.
redisCommand(cc, "EVALSHA %s 1 %s", "redis 返回的 lua 脚本 sha1 值", name.c_str());
]]>而且还有个好处就是避免了常说的“缓存一致性问题”😄。
各位大佬厂里有没有这样用的？如果没有原因是什么呢？
]]> ConnectionMultiplexer redis = ConnectionMultiplexer.Connect("localhost"); Stopwatch stopwatch = Stopwatch.StartNew(); var count = 100000; for (int i = 0; i < count; i++) { var id = (int)redis.GetDatabase().StringIncrement("PMDCS:id_hello"); } stopwatch.Stop(); Console.WriteLine("用时:" + stopwatch.ElapsedMilliseconds + ", tps=" + (count / stopwatch.ElapsedMilliseconds)); 测试结果 用时:8357, tps=11
]]>唯一的一次,还是自己 py 程序的问题,原因记不清楚了,好像是自己往 redis 里面写日志,忘了设置过期时间了.
还是就是 celery 用 redis 做 broker,会断联的问题,但是这个 python 单线程遇到 pub/sub 导致的,redis 还是稳
]]>https://github.com/hcymysql/redis_monitor
Redis Monitor 可以监控单机模式，哨兵模式，集群模式，并且录入一个主库或者从库 IP ，自动发现主库或者从库 IP 信息，无需人工再次录入。
采用远程连接方式获取数据，所以无需要在 Redis 服务器端部署相关 agent 或计划任务，可实现微信和邮件报警。
注：监控环境为 Redis 6.2 以上版本。
]]>然后主节点自动都转移到了其中一台机器上，此时 kill 掉这台机器，发现集群无法恢复，貌似是没法投票了。
应该如何避免这种情况发生呢？
]]>- 有个单点登录 CAS 服务，其他服务登录时会请求一个 ticket ，CAS 服务颁发完 ticket 后，会写入 redis 。
- 其他服务获取到 ticket 后，会调用 CAS 服务的另一个接口去校验 ticket ，同时获取用户信息。
现在偶尔会出现一个问题：执行第 2 步操作时，有时候校验 ticket 会不通过
排查一下： redis 主从偏移有点大，造成主从数据不一样，校验接口走从库时查询不到 ticket 所以校验失败，大概是网络原因？
想到的一个解决方案是，校验接口强制走主库，但是哨兵模式下主库是不固定，有啥办法强制走主库吗（ Java 语言的 SDK ）？
或者有更好的解决方案？
]]>出现的情况是有时候 B 已经将数据写入 redis 了,但是 A 读不到. 查询写入使用的同一个 StringRedisTemplate.
有时候查不到就很迷
顺便吐槽下华为云 -- huaweicloud.csdn.net
点下阅读全文就自动获取手机号发送注册验证码..
如果这些 key 能够散列在同一个 slot ，那没什么问题。
如果这些 key 之确保散列在同一个节点，可以吗？ 大部分博客都只说要求散列在同一个 slot 。
散列在同一个节点会有问题吗？ 有没有相关参考文档？ ]]>
Redis has a different evolution path in the key-value DBs where values can contain more complex data types, with atomic operations defined on those data types.
是不是所有 redis 7 的命令都是原子的？这跟 chatgpt 中给的答案不一样
]]>如果是 Redis 主从集群，能避免这种情况吗？集群全挂了呢?
注：目前解决缓存与数据库一致所使用的方案，是双写方案，写操作-先写数据库再删缓存，读操作-有缓存就读缓存，无缓存就读数据库后重建缓存
但这种方案的问题是，缓存服务挂了后，在写操作时无法删掉过期缓存，最后等缓存服务恢复，读操作读到的就是过期数据
请老哥们指点一下，
难道因为缓存服务挂掉，就拒绝一切写操作吗？ ]]>
A：MySQL 以前有缓存，但由于命中率不高，在新版本中已经舍弃掉了。
Q：那 Oracle 数据库呢？ Oracle 数据库有缓存吗？
A：不清楚。
Q：不论是 MySQL 还是 Oracle ，只要是数据库就应该都有缓存，那为什么数据库有缓存，还要使用 Redis ？
A: Redis 支持分片集群，缓存容量容易扩展；而 MySQL 是为单机设计的，缓存容量受限于运行 MySQL 的主机内存。
但面试官好像对这个回答不太满意
现在回想起来，虽然当时是我混淆了“MySQL 查询缓存”和“MySQL 的 Buffer Pool”，但是，MySQL 的 Buffer Pool 也起到了缓存作用，减少磁盘 IO 。
为什么 MySQL 有缓存，还要使用 Redis ？
这个问题，目前我只想到从两个角度回答：
1. Redis 支持分片集群，缓存容量容易扩展。
2. 多级缓存。Redis 内存->Buffer Pool->磁盘。
各位还有什么别的看法吗？ ]]>
- cacheMiss 时，生成一个对应 cacheKey 的 leaseId （ redis 生成一个值：key 是
cacheKey + "_id"，value 是随机数，expireTime=10 秒，若 key 已存在则失败），若生成 leaseId 失败则等待并重试。 - cacheMiss 后，先查 db 再更新缓存，但更新缓存的时候，需要检查 leaseId 是否有效（ redis 是否存在 key=
cacheKey + "_id"、value=leaseId 的值） - 每次更新 db 后，删除缓存，同时删除 leaseId （ redis 删除 key=
cacheKey + "_id"的值）
这样有什么问题吗？
]]>因为用户的客户端不可信，有几个问题不知道如何解决，独立的临时账号解决了客户端的安全问题，那么主要是客户端的资源占用的限制上。
- 1 、怎么限制客户端的请求频率，用 iptable 来限制？
- 2 、怎么限制单个用户的占用的内存。
目前想到的- 2.1 、client-query-buffer-limit 限制输入缓冲区
- 2.2 、后端不断执行 CLIENT LIST 踢掉占用太大的用户？
- 2.3 、怎么限制同一个用户重复登陆 redis ？只能定时用 CLIENT LIST 去扫描吗
暂时只想到这些，恳求各位赐教！
]]>往消息队列里面发消息的方式，但是多用户并发的情况下，其实会有多个用户过来请求更新缓存，当然可以用分布式锁来处理，只让一个用户生成缓存成功。
这个就是我的一个想法，有没有更好的方案？ ]]>
使用过两种方案
1.ip 存为 set 类型 每次使用 srandmember 随机抽取, 但测试发现 非常不随机
2.ip 存为 list 类型 每次 rpoplpush 到同一队列, 这个可以实现完全平均的使用,但有个问题无法解决, 因为可能某一个 ip 某短时间不可以使用, 需要从队列中移除, 但是使用 list 无法移除某一个失效的 ip
想问下大佬们 有什么好的解决方案吗 ]]>
not in the same slot 的错误，感觉我的这个脚本可能与会遇到。如果我真的通过 key 加前缀的方式保证他们在同一个 slot 内是不是也会导致 cluster 处于一个不健康的集群状态。 local userAttributiOnKey= KEYS[1]; local humeSource = KEYS[2]; local attributeKeys = cjson.decode(KEYS[3]); if redis.call("EXISTS", userAttributionKey) == 1 then -- get attribution cache local res = redis.call("GET", userAttributionKey); if res then return { 1, res }; end end local matchResult = {}; local hits = {}; local latestTime = 0; for i = 1, #attributeKeys do local indexInfoString = redis.call("GET", attributeKeys[i]); if indexInfoString then local indexInfo = cjson.decode(indexInfoString); local reportSource = indexInfo['report_source']; local uniqId = indexInfo['uniq_id']; local timestamp = tonumber(indexInfo['timestamp']); if humeSource == '' or humeSource == indexInfo['report_source'] then -- check attribute index info if reportSource ~= '' and uniqId ~= '' then if timestamp > latestTime then indexInfo['hit'] = attributeKeys[i]; indexInfo['match_res'] = 'matched'; matchResult = indexInfo; latestTime = timestamp; end table.insert(hits, attributeKeys[i]); else return redis.error_reply("Invalid Info:" .. indexInfoString); end end -- delete attribute key cache redis.call("DEL", attributeKeys[i]) end end if #hits > 0 then matchResult['hits'] = hits; local matchResultStr = cjson.encode(matchResult); -- set attribution cache redis.call("SET", userAttributionKey, matchResultStr, "EX", ARGV[1]); return { 1, matchResultStr }; end return { 0, cjson.encode(matchResult) }; 请教下大佬和前辈，我这是不是一种错误的使用方式？以及 lua script 使用时有什么注意事项？
]]>redis-cli -a myPassword -h redis-host -p 6379 --scan --pattern '*myKey*' 但使用下面的命令,却无法删除成功
redis-cli -a myPassword -h redis-host -p 6379 --scan --pattern '*myKey*' | xargs redis-cli -a myPassword -h redis-host -p 6379 unlink (integer) 0 当然了, 把 unlink 改成 del 也是一样的效果, 不知道大家有没有解决过一样的问题?
要求：希望在推送消息时尽可能的快，低延时。
为了达到这个要求，选择对 zset 做分片，分片的规则是：按订阅用户的 userid 做 hash 取值，取值结果按分片数取模，在分配到相应的 zset 分片上。
问题：zset 数据除了承担 push 消息通知的数据源之外，还用于查询用户是否订阅该活动的状态查询（这个没啥问题，找到对应的分片，然后查询 zscore 即可）和订阅总数计算的角色。如果我为了某些活动可能超过百万的关注订阅数，而设置 1024 个 zset 分片，是不是意味着绝大多数的活动，为了计算总数都要去做 1024 次 zcount 再将 result 相加才能得到结果？感觉也不是很好的设计。。。。（当然也可以总数单独维护，不通过 zset 分片结果相加获取，就是这样又增加了存储成本）
大家觉得该怎么做比较合适呢？ ]]>
延迟队列的设计：目前是依赖 redis ，生产者向 redis 的 zset 中投递 task 信息，score 是活动的通知时间（活动开始时间-15 分钟），然后轮询这个 task 的 redis key ，读取到期是任务信息，读取到之后将该任务信息投递到 redis 的 list （通过 rpush ）中，消费者则一直读取这个 list 队列（通过 lpop ）。
目前想探讨的是：这个方案是否在活动很多的时候导致推送消息的延迟（虽然可以通过增加消费者来缓解，正常哪怕是一个活动有百万级别的活动关注者（极其罕见），从 redis 的 zset 中分页拉取出来并投递消息，一般处理时长不会超过 10 分钟）
但是隐隐约约还是觉得是不是还有更好的方案呢？可以尽量减少延迟的方案。 ]]>
但是第二页和第三页却不能这么处理，因为直接从各个 zset 中获取排名 10 到 20 的 value ，来做排序合并得到的结果并不准确
能想到的一个方案是把所有的 zset 都合并成一个总的 zset 再来分页切割，但是感觉这样太耗费性能了，不是一个好的方案。 ]]>
实现方案:
一般涉及到这种需求，都会想到用布隆过滤器或者 bitmap 来实现，我最终选择了用布隆过滤器，不用 bitmap 的主要原因是:
1.目前 post_id 的值是雪花算法生成的，长度有 16 位，如果不做处理直接把这个 id 当成 bitmap 的 offset 会造成极大的内存空间浪费，而怎么把这些 post_id 转换成更小的从 1 开始递增的数字，处理起来比较麻烦（不是不可以，自己想到的就有几种，比如说:因为展示的内容都是关联了某些 tag 的内容，用数据库里面的关联关系表的 id 作为 bitmap 的 offset 来处理是可以做到的,之所以不选择 bitmap 最主要还是下面的原因 2 ）;
2.getbit 不支持批量查询（当然我知道有人可能要说可以用 lua 脚本，用 pipeline 之类的，但是写起来有点麻烦）而选择布隆过滤器就没有上面这两个问题了
这次选用的是直接装 redis 的布隆过滤器模块，实现方案如下:
1.每个用户初始化一个 500 长度的布隆过滤器，用户已阅的内容通过 bf.add 操作加入他的布隆过滤器中
2.获取列表数据的时候，按下面的步骤进行:
2.1 从 zset 中读取 100 条数据，
2.2 通过 bf.mexist 操作查询这些内容是否已阅，已阅的内容跳过
2.3 一直循环 2.1 和 2.2 步骤，直到查到满足条目数的内容为止（目前是定的 12 条一页）
2.4 如果 zset 查到最后都没有得到满足条件的条目数，则返回经过了 2.1 和 2.2 步骤之后获取到的数据（可能有数据，只是不满足 12 条的条件，总数记为 total1 ）+zset 中按发布时间顺序倒序获取 12-total1 条数据作为补充 2.5 什么时候删除用户的布隆过滤器？ 2.4 步骤中发现 total1 的数量为 0 （说明所有内容都已经阅读过了）时进行删除
内存占用估算:有试过模拟一个 500 长度 size 的布隆过滤器大致的内存占用为 800 多个字节，按 50w 日活来计算的话，总的占用空间为两三百 M 左右，在可接受范围内，但是如果为每个用户初始化 1000 长度 size 的布隆过滤器，内存占用就有点高了，初步预估在 900M 左右
我的疑问:
1.其实用布隆过滤器的方案，有通过 golang 自己依赖 redis 的 bitmap 结构实现一个的方案也有直接用 redis 的布隆过滤器模块（需要编译安装）的方案，我好奇哪种方案更好？
2.上面说到的获取列表数据的逻辑，总感觉是不是有什么地方可以优化，因为按上面描述的逻辑，每一次都要遍历一遍 zset 中的数据，最差的情况下，会有数十次的 redis 查询（比如最后一页）
3.可能有人会说可以用 bf.count 看用户已阅内容的总数，因为总是最新的内容展示出来，那么直接跳过 bf.count 的总数去获取数据即可，就不用那么麻烦，但是这样获取有个问题，就是新加入 zset 的内容（而且发布时间还是最新的），按这个方案来处理，几乎无法得到展示（只有等内容耗尽，到下一轮推荐才能展示）
4.这个列表是展示在用户签到的下方内容推荐的模块中，我在想每个用户的布隆过滤器初始长度设置为多少比较合适，一开始想着直接设置 1000 的长度，但是想到真实的场景，用户可能签完到就离开了，不会去消费内容（虽然不会主动下拉消费，但是底部会外漏出 2 到 4 条内容出来，也被认为是用户已阅的内容），所以直接初始化 1000 长度我感觉有点浪费，所以考虑先初始化 500 个，消费内容超过 500 个的话，Redis 的布隆过滤器会自动扩容，扩容成自己的 2 倍内存空间（试过，这种扩容最终占的内存空间会比一开始就初始化 1000 长度的内存空间占用大很多），不知道这么设计是否合适？以上就是我个人的一些实现方案的想法和探索，大家有什么观点和看法，欢迎评论留言一起探讨一下 ]]>
实现：将用户 id 经过 murmurhash 计算出来的哈希结果按 4 取模，得到分桶信息，将该结果保持到 redis 中，每个用户一个 redis key ，字符串类型存储，如 abresult_11111(user_id):1,程序开始执行时先读取 redis ，如果存在分桶记录，那么直接返回，不存在则进行分桶操作，并将分桶结果发给数据部门
疑问：
目前这个设计是一个好的设计吗？百万级别的用户量的话，是不是会生成百万的 redis key ，印象中 redis_key 过多不是一个好的设计，比如不好管理等。
我能想到的几个问题：
1.印象中用 hash 结构来存储，会被这种存储方式节约内存,但是用 hash 来存储必然导致 big key 问题，当然在这种场景下面，不涉及像 getall 那样的 O(n)操作，是不是 big key 问题可以基本忽略不计？印象中 big key 可能导致的问题不止是性能问题，还有像数据倾斜导致的访问倾斜问题等，所以用 hash 来存储的话是不是也要那用户 id 来做分片才是比较合适的方案？
2.redis 的删除是惰性删除+定时删除，定时删除基于取样，取样的话如果失效的数据过多，印象中会一直不断的循环删除，指定取样的结果不满足为止，想知道这个定时删除是在主进程上完成的吗？如果过多的 key 失效，会阻塞 redis 进程吗？
大佬们，一起讨论下啊？一个是上面提出的一些问题，还有就是如果是你们来设计的话会怎么设计？ ]]>
报的异常如下
生产者异常： :"sendQueueMessageInfo leftPushAll : 异常 : org.springframework.data.redis.RedisConnectionFailureException: Unexpected end of stream.; nested exception is redis.clients.jedis.exceptions.JedisConnectionException: Unexpected end of stream. org.springframework.data.redis.connection.jedis.JedisExceptionConverter.convert(JedisExceptionConverter.java:67) org.springframework.data.redis.connection.jedis.JedisExceptionConverter.convert(JedisExceptionConverter.java:41) org.springframework.data.redis.PassThroughExceptionTranslationStrategy.translate(PassThroughExceptionTranslationStrategy.java:44) org.springframework.data.redis.FallbackExceptionTranslationStrategy.translate(FallbackExceptionTranslationStrategy.java:42) org.springframework.data.redis.connection.jedis.JedisConnection.convertJedisAccessException(JedisConnection.java:142) org.springframework.data.redis.connection.jedis.JedisListCommands.convertJedisAccessException(JedisListCommands.java:486) org.springframework.data.redis.connection.jedis.JedisListCommands.lPush(JedisListCommands.java:84) org.springframework.data.redis.connection.DefaultedRedisConnection.lPush(DefaultedRedisConnection.java:444) org.springframework.data.redis.core.DefaultListOperations.lambda$leftPushAll$2(DefaultListOperations.java:124) org.springframework.data.redis.core.RedisTemplate.execute(RedisTemplate.java:224) org.springframework.data.redis.core.RedisTemplate.execute(RedisTemplate.java:184) org.springframework.data.redis.core.AbstractOperations.execute(AbstractOperations.java:95) org.springframework.data.redis.core.DefaultListOperations.leftPushAll(DefaultListOperations.java:124) com.service.ds.exec.DataSourceActuator.sendQueueMessageInfo(DataSourceActuator.java:392) com.service.ds.exec.DataSourceActuator.execAndPushQueue(DataSourceActuator.java:214) com.controller.rest.etl.EtlTaskRestController$1.run(EtlTaskRestController.java:86) java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142) java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617) java.lang.Thread.run(Thread.java:745)\
Caused by: redis.clients.jedis.exceptions.JedisConnectionException: Unexpected end of stream. redis.clients.util.RedisInputStream.ensureFill(RedisInputStream.java:199) redis.clients.util.RedisInputStream.readByte(RedisInputStream.java:40) redis.clients.jedis.Protocol.process(Protocol.java:153) redis.clients.jedis.Protocol.read(Protocol.java:218) redis.clients.jedis.Connection.readProtocolWithCheckingBroken(Connection.java:341) redis.clients.jedis.Connection.getIntegerReply(Connection.java:266) redis.clients.jedis.BinaryJedis.lpush(BinaryJedis.java:1119) org.springframework.data.redis.connection.jedis.JedisListCommands.lPush(JedisListCommands.java:82)\n\t... 12 more\n","stackTrace":"","reqId":"","elapsedTime":null}
消费者异常： 1","className":"com.service.schedule.SchedulerTask$1","lineNumber":"63","message":"队列消费 : 异常 : org.springframework.data.redis.RedisConnectionFailureException: Cannot get Jedis connection; nested exception is redis.clients.jedis.exceptions.JedisConnectionException: Could not get a resource from the pool org.springframework.data.redis.connection.jedis.JedisConnectionFactory.fetchJedisConnector(JedisConnectionFactory.java:281) org.springframework.data.redis.connection.jedis.JedisConnectionFactory.getConnection(JedisConnectionFactory.java:464) org.springframework.data.redis.core.RedisConnectionUtils.doGetConnection(RedisConnectionUtils.java:132) org.springframework.data.redis.core.RedisConnectionUtils.getConnection(RedisConnectionUtils.java:95) org.springframework.data.redis.core.RedisConnectionUtils.getConnection(RedisConnectionUtils.java:82) org.springframework.data.redis.core.RedisTemplate.execute(RedisTemplate.java:211) org.springframework.data.redis.core.RedisTemplate.execute(RedisTemplate.java:184) org.springframework.data.redis.core.AbstractOperations.execute(AbstractOperations.java:95) org.springframework.data.redis.core.DefaultListOperations.leftPush(DefaultListOperations.java:99) com.service.etl.consumer.QueueConsumer.retryQueueMessage(QueueConsumer.java:101) com.service.etl.consumer.QueueConsumer.consume(QueueConsumer.java:180) com.service.schedule.SchedulerTask$1.run(SchedulerTask.java:60) java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)java.lang.Thread.run(Thread.java:745)\nCaused by: redis.clients.jedis.exceptions.JedisConnectionException: Could not get a resource from the poolredis.clients.util.Pool.getResource(Pool.java:53)redis.clients.jedis.JedisPool.getResource(JedisPool.java:226)redis.clients.jedis.JedisPool.getResource(JedisPool.java:16) org.springframework.data.redis.connection.jedis.JedisConnectionFactory.fetchJedisConnector(JedisConnectionFactory.java:271)\n\t... 14 more\nCaused by: redis.clients.jedis.exceptions.JedisConnectionException: java.net.SocketException: Connection resetredis.clients.util.RedisInputStream.ensureFill(RedisInputStream.java:202) redis.clients.util.RedisInputStream.readByte(RedisInputStream.java:40) redis.clients.jedis.Protocol.process(Protocol.java:153) redis.clients.jedis.Protocol.read(Protocol.java:218) redis.clients.jedis.Connection.readProtocolWithCheckingBroken(Connection.java:341) redis.clients.jedis.Connection.getStatusCodeReply(Connection.java:240) redis.clients.jedis.BinaryJedis.auth(BinaryJedis.java:2223) redis.clients.jedis.JedisFactory.makeObject(JedisFactory.java:108) org.apache.commons.pool2.impl.GenericObjectPool.create(GenericObjectPool.java:889) org.apache.commons.pool2.impl.GenericObjectPool.borrowObject(GenericObjectPool.java:424) org.apache.commons.pool2.impl.GenericObjectPool.borrowObject(GenericObjectPool.java:349) redis.clients.util.Pool.getResource(Pool.java:49)\n\t... 17 more\nCaused by: java.net.SocketException: Connection reset java.net.SocketInputStream.read(SocketInputStream.java:209) java.net.SocketInputStream.read(SocketInputStream.java:141) java.net.SocketInputStream.read(SocketInputStream.java:127) redis.clients.util.RedisInputStream.ensureFill(RedisInputStream.java:196)\n\t... 28 more\n","stackTrace":"","reqId":"","elapsedTime":null}
redis 配置
public RedisTemplate<String, QueueMessageInfo> redisQueueMessageTemplate(RedisConnectionFactory factory) { RedisTemplate<String, QueueMessageInfo> template = new RedisTemplate<String, QueueMessageInfo>(); template.setConnectionFactory(factory); // 使用 Jackson2JsonRedisSerializer 来序列化和反序列化 redis 的 value 值 Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<Object>(Object.class); ObjectMapper om = new ObjectMapper(); om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY); om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL); serializer.setObjectMapper(om); template.setValueSerializer(serializer); template.setKeySerializer(new StringRedisSerializer()); template.setHashKeySerializer(new StringRedisSerializer()); template.afterPropertiesSet(); return template; } @Bean public RedisConnectionFactory connectionFactory() { JedisPoolConfig poolCOnfig= new JedisPoolConfig(); poolConfig.setMaxTotal(maxActive); poolConfig.setMaxIdle(maxIdle); poolConfig.setMaxWaitMillis(maxWait); poolConfig.setMinIdle(minIdle); poolConfig.setTestOnBorrow(true); poolConfig.setTestOnReturn(false); poolConfig.setTestWhileIdle(true); JedisClientConfiguration jedisClientCOnfiguration= null; if (ssl) { jedisClientCOnfiguration= JedisClientConfiguration.builder().usePooling().poolConfig(poolConfig).and() .readTimeout(Duration.ofMillis(timeout)).useSsl().build(); } else { jedisClientCOnfiguration= JedisClientConfiguration.builder().usePooling().poolConfig(poolConfig).and() .readTimeout(Duration.ofMillis(timeout)).build(); } RedisStandaloneConfiguration redisStandalOneConfiguration= new RedisStandaloneConfiguration(); redisStandaloneConfiguration.setDatabase(redisDatabase); redisStandaloneConfiguration.setPort(port); redisStandaloneConfiguration.setPassword(password); redisStandaloneConfiguration.setHostName(host); RedisConnectionFactory redisCOnnectionFactory= new JedisConnectionFactory(redisStandaloneConfiguration, jedisClientConfiguration); logger.info("初始化 redis 链接池 : JedisPoolConfig"); return redisConnectionFactory; } # 池在给定时间可以分配的最大连接数。使用负值无限制。 #spring.redis.pool.max-active=200 spring.redis.pool.max-active=200 # 池中“空闲”连接的最大数量。使用负值表示无限数量的空闲连接。 # spring.redis.pool.max-idle=20 spring.redis.pool.max-idle=20 # 连接分配在池被耗尽时抛出异常之前应该阻塞的最长时间量（以毫秒为单位）。使用负值可以无限期地阻止。 spring.redis.pool.max-wait=9000 # 目标为保持在池中的最小空闲连接数。这个设置只有在正面的情况下才有效果。 #spring.redis.pool.min-idle=20 spring.redis.pool.min-idle=20