Redis 核心机制 | Lazy Free:异步删除大 Key ,架构师视角的机制、代价与决策框架

Lazy Free 管的不是「什么时候删」,而是「删的时候谁干活」。它把从键空间摘除 (主线程,O(1))和递归释放内存(BIO 线程,O(N))拆开。本文按「先实验看到差异 → 再讲机制 → 再给命令与代码 → 最后说代价与边界」的顺序组织,因为结论只有先被观测到,判据才立得住。

一、开篇:一次能看见差异的删除

本节用一个可复现的实验,同时量出「主线程耗时」与「内存归还时点」。下文 bash 块为 Linux / msys2 形态(依赖 grep/seq/awk/sleep),注释写在对应命令的上一行;text 块是输出样本,不可执行;带 | 的管道只能贴在 shell 里跑。

先钉死一组易混概念:惰性删除 (lazy expire)回答「过期键何时被判定过期」;惰性释放(Lazy Free)回答「删除时内存何时释放」。名字相近,机制无关。

动手前先自查版本与语法:

bash 复制代码
# 客户端与服务端版本必须对齐:8.x 与 7.x 的 INFO 分段不同,结论不可混用
redis-cli -p 6379 --version
redis-cli -p 6379 INFO server | grep -E 'redis_version|os:'
# 密码走环境变量,不进进程列表;生产更推荐 --user + ACL 只给 +info 的账号
REDISCLI_AUTH='<密码>' redis-cli -h 127.0.0.1 -p 6379 PING
# 语法自查:HELP 给出 since 与命令分组;COMMAND INFO 给出 arity=-2、flags write/fast、key 位置区间
redis-cli -p 6379 HELP UNLINK
redis-cli -p 6379 COMMAND INFO UNLINK
text 复制代码
redis-cli 8.10.3

  UNLINK key [key ...]
  summary: Asynchronously deletes one or more keys.
  since: 4.0.0
  group: generic

造数 :别用 EVAL 循环灌百万级字段------实测 50 万次 redis.call('HSET') 已耗 3.0 秒、100 万次 6.2 秒,超过 lua-time-limit(默认 5 秒)后其他客户端会收到 BUSY,且带写命令的脚本不能 SCRIPT KILL。用 --pipe:

bash 复制代码
# 生成 100 万条内联 HSET 喂给 --pipe;seq/awk 是 shell 工具,整条管道不能粘进 redis-cli 交互界面
seq 1 1000000 \
  | awk '{print "HSET big:hash f" $1 " v"}' \
  | redis-cli -p 6379 --pipe
text 复制代码
All data transferred. Waiting for the last reply...
Last reply received from server.
errors: 0, replies: 1000000

errors: 0 是成功判据,灌完再用 HLEN big:hash 复核--------pipe 省 RTT 但不保证原子性,中途失败会留半成品。Windows 不支持 < 重定向,改用 cmd /c "type hset.txt | redis-cli -p 6379 --pipe"(其中 redis-cli 换成全路径),20 万条实测约 3.2 秒。

打开两个观测面 (不先开,后面的 LATENCY 永远是空数组):

bash 复制代码
# 延迟监控默认关闭(0),设为 1 毫秒才能捕获尖峰
redis-cli -p 6379 CONFIG SET latency-monitor-threshold 1
# 慢日志阈值清零(微秒):让所有命令入日志,才看得见 UNLINK 的几十微秒
redis-cli -p 6379 CONFIG SET slowlog-log-slower-than 0
# 回读确认:CONFIG SET 返回 OK 只代表写入成功
redis-cli -p 6379 CONFIG GET latency-monitor-threshold slowlog-log-slower-than
text 复制代码
slowlog-log-slower-than
0
latency-monitor-threshold
1

CONFIG GET 一次可传多个参数,输出是「名一行、值一行」的扁平序列且顺序不保证,脚本必须按名配对。

删两次,看两条曲线:

bash 复制代码
# 先清空慢日志:阈值 0 时任何命令都会入日志,不清空取到的就不是 DEL
redis-cli -p 6379 SLOWLOG RESET
# 同步删除:主线程承担全部 O(N) 释放
redis-cli -p 6379 DEL big:hash
# 取最近 1 条:第 3 字段即主线程净耗时(微秒)
redis-cli -p 6379 SLOWLOG GET 1
text 复制代码
1) (integer) 1000006
2) (integer) 1794983569
3) (integer) 525622
4) 1) "DEL"
   5) "big:hash"
6) "127.0.0.1:64628"
7) ""

525622 微秒 = 525.6 毫秒;第 6 字段是客户端名,未 CLIENT SETNAME 时为空串。重建同规模 Hash(复用上面的 --pipe)后换成异步删:

bash 复制代码
# 百万字段必然是 hashtable,这是「会不会走异步」的第一手证据
redis-cli -p 6379 OBJECT ENCODING big:hash
# 清空慢日志,保证下一条取到的就是 UNLINK
redis-cli -p 6379 SLOWLOG RESET
# 异步删除:主线程只摘引用并入队,O(N) 释放交给 BIO
redis-cli -p 6379 UNLINK big:hash
# 阈值 0 下 UNLINK 也会入日志,但耗时应只有几十微秒
redis-cli -p 6379 SLOWLOG GET 1
text 复制代码
1) (integer) 2000011
2) (integer) 1794983576
3) (integer) 37
4) 1) "UNLINK"
   5) "big:hash"
6) "127.0.0.1:59514"
7) ""

同样的 Key、同样的删除语义,主线程耗时相差约 1.4 万倍(525,622 µs vs 37 µs)。10 万字段规模下是 70,827 µs vs 27 µs,量级关系不变------所以 4.5 的验证流程用 10 万规模就够,不必每次都灌百万级。

内存不会立刻还回来:

bash 复制代码
# 采 4 次、间隔 150 毫秒,把 pending 回落与 used_memory 下降放在同一条时间线上
for i in 1 2 3 4
do
  redis-cli -p 6379 INFO memory | grep -E 'used_memory:|lazyfree_pending_objects'
  # 间隔必须短于释放总时长,否则第一采就是 0(10 万规模常见)
  sleep 0.15
done
text 复制代码
used_memory:31905492 lazyfree_pending_objects:1
used_memory:19784232 lazyfree_pending_objects:1
used_memory:10287291 lazyfree_pending_objects:1
used_memory:934040   lazyfree_pending_objects:0

约 0.5 秒后释放完成:pending 归零,used_memory 从 31.9 MB 降到 0.93 MB。这 0.5 秒里 EXISTS 早已返回 0------「键没了」和「内存还了」被解耦。

两个常见误判 。

①「DEL 只是标记键消失、清理交给后台」是错的:原生 DEL 在开 lazyfree-lazy-user-del 之前完全同步,返回时内存已释放。

②「采不到 pending=1 说明没走异步」也是错的,那只说明 BIO 已干完;判据是 lazyfreed_objects 有没有 +1(实测 10 万字段异步删后由 0 变 1,四条采样全是 0)。要观察 pending 爬升,用百万级规模或把采样间隔压到 50 毫秒内。

决策落点 :线上 SLOWLOG 出现高耗时 DEL 而业务没改代码时,第一动作查版本与开关(CONFIG GET lazyfree-lazy-user-del),第二动作查编码与规模(OBJECT ENCODING / MEMORY USAGE),不要先怀疑网络抖动。

二、机制:摘除与释放的分离

本节把「谁在干活、卡在哪一步」讲清,后面所有取舍都从这里推。

保证 :摘除留在主线程且是 O(1),释放交给 BIO,主线程不为元素数量级耗时代价;键对外立即不可见。不保证 :内存立刻归还操作系统(used_memory 滞后,used_memory_rss 更滞后);释放不耗 CPU(只是换了线程,总工作量不变);释放完成时点可预期(取决于队列深度与线程调度,且没有完成通知)。

UNLINK 的复杂度是「每个 Key O(1) 摘除」,O(N) 回收在另一个线程完成。唯一要记住的阻塞点 :free_effort 未超阈值时,即使写了 UNLINK,释放仍落在主线程------dbAsyncDelete 先估算成本,只有够大才投递 BIO,小对象不值得线程切换开销。

Lazy Free 不是单个开关,而是一族开关,每条路径各有归属(默认值均为本机 8.10.3 实测):

三条协作口径:

①命令级与开关级不是一回事 ------UNLINK 只管这一条命令,粒度细、影响可控;lazyfree-lazy-user-del 是把所有 DEL 切成异步的全局行为变更,两者可并存,UNLINK 不受任何开关影响。

②淘汰级与过期级只改「怎么执行删除」,不改「删哪一个」「何时判定过期」 :开关开启后 performEvictions 选中 Key 走 dbAsyncDelete 而非 dbSyncDelete,传播给从库与 AOF 的命令也从 DEL 变 UNLINK;过期路径同理,只是触发者换成过期回收循环。

③键对外不可见永远在主线程立刻完成,同步与异步的区别只在内存回收由谁做。

决策落点 :机制价值与「Key 大小 × 编码」强相关。引入前用 MEMORY USAGE + OBJECT ENCODING 摸清业务 Key 的规模与编码分布;若 p99 Key 都是 listpack/intset/String,引入它是负收益。

2.1 free_effort:编码决定一切

free_effort 不是简单的元素数量,先看编码再谈规模:

两条直接结论:

  1. 编码是闸门,规模是扳机。 100 字段 Hash 因 listpack 永远同步;一旦超过 hash-max-listpack-entries(8.10.3 实测默认 512 )转成 hashtable,就必然异步------能转编码说明元素数已远超 free_effort 阈值 64。反过来 200 字段仍是 listpack(200 < 512),依旧同步 。转编码阈值(512,可配)与投递阈值(64,源码常量 LAZYFREE_THRESHOLD)是两个不同的数,判据只能是 OBJECT ENCODING,不是 HLEN。
  2. String 无论多大都同步释放。 这是别在 Redis 里存超大 String 的硬理由之一(另一条是网络与序列化成本)。

决策落点 :判断一次删除会不会阻塞,固定顺序 OBJECT ENCODING → HLEN/MEMORY USAGE →(可选)DEBUG OBJECT,前两步能覆盖 95% 的误判。

DEBUG OBJECT 能给出 serializedlength、ql_nodes,但它在 8.x 默认禁用 (enable-debug-command 实测 no)且不可热改,只能改配置重启。所以线上排查别把它写进标准动作:

bash 复制代码
# 默认配置下直接调用会被拒
redis-cli -p 6379 DEBUG OBJECT big:hash
# 热改一定失败:这条用来确认「不可热改」这一点
redis-cli -p 6379 CONFIG SET enable-debug-command local
text 复制代码
ERR DEBUG command not allowed. If the enable-debug-command option is set to "local", you can run it from a local connection, otherwise you need to set this option in the configuration file, and then restart the server.

ERR CONFIG SET failed (possibly related to argument 'enable-debug-command') - can't set immutable config

三、命令、配置与五种删除方式

本节给全命令与开关口径,并给出「五种删除方式」的落点,避免在选型时反复翻文档。

语法(说明用,不是可执行命令):

text 复制代码
UNLINK key [key ...]
arity      -2          (至少 1 个参数,可继续追加,参数全是 Key)
since      4.0.0
flags      write, fast (fast 指不做复杂计算,与「释放是否异步」无关)
返回值     被删除的 Key 数量(integer)

FLUSHDB  [ASYNC | SYNC]
FLUSHALL [ASYNC | SYNC]
无修饰符   行为由 lazyfree-lazy-user-flush 决定(默认 no = 同步)
返回值     恒为 OK(不是被清空的键数量)

可执行形态:

bash 复制代码
# 单个 Key:返回 1 表示摘除成功
redis-cli -p 6379 UNLINK big:hash
# 多个 Key:返回实际存在的个数,不存在的 Key 不计入也不报错
redis-cli -p 6379 UNLINK big:hash big:zset no:such:key
# 全都不存在返回 0:清理脚本因此可以幂等重跑
redis-cli -p 6379 UNLINK nokey1 nokey2
# 返回如下:
1
2
0
bash 复制代码
# 异步清空:主线程只做一次字典替换,旧字典交给 BIO
redis-cli -p 6379 FLUSHDB ASYNC
# 立刻查键数:应为 0(键空间已空,但内存可能还没还回来)
redis-cli -p 6379 DBSIZE
# 显式同步清空:接受阻塞,换「命令返回即释放完成」
redis-cli -p 6379 FLUSHDB SYNC
# 清空全部 16 个 db;集群下要逐节点执行
redis-cli -p 6379 FLUSHALL ASYNC
# 返回如下
OK
0
OK
OK

要点三条:ASYNC 把旧字典整体交后台(4.0+),SYNC 显式要求同步(6.2+ 才支持显式指定);ASYNC 只删命令调用时刻已存在的 Key ,flush 期间新建的 Key 不受影响,这让「清空后立刻重建缓存」的编排要额外处理;返回值恒为 OK,DBSIZE 立刻归零但 used_memory 不立刻下降。

UNLINK 的名字来自「只断开键空间引用、不立刻释放」。它与 DEL 语义等价、返回值相同,但返回值相同不代表耗时相同;也不要把它理解成「延迟删除」------键立刻不可见、立刻不参与命中,异步的只是内存归还。

3.2 开关族:以 CONFIG GET 清单为准

历史资料常说「四个开关」,实际数量随版本变化,写稿与落地前先列全:

bash 复制代码
# 单引号必须保留:让 glob 由 Redis 展开,而不是被 shell 先当文件名通配展开
redis-cli -p 6379 CONFIG GET 'lazyfree-*'
# 改前留快照,回滚与复盘都靠它(> 是 shell 重定向,只能写在 shell 里)
redis-cli -p 6379 CONFIG GET 'lazyfree-*' > lazyfree-before.txt
text 复制代码
lazyfree-lazy-eviction
no
lazyfree-lazy-server-del
no
lazyfree-lazy-user-del
no
lazyfree-lazy-expire
no
lazyfree-lazy-user-flush
no

lazyfree-lazy-* 前缀下 5 项,加上独立命名的副本清空开关,共 6 项,默认全部 no:

bash 复制代码
# 副本清空开关不在 lazyfree 前缀下,漏查就会得出「只有 5 项」的错结论
redis-cli -p 6379 CONFIG GET 'replica-lazy-flush'
text 复制代码
replica-lazy-flush
no

六项全部支持 CONFIG SET 热改、无需重启;CONFIG REWRITE 能把热改结果持久化,但会一并写入当前会话里为测试改过的其他参数(例如 slowlog-log-slower-than),测完先恢复再 rewrite。

一句话落地口径 :先开命令级(UNLINK / FLUSHALL ASYNC)观察收益,能改代码就不要依赖 lazyfree-lazy-user-del。开关里优先 eviction、expire;server-del 看有没有大对象覆写;user-del 只在客户端改不动时兜底;user-flush 与 replica-lazy-flush 按清理与复制场景决定。每开一项都要同步修正内存监控的判读口径------这比「开哪几个」更重要。

3.3 五种删除方式对照

四、执行原理与亲手验证

本节把「一次删除到底发生了什么」按步骤拆开,并给出一套能在 10 万规模上跑完的验证流程。

UNLINK big:hash(hashtable)的 8 个步骤:

①主线程查 Key,不存在则跳过;

②从 db->dict 删 entry;

③清 expires 标记;

④估算 free_effort;

⑤a 未超阈值→主线程直接释放(O(N) 但 N 小),b 超阈值→构造 job 加锁入队、pending++;

⑥返回客户端;

⑦BIO 取 job 释放 value;

⑧pending--、lazyfreed_objects++、内存归还分配器。

DEL 没有 5b 步------它在第 6 步之前必须走完第 7 步的全部工作量,所以返回时 used_memory 已经降下来了。

4.1 四段法:脚本、结果、判读、不符怎么办

第一段,脚本:

bash 复制代码
# 打开延迟监控(毫秒):不开它 LATENCY HISTORY 永远返回空数组,这是复现失败的头号原因
redis-cli -p 6379 CONFIG SET latency-monitor-threshold 1
# 慢日志阈值清零(微秒):所有命令入日志,才可能看到 UNLINK 的几十微秒
redis-cli -p 6379 CONFIG SET slowlog-log-slower-than 0
# 重置命令统计:它同时把 lazyfreed_objects 清零,正是我们想要的干净基线
redis-cli -p 6379 CONFIG RESETSTAT
# 清空慢日志与延迟历史,去掉上一轮的残留
redis-cli -p 6379 SLOWLOG RESET
redis-cli -p 6379 LATENCY RESET

# 造 10 万字段 Hash:EVAL 循环 10 万次实测 654 毫秒,安全;百万级会撞 lua-time-limit
redis-cli -p 6379 EVAL "for i=1,100000 do redis.call('HSET',KEYS[1],'f'..i,'v') end return redis.call('HLEN',KEYS[1])" 1 test:sync
# 编码是第一手证据:10 万字段必然已是 hashtable
redis-cli -p 6379 OBJECT ENCODING test:sync
# 内存数字用来对照 used_memory 的回落幅度
redis-cli -p 6379 MEMORY USAGE test:sync
# 清空慢日志,保证下一条取到的就是 DEL 本身
redis-cli -p 6379 SLOWLOG RESET
# 同步删除,然后读主线程净耗时
redis-cli -p 6379 DEL test:sync
redis-cli -p 6379 SLOWLOG GET 1
# 延迟历史是本事件的时间序列(位置数组,无字段名)
redis-cli -p 6379 LATENCY HISTORY command
bash 复制代码
# 清空慢日志,避免下一条取到 DEL 的残留条目
redis-cli -p 6379 SLOWLOG RESET
# 重建同规模 Key:异步路径需要重新造一个 hashtable 编码的大 Key
redis-cli -p 6379 EVAL "for i=1,100000 do redis.call('HSET',KEYS[1],'f'..i,'v') end return redis.call('HLEN',KEYS[1])" 1 test:async
redis-cli -p 6379 OBJECT ENCODING test:async
# 异步删除:主线程只摘引用并入队
redis-cli -p 6379 UNLINK test:async
# 阈值 0 下 UNLINK 也会被记录,实测 27 微秒
redis-cli -p 6379 SLOWLOG GET 1
# 立刻采样:pending 与 used_memory 要一起看
redis-cli -p 6379 INFO memory | grep -E 'used_memory:|lazyfree_pending_objects|lazyfreed_objects'

第二段,预期结果(本机 8.10.3、libc 分配器,耗时取自 SLOWLOG 第 3 字段):

lazyfreed_objects 在 10 万规模的异步删后由 0 变 1,是「确实走了 BIO」的直接证据。不要把这些数字当跨环境基准 :换 Linux + jemalloc,free() 更快、绝对值明显下降,但「O(N) vs O(1)」的量级关系不变;DEL 随规模近似线性但非严格线性(10 万→100 万字段数涨 10 倍、耗时只涨 7.4 倍)。

第三段,判读四条:

①看命令是否进了 SLOWLOG,进即说明主线程确实被占;

②看 pending 的方向,由正回落到 0 正常、持续为正才是问题;

③看 used_memory 的曲线形状,台阶式瞬降是同步、阶梯式缓降是异步;

④看 lazyfreed_objects 的增量,注意它会被 CONFIG RESETSTAT 和重启清零,只能比较本轮前后差值。

第四段,结果不符怎么定位:UNLINK 后 pending 恒为 0 且 used_memory 立刻下降 → free_effort 未超阈值,先查编码 (listpack/intset 换更大 Key 也没用,得等它转成 hashtable/skiplist);DEL 延迟尖峰不明显 → 机器快或 Key 不够大,也复查 slowlog-log-slower-than 是否设得过高;UNLINK 与 DEL 曲线几乎一样 → 检查是否在 MULTI 或 Lua 脚本里删,脚本整体在主线程原子执行,入队收益不会体现在单条延迟上;pending 持续上涨不回落 → 删除速率超过 BIO 串行释放速率,见 8 节坑点 3。

4.2 用 SLOWLOG 与 INFO 判定「是否真的卡住」

bash 复制代码
# 最近 10 条:时间从新到旧,第 1 条是最近执行的命令
redis-cli -p 6379 SLOWLOG GET 10
# 当前日志条数(不超过 slowlog-max-len,实测已满 128)
redis-cli -p 6379 SLOWLOG LEN
# 阈值(微秒):10000 = 10 毫秒;0 记录全部,-1 关闭
redis-cli -p 6379 CONFIG SET slowlog-log-slower-than 10000
# 容量:只保留最近 N 条,调大只影响内存占用
redis-cli -p 6379 CONFIG SET slowlog-max-len 128
# 回读确认实验参数没被配置文件旧值覆盖
redis-cli -p 6379 CONFIG GET 'slowlog-*'

slowlog-* 在 8.10.3 共 4 项,多出的 slowlog-entry-max-string-len(默认 128)与 slowlog-entry-max-argc(默认 32)是单条日志的截断限制------排查「参数看不全」先查这两项。

单条慢日志是 6 个位置字段:

①日志 ID(单调递增,确认「是不是同一条」);

②执行时刻(Unix 秒,可与 LATENCY 时间戳对齐);

③主线程净耗时(微秒) ,判定的核心字段;

④命令名与参数;

⑤客户端地址(定位是哪个应用);

⑥客户端名,未 CLIENT SETNAME 时为空串------建议业务连接都设名字。

三种典型判定:命令是 DEL、耗时远大于阈值且没开 user-del → 确认主线程同步阻塞;已开 user-del 仍有高耗时 DEL → 该 Key 编码是 listpack/intset/String(free_effort 未超阈值),或这个多键 DEL 里夹着中等集合,用 OBJECT ENCODING + MEMORY USAGE 验证;命令是 UNLINK 却有毫秒级耗时 → 未触发异步,或主线程正被其他命令占住(对比同一时段的其他慢日志)。

误区 :别凭「SLOWLOG 没记录」断定没问题------阈值设大了,几十毫秒阻塞也不会被记。排查时临时调低阈值,并用 LATENCY HISTORY command 交叉验证同一时刻。

SLOWLOG 与 LATENCY 都有前置开关,下面两个指标则始终在线:

bash 复制代码
# 每命令调用次数、累计与平均耗时(微秒)
redis-cli -p 6379 INFO commandstats | grep -E 'cmdstat_del|cmdstat_unlink'
# 每命令延迟分位(微秒):p99 是否被删除拉高,一看就知道
redis-cli -p 6379 INFO latencystats | grep -E 'latency_percentiles_usec_(del|unlink)'
text 复制代码
cmdstat_unlink:calls=1,usec=27,usec_per_call=27.00,rejected_calls=0,failed_calls=0,slowlog_count=1,slowlog_time_ms_sum=0.03,slowlog_time_ms_max=0.03
cmdstat_del:calls=1,usec=70827,usec_per_call=70827.00,rejected_calls=0,failed_calls=0,slowlog_count=1,slowlog_time_ms_sum=70.83,slowlog_time_ms_max=70.83
latency_percentiles_usec_unlink:p50=27.007,p99=27.007,p99.9=27.007
latency_percentiles_usec_del:p50=71303.167,p99=71303.167,p99.9=71303.167

两条 8.x 细节:

①cmdstat_* 在 7.x 的 calls/usec/usec_per_call/rejected_calls/failed_calls 之外多了 slowlog_count、slowlog_time_ms_sum、slowlog_time_ms_max ,按固定字段顺序解析会错位,必须按 key=value 解析;

②latencystats 的分位值是带三位小数的微秒,且样本只有一个时 p50/p99/p99.9 完全相同,别当三个独立指标用。

五、生产落地:五个场景与 .NET 代码

本节把机制落到具体场景:每个场景给「需求 → 方案 → 边界与退化 → 失效条件」,再给一份已验证可运行的 .NET 10 代码。

bash 复制代码
# 开:淘汰后的释放交给 BIO(热改,立即生效)
redis-cli -p 6379 CONFIG SET lazyfree-lazy-eviction yes
# 回读确认:CONFIG SET 返回 OK 只代表写入成功
redis-cli -p 6379 CONFIG GET lazyfree-lazy-eviction
# 把「淘汰强度」与「释放积压」配对观测:-r 30 -i 1 = 重复 30 次、间隔 1 秒
redis-cli -p 6379 -r 30 -i 1 INFO stats | grep -E 'evicted_keys'
# 回滚:只撤这一项
redis-cli -p 6379 CONFIG SET lazyfree-lazy-eviction no
# 过期路径同理;user-del 影响面最大,放在最后开
redis-cli -p 6379 CONFIG SET lazyfree-lazy-expire yes
redis-cli -p 6379 CONFIG GET lazyfree-lazy-expire
# 从库清空改异步:要在执行清空动作的那台机器上开
redis-cli -h 10.0.0.12 -p 6379 CONFIG SET replica-lazy-flush yes

-i(--interval)必须与 -r(重复次数)同用:单独传 --interval 1 会被判为参数错误(实测报 Unrecognized option or bad number of args)。

异步 flush 后的编排要点 :命令返回代表键空间已空,内存由后台慢慢释放;重启不会带来正确性问题(进程退出后内存由 OS 统一回收),只是失去释放进度的观测。需要等 pending 回落的场景只有一个------清空后要按容量水位做下一步决策。

主从传播的两条语义必须分清 :主库执行 UNLINK,传播给从库的是 UNLINK,从库一律异步,与该从库的 lazyfree-* 开关无关;主库执行 DEL,传播的是 DEL,从库是否异步取决于从库自己的 lazyfree-lazy-user-del。所以「主从不一致配置」的影响面只出现在 DEL 路径。

5.1 五种情况下不该用这条机制

  • 内存水位紧、淘汰频繁 :异步释滞后可能让 used_memory 长时间高于水位、触发更多淘汰,贴近 cgroup 上限时甚至先撞 OOM。已在 OOM 边缘,先解决容量(S6)。
  • Key 普遍很小、编码紧凑 :free_effort 恒为 1,投递 BIO 的额外开销(构造 job、加锁、唤醒线程)可能比直接释放还大。
  • 依赖「删除返回即内存下降」的自动化流程 :运维脚本、自动扩缩容、业务侧容量判断都会失效。要么改用 pending 判断,要么保持同步删除。
  • 单实例 CPU 吃紧:BIO 释放同样占 CPU,核数紧张的小实例上整体延迟可能更差。
  • 需要精确掌握释放完成时点 :没有完成回调,只能靠 pending 回落到 0 间接判断,对「删完立刻下一步」的编排不友好。

5.2 .NET 10 落地代码(已实测可编译可运行)

三个关键点:

①KeyDeleteAsync 发出的是 DEL,要发原生 UNLINK 只能用 ExecuteAsync;

②ExecuteAsync(string, params object[]) 收到 RedisKey[] 不会自动按元素展开,必须显式转成 object[],否则服务端只收到一个打包参数;

③IServer.InfoAsync 属于 admin 命令,连接串必须带 allowAdmin=true,否则抛 RedisCommandException。

工程文件(与 Program.cs 同目录,dotnet run 直接可跑):

xml 复制代码
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <!-- 控制台程序:便于 dotnet run 直接验证,不必套测试框架 -->
    <OutputType>Exe</OutputType>
    <!-- 与本文基线一致:.NET 10 -->
    <TargetFramework>net10.0</TargetFramework>
    <!-- 省略常用 using(System / System.Linq 等),减少示例头部噪音 -->
    <ImplicitUsings>enable</ImplicitUsings>
    <!-- 开启可空引用检查:Action<string>? 这类标注才生效,否则报 CS8625 -->
    <Nullable>enable</Nullable>
  </PropertyGroup>
  <ItemGroup>
    <!-- 客户端库版本固定:不同小版本的 API 与过时标记不同,影响可复现性 -->
    <PackageReference Include="StackExchange.Redis" Version="3.4.35" />
  </ItemGroup>
</Project>

完整代码(注释均在对应代码行的上一行):

csharp 复制代码
// 连接复用与 INFO 读取的最小演示;包引用见上方的 PackageReference 片段
using System;
// KeyValuePair:INFO 的返回结构是「分组名 -> 键值对集合」
using System.Collections.Generic;
// Stopwatch:用于对比「墙钟耗时」与「SLOWLOG 记录的主线程净耗时」
using System.Diagnostics;
// First / SelectMany:在 INFO 的分组结果里定位目标字段
using System.Linq;
// Task / async-await:所有 Redis 调用走异步版本,避免阻塞线程池线程
using System.Threading.Tasks;
// 客户端库:ConnectionMultiplexer / IDatabase / IServer / RedisKey / RedisResult 都在这里
using StackExchange.Redis;

// 独立命名空间,避免示例类型与业务代码里的同名类型冲突
namespace RedisLazyFreeDemo
{
    // 封装「显式异步删除 + lazyfree 计数观测 + 异步清库」,实现 IDisposable 以便释放连接
    internal sealed class RedisLazyFreeHelper : IDisposable
    {
        // 连接多路复用器:进程内应复用一个实例,不要每条操作都新建连接
        private readonly IConnectionMultiplexer _multiplexer;

        // 数据面句柄:执行 UNLINK、FLUSHDB 这类普通命令
        private readonly IDatabase _db;

        // 管理面句柄:INFO 属于 admin 命令,必须走 IServer 而不是 IDatabase
        private readonly IServer _server;

        // 日志注入点:示例写 Console,生产环境换成结构化日志组件
        private readonly Action<string> _log;

        // 释放标记:保证 Dispose 不会被重复执行
        private bool _disposed;

        // 构造函数:建立连接并初始化数据面与管理面句柄
        // 连接串必须带 allowAdmin=true,否则读取 INFO 会抛 RedisCommandException
        public RedisLazyFreeHelper(string connectionString, Action<string>? log = null)
        {
            // 未注入日志时退化为空委托,避免每次写日志都判空
            _log = log ?? (_ => { });

            // 连接在此处同步建立;若带 abortConnect=false,连不上时不会在构造期抛出
            _multiplexer = ConnectionMultiplexer.Connect(connectionString);

            // 默认库;多库场景换成 GetDatabase(dbIndex)
            _db = _multiplexer.GetDatabase();

            // 取第一个端点即可:单实例场景足够;集群需按 Key 的 slot 选择节点
            _server = _multiplexer.GetServer(_multiplexer.GetEndPoints().First());
        }

        // 用原生 UNLINK 异步删除一个或多个 Key,返回已从键空间摘除的 Key 数量
        public async Task<long> UnlinkAsync(params RedisKey[] keys)
        {
            // 空参数直接返回 0,避免把空数组发给服务端触发参数错误
            if (keys == null || keys.Length == 0)
            {
                return 0;
            }

            // 必须显式展开为 object[]:RedisKey 是值类型,数组不能协变交给 params object[]
            object[] args = keys.Select(k => (object)k).ToArray();

            try
            {
                // 注意:这里不能用 KeyDeleteAsync(它固定发送 DEL),要发 UNLINK 只能走 ExecuteAsync
                RedisResult result = await _db.ExecuteAsync("UNLINK", args).ConfigureAwait(false);

                // 先判空再强转:错误响应或空结果直接强转会变 InvalidCastException
                if (result.IsNull)
                {
                    throw new InvalidOperationException("UNLINK 返回空结果,命令语义与预期不符。");
                }

                // UNLINK 的返回值与 DEL 一致:被删除的 Key 数量
                return (long)result;
            }
            catch (RedisTimeoutException ex)
            {
                // UNLINK 本身是 O(1),超时通常指向网络抖动或实例整体压力,而不是这个 Key 太大
                _log($"UNLINK 超时:{ex.Message}");
                throw;
            }
        }

        // 一次性读取 lazyfree 的两个计数,返回(待释放对象数, 累计已释放对象数)
        public async Task<(long Pending, long Freed)> GetLazyFreeStatsAsync()
        {
            // 只读 memory 段:8.x 起两个字段都在这里,7.x 及更早在 stats 段
            var groups = await _server.InfoAsync("memory").ConfigureAwait(false);

            // 展平成单个键值对列表,便于按字段名精确匹配
            List<KeyValuePair<string, string>> pairs = groups.SelectMany(g => g).ToList();

            // 字段缺失或解析失败都要显式失败,不能静默返回 0 掩盖「指标不存在」
            long pending = ParseCounter(pairs, "lazyfree_pending_objects");
            long freed = ParseCounter(pairs, "lazyfreed_objects");

            return (pending, freed);
        }

        // 解析 INFO 里的单个计数;字段缺失与格式变化分别抛出可区分的异常
        private static long ParseCounter(List<KeyValuePair<string, string>> pairs, string field)
        {
            // 用精确匹配而不是 Contains,避免 lazyfree_ 前缀的字段互相误命中
            KeyValuePair<string, string> entry =
                pairs.FirstOrDefault(kv => string.Equals(kv.Key, field, StringComparison.Ordinal));

            // 字段不存在:多半是 INFO 分段随版本变化,需要回查采集口径
            if (entry.Key == null || entry.Value == null)
            {
                throw new InvalidOperationException($"INFO memory 中缺少 {field} 字段,请确认 INFO 分段是否随版本变化。");
            }

            // 字段存在但解析失败:多半是版本升级后值格式变化,需要同步更新采集脚本
            if (!long.TryParse(entry.Value, out long value))
            {
                throw new FormatException($"{field} 解析失败:{entry.Value}");
            }

            return value;
        }

        // 以 ASYNC 方式清空当前数据库,避免主线程同步释放造成的长时间阻塞
        public async Task FlushDbAsync()
        {
            // "ASYNC" 是修饰符而不是 Key:服务端会把它解析为 flush 模式
            RedisResult result = await _db.ExecuteAsync("FLUSHDB", "ASYNC").ConfigureAwait(false);

            // FLUSHDB 的返回值是状态串 OK,不是被清空的键数量,因此必须校验而不是当计数用
            if (result.IsNull || !string.Equals(result.ToString(), "OK", StringComparison.OrdinalIgnoreCase))
            {
                throw new InvalidOperationException($"FLUSHDB ASYNC 返回异常:{result}");
            }
        }

        // 释放底层连接资源
        public void Dispose()
        {
            // 幂等:重复 Dispose 直接返回
            if (_disposed)
            {
                return;
            }

            // 关闭多路复用器:内部会断开所有连接并停止后台任务
            _multiplexer.Dispose();

            // 置位标记,防止二次释放
            _disposed = true;
        }
    }

    // 程序入口:演示异步删除、积压观测与异步清库
    internal static class Program
    {
        private static async Task Main(string[] args)
        {
            // 读 INFO 需 admin 权限;abortConnect=false 让「实例暂时不可达」变成异常而不是构造期崩溃
            // connectTimeout/syncTimeout 显式配置,避免默认值在生产里掩盖问题
            string connectionString = args.Length > 0
                ? args[0]
                : "127.0.0.1:6379,allowAdmin=true,abortConnect=false,connectTimeout=2000,syncTimeout=5000";

            // using 保证异常路径也会 Dispose,连接不会泄漏
            using var helper = new RedisLazyFreeHelper(connectionString, message => Console.WriteLine(message));

            try
            {
                // 墙钟耗时含客户端与服务端往返,用来对照 SLOWLOG 里的「主线程净耗时」
                Stopwatch watch = Stopwatch.StartNew();

                // 目标 Key 需事先存在(见下方验证步骤),UNLINK 只统计真正被摘除的 Key
                long removed = await helper.UnlinkAsync("big:hash", "big:zset").ConfigureAwait(false);

                watch.Stop();

                Console.WriteLine($"已摘除 Key 数量:{removed}");
                Console.WriteLine($"客户端墙钟耗时:{watch.ElapsedMilliseconds} ms");

                // pending 为 0 表示后台已释放完;非 0 才是积压
                (long pending, long freed) = await helper.GetLazyFreeStatsAsync().ConfigureAwait(false);

                Console.WriteLine($"BIO 待释放对象数:{pending}");
                Console.WriteLine($"累计已释放对象数:{freed}");

                // 异步清库:返回 OK 即代表键空间已空,内存仍由后台慢慢释放
                await helper.FlushDbAsync().ConfigureAwait(false);

                Console.WriteLine("FLUSHDB ASYNC 已提交");
            }
            catch (RedisConnectionException ex)
            {
                // 连接类异常可退避重试;这里只记录,重试策略交给调用方
                Console.WriteLine($"连接异常,可退避重试:{ex.Message}");
            }
            catch (RedisServerException ex)
            {
                // 服务端拒绝执行(ACL 无权限、命令参数错误等),重试通常无效
                Console.WriteLine($"服务端异常:{ex.Message}");
            }
            catch (InvalidOperationException ex)
            {
                // 指标缺失或返回语义异常:属于观测口径问题,应告警而不是静默降级
                Console.WriteLine($"语义异常:{ex.Message}");
            }
            catch (FormatException ex)
            {
                // 指标格式变化通常意味着版本升级,需同步更新采集脚本
                Console.WriteLine($"指标解析失败:{ex.Message}");
            }
        }
    }
}

验证(可执行的断言,不是「跑一下看有没有异常」):

bash 复制代码
# 准备两个真实存在的 Key:Key 不存在时返回 0 会让断言失效
redis-cli -p 6379 SET big:hash v
redis-cli -p 6379 SET big:zset v
# 清零计数器,让「累计已释放对象数」的输出可预期(否则它是历史累计值)
redis-cli -p 6379 CONFIG RESETSTAT
# -- 之后的第一个参数是连接串,会覆盖程序里的默认值
dotnet run --project . -- "127.0.0.1:6379,allowAdmin=true,abortConnect=false,connectTimeout=2000,syncTimeout=5000"
text 复制代码
已摘除 Key 数量:2
客户端墙钟耗时:15 ms
BIO 待释放对象数:0
累计已释放对象数:0
FLUSHDB ASYNC 已提交

四条断言与典型失败的定位:

①已摘除 Key 数量 必须是 2,返回 1 说明 RedisKey[] 被当成单个参数打包,检查 args 是否显式展开;返回 0 先 EXISTS big:hash big:zset。

②抛「INFO memory 中缺少 lazyfree_pending_objects」说明 INFO 分段与版本不匹配,回查 3.2。

③累计已释放对象数 在 CONFIG RESETSTAT 后应为 0,删大 Hash 后会在释放完成时变成 1 以上,这正是走了 BIO 的证据。

④抛 This operation is not available unless admin mode is enabled: INFO 说明连接串少了 allowAdmin=true。

决策落点 :新项目在代码里显式用 UNLINK(局部、可控、语义清晰);存量项目改不动代码时,再用 lazyfree-lazy-user-del yes 在服务端兜底。两者可并存。

六、性能、观测与告警

本节回答「代价有多大、用什么指标看、阈值怎么定」。

一致性无差别:Key 摘除后对后续命令就不可见,BIO 释放的是已无人引用的内存。总 CPU 工作量不变,只是发生时机与所在线程转移了------Lazy Free 不减少释放本身的计算量。

6.1 对业务的三层影响

收益 :主线程 P99 显著降低。100 万字段 Hash 同步删占主线程 525,622 µs,必然进 SLOWLOG;异步删后只承担微秒级摘除与入队,尖刺转成后台持续 CPU 占用。

风险一:used_memory 不立刻下降导致误判。 业务在删后立即查内存(「删了 2 GB 怎么没降,是不是没删掉」)会误判;按水位驱动的自动扩缩容会被这层延迟误导、反复横跳。

风险二:淘汰路径的滞后有两种后果,判据不同。 过度淘汰:performEvictions 以 used_memory 是否超额为驱动,异步释放让计数不立即下降,同一轮可能连续淘汰多个 Key,实际删掉的量超过需要腾出的量------表现是 evicted_keys 一次跳变量远超预期,同时 pending 升高。水位穿顶:used_memory/maxmemory 短时超过 1,多数情况淘汰循环会继续删到达标,但写入速率高于释放速率时确实可见短暂穿顶。8.x 是否引入了基于预估释放量的收敛逻辑------待用 INFO 时序 + 源码验证 ,本文不写成定论;实践上把「evicted_keys 增速 / 写入量」当作独立监控项观察一周。

风险三:内存归还到哪一步取决于分配器。 BIO 释放把内存交还分配器,used_memory 随之下降;是否把空闲页交还操作系统则取决于分配器:

本机就是 libc(INFO memory 里 mem_allocator:libc),所以文中只给计数变化、不引用碎片率结论。

退化路径 :pending 持续高位说明 BIO 成了瓶颈------它串行消费,大量并发删大 Key 时释放速度有上限。主线程虽不阻塞,但内存回收变慢,可能影响后续写入,极端情况先撞内存上限。

决策落点:收益与风险同源,都来自「释放被挪到后台」。引入前的判断不是「要不要开」,而是「内存水位有没有余量、监控口径改没改、分配器是哪一个」;三者任一不满足,收益都会被风险抵消。

6.2 三套观测手段的分工

取舍:面板用第三套,事故定调用第一套,实验对比用第二套。前两套有前置开关,忘开就会出现「明明卡了却没有任何记录」的假阴性------这是复现失败最常见的原因。

bash 复制代码
# 积压与累计释放:两个字段都在 INFO memory 段
redis-cli -p 6379 INFO memory | grep -E 'lazyfree_pending_objects|lazyfreed_objects'
# 内存与碎片:libc 下 mem_fragmentation_ratio 不可信,只作参考别进告警
redis-cli -p 6379 INFO memory | grep -E 'used_memory_human|used_memory_rss|mem_fragmentation_ratio'
# 命令级耗时与分位,始终在线
redis-cli -p 6379 INFO commandstats | grep -E 'cmdstat_del|cmdstat_unlink'
redis-cli -p 6379 INFO latencystats | grep -E 'latency_percentiles_usec_(del|unlink)'
# 独立客户端延迟探针:持续采样,Ctrl+C 结束;重定向到非 TTY 时只采 1 秒
redis-cli -p 6379 --latency
# 分时段看变化(默认 15 秒一段,-i 可改),适合抓「删大 Key 的时间窗」
redis-cli -p 6379 --latency-history -i 5
text 复制代码
min: 0, max: 1, avg: 0.21 (1024 samples)

--latency 只采往返延迟、不含命令执行时间:它证明「网络没问题」,不能证明「主线程没被删除卡住」。组合判据是--------latency 正常而 latencystats 的 del p99 高,问题就在服务端执行侧。

挖尖刺 :把 slowlog-log-slower-than 调到 0 记全量命令,配合 SLOWLOG GET 看删除命令;再开 latency-monitor-threshold 用 LATENCY HISTORY 取尖峰时刻。注意 CONFIG REWRITE 会把这些测试值写进配置文件,测完先恢复。

压测方法 :造 10 万/50 万/100 万字段三档 Hash,分别用 DEL 与 UNLINK,记录 SLOWLOG 耗时字段(比墙钟准,不含客户端启动与网络开销);每组重复 10 次取中位数,并记录版本、分配器、CPU 核数、数据集规模,否则数字无法复现。

6.3 告警指标与阈值

阈值怎么定 (抄方法别抄数字):pending 阈值 = BIO 每秒能释放的对象数 × 可接受滞留秒数。校准办法:删掉 N 个已知大小的大 Key,记录 pending 从 N 回落到 0 的秒数,得到 objects/sec。本机一个 38 MB Hash 约 0.5 秒释放完,即 2 objects/sec 量级(jemalloc 环境更高,必须在目标实例重校)。

七、版本迁移与集群边界

本节只留「升级时要做什么」与「集群/复制下的额外边界」。

迁移坑一:参数改名比传闻温和。 实测 8.10.3 仍把旧名当别名:CONFIG GET slave-lazy-flush 有返回值,CONFIG SET slave-lazy-flush yes 返回 OK 且 CONFIG GET replica-lazy-flush 立刻变 yes。所以「旧配置搬到新版本起不来」在当前版本不成立(是否保留别名随发行版而异,按下面命令确认一次)。真正的坑是 CONFIG REWRITE 会以规范名写回,旧名被「悄悄改名」,变更审计容易误判;以及按旧名采集的监控项在规范化输出里变成新名、面板出现空值。

bash 复制代码
# 规范名:能读到值即说明这一项存在且可读
redis-cli -p 6379 CONFIG GET replica-lazy-flush
# 旧名(别名):实测仍可读,说明旧配置文件不会因这个名字直接失效
redis-cli -p 6379 CONFIG GET slave-lazy-flush
# 写旧名再读规范名:两个视图同步变化,证明别名指向同一项配置
redis-cli -p 6379 CONFIG SET slave-lazy-flush yes
redis-cli -p 6379 CONFIG GET replica-lazy-flush
# 复原:别把测试值留在实例上
redis-cli -p 6379 CONFIG SET replica-lazy-flush no

本机依次得到 no、no、OK、yes、OK。若旧名那一步返回空数组,说明该发行版已彻底移除别名,才需要走「改名 → CONFIG GET 确认 → CONFIG REWRITE」的升级流程。

迁移坑二:INFO 分段迁移是最实际的一条。 两个计数在 8.10.3 属于 INFO memory,任何写死 INFO stats 的脚本会静默返回空值------最危险的不是报错,而是「看起来正常但没有数据」。

bash 复制代码
# 新位置:8.10.3 的两个计数在 memory 段,这是唯一正确的取数口径
redis-cli -p 6379 INFO memory | grep -E 'lazyfree_pending_objects|lazyfreed_objects'
# 旧位置:stats 段已无此字段;grep 未命中返回 1,用 || 触发兜底提示而不是静默成功
redis-cli -p 6379 INFO stats | grep -E 'lazyfree_pending_objects|lazyfreed_objects' || echo "stats 段无此字段,说明 INFO 分段已迁移"
# 兜底:两段都查一遍再判定「字段缺失」,避免把「暂时为 0」误判成「字段不存在」
redis-cli -p 6379 INFO | grep -E 'lazyfree_pending_objects|lazyfreed_objects' | head -n 2
text 复制代码
lazyfree_pending_objects:0
lazyfreed_objects:1
stats 段无此字段,说明 INFO 分段已迁移
lazyfree_pending_objects:0
lazyfreed_objects:1

INFO 不带参数时,实测 14 个段标题为 Server/Clients/Memory/Persistence/Threads/Stats/Replication/CPU/Hotkeys/Modules/Errorstats/Cluster/Keyspace/Keysizes------存成基线文件,升级后 diff 一次即可发现分段变化。另注意 lazyfreed_objects 不是永久累计 ,CONFIG RESETSTAT 与进程重启都会清零。

迁移坑三:客户端的 admin 与 API 边界。

①读 INFO 走 IServer.InfoAsync,需要 allowAdmin=true(生产更推荐用 ACL 给一个只有 +info 权限的账号);

②KeyDeleteAsync 发 DEL,发 UNLINK 只能用 ExecuteAsync 且参数显式展开为 object[];

③ExecuteAsync 返回 RedisResult,取值前必须判空。

集群与复制的额外边界 :UNLINK 支持多 Key,但集群下多 Key 必须落在同一 slot,否则返回 CROSSSLOT,跨 slot 批量清理用 {hash-tag} 归槽或按槽分批(协议语义,本机 CLUSTER INFO 为 cluster support disabled,未在实测环境验证);FLUSHALL ASYNC 只影响当前节点,集群要逐节点执行;异步删除传播给从库与 AOF 的是 UNLINK,下游按收到的命令语义执行,不会把同步成本转嫁给下游;AOF fsync 是另一条 BIO 链路,磁盘排队与 lazyfree 队列互不影响,别用 pending 的变化解释 AOF 延迟(加载时的删除行为见 S5)。

八、结论、争议裁决与坑点索引

8.1 六条结论

  1. Lazy Free 拆分「摘除」与「释放」:主线程做 O(1) 摘除,BIO 做 O(N) 释放。保证主线程不阻塞,不保证内存立刻下降,也不减少总工作量。
  2. UNLINK 是显式异步,DEL 默认同步 :lazyfree-lazy-user-del yes 能让 DEL 获得异步语义而不改客户端代码,是存量项目最实用的兜底;命令级优先,开关级兜底。
  3. 开关族六项,实测默认全 no :lazyfree-lazy-* 五项 + replica-lazy-flush。开哪几项取决于路径判据,不是「全开更安全」;user-del 影响面最大,放最后。
  4. lazyfree_pending_objects 是核心观测指标,且位于 INFO memory :持续上涨不回落说明 BIO 跟不上,此时 used_memory 高位是「假性滞留」而非泄漏;判据是 pending 走向,不是瞬时内存值。
  5. 编码决定是否异步,规模决定收益大小 :listpack/intset/String 的 free_effort 恒为 1,永远同步;hashtable/skiplist 元素数 > 64 即异步,quicklist 按节点数计。「小 Key 无收益」的准确说法是「紧凑编码的 Key 无收益」。
  6. 异步把尖刺换成延迟与后台占用:内存水位紧张时不划算;开关只治阻塞,不治容量。

8.2 四条历史争议的裁决

另外三条误解正文已就地纠正:UNLINK 是「延迟删除」(错,键立刻不可见);UNLINK 一定不阻塞(错,小对象仍在主线程释放);MEMORY USAGE 返回 nil 说明删除没完成(错,键与内存是两件事)。

8.3 结论可被推翻的条件

出现以下变化时,「紧凑编码无收益」「用 pending 判断释放进度」「异步释放不阻塞主线程」需要相应修正:LAZYFREE_THRESHOLD 的判定方式改变(例如对紧凑编码也投递 BIO);BIO_LAZY_FREE 由单线程改为多线程或线程数可配,使 pending 不再反映真实瓶颈;释放改为可并行、可被主线程抢占;引入释放完成通知或回调替代轮询;INFO 再次调整分段或字段名(8.x 已发生过一次,采集需具备兼容取值能力)。

8.4 高频坑点索引

九、下一篇预告

第 5 篇:Redis 事务为什么不支持回滚:MULTI/EXEC/WATCH 的原子性边界与乐观锁正确写法

会讲清 MULTI 入队与 EXEC 执行两阶段的错误分类、Redis 为什么选择不回滚、WATCH 的 CAS 语义与「乐观锁标记」的本质(它不是锁)、与数据库事务在 ACID 上的逐条差异,以及什么场景该改用脚本。与本篇的分界:本篇讲删除动作的线程归属与执行成本,下一篇讲多条命令的连续执行边界------两者都涉及「主线程做了什么、没做什么」,但对象不同。

相关推荐
旋风菠萝16 小时前
HashMap和CurrentHashMap的key可以为空吗
java·数据库·redis
IT规划师1 天前
Redis 核心机制 | 内存淘汰策略全解:8种策略、近似LRU采样、LFU计数器
redis·.net
CappuccinoRose2 天前
Redis 学习文档
redis·后端·学习·缓存·session·非关系型数据库·gossip
我不会起名字3222 天前
WebSocket 停机与在线状态:Shutdown 返回后还需要清理什么
redis·后端·websocket·go·即时通讯·im·故障排查
时间的拾荒人2 天前
Redis 典型应用:缓存与分布式锁原理
redis·分布式·缓存·面试·架构