From 7950eaa37bf302bada808ed5af1c3a714e47d8d4 Mon Sep 17 00:00:00 2001 From: CyC2018 Date: Sat, 7 Nov 2026 17:10:29 +0800 Subject: [PATCH] =?UTF-8?q?Update=20=E7=BC=93=E5=AD=98.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 多级缓存、穿透、击穿、一致性和 LRU 等小节的补充,附录 A6 更新,新增附录 A10 Caffeine 的刷新与过期。 --- notes/缓存.md | 99 ++++++++++++++++++++++++++++++++++++++++----------- 1 file changed, 78 insertions(+), 21 deletions(-) diff --git a/notes/缓存.md b/notes/缓存.md index 4c1a1617..19259eca 100644 --- a/notes/缓存.md +++ b/notes/缓存.md @@ -45,7 +45,7 @@ ### ISP -网络服务提供商(ISP)是网络访问的第一跳,通过将数据缓存在 ISP 中能够大大提高用户的访问速度。 +用户通过网络服务提供商(ISP)接入互联网。把缓存部署在 ISP 的网络内,命中的请求在这个网络内就能得到响应,例如 Netflix 向合作的 ISP 提供缓存设备。 ### 反向代理 @@ -53,7 +53,7 @@ ### 本地缓存 -使用 Caffeine、Guava Cache 等把数据缓存在应用进程的内存中,读取时不经过网络,速度非常快。 +使用 Caffeine、Guava Cache 等把数据缓存在应用进程的内存中,读取时不经过网络,速度非常快。Guava 的文档建议改用 Caffeine,两者的接口相近,Caffeine 性能更好、功能更多。 ### 分布式缓存 @@ -70,7 +70,7 @@ Caffeine 读取一次约 21 纳秒;用单个连接逐条向 Redis 发送 GET 难点在于数据更新后怎样让所有实例的本地缓存失效: - 更新数据库后删除 Redis 中的键,再通过 Redis 的发布订阅或消息队列广播一条删除消息,各实例收到后删除自己的本地缓存。顺序不能反过来,否则本地缓存删除后、Redis 删除前的读请求会把 Redis 中的旧值重新加载到本地; -- Redis 的发布订阅不保证送达,实例断线期间的消息会丢失,所以本地缓存还要设置较短的过期时间(例如 30 秒)兜底,需要更可靠时改用消息队列。检测到订阅连接断开时清空本地缓存,并在订阅恢复前暂停使用和回填本地缓存;本地缓存从 Redis 回填时,过期时间取本地 TTL 与 Redis 中剩余 TTL 的较小值,避免本地副本比 Redis 中的值更晚过期; +- Redis 的发布订阅不保证送达,实例断线期间的消息会丢失,所以本地缓存还要设置较短的过期时间(例如 30 秒)兜底,需要更可靠时改用消息队列。检测到订阅连接断开时清空本地缓存,并在订阅恢复前暂停使用和回填本地缓存;本地缓存从 Redis 回填时,过期时间取本地缓存配置的有效时长与 Redis 中键的剩余生存时间(Time To Live, TTL)的较小值,避免本地副本比 Redis 中的值更晚过期; - 因此本地缓存只适合读多写少、能接受短暂不一致的数据,例如商品详情、配置;库存、余额这类数据不要放在本地缓存中。 本地缓存不直接用 HashMap 或 ConcurrentHashMap,是因为它们没有容量上限和过期时间,JVM 内存会一直上涨。常用的是 Caffeine: @@ -86,13 +86,13 @@ Product p = cache.get("product:1024", key -> loadFromRedisOrDb(key)); Caffeine 的淘汰算法 W-TinyLFU 同时考虑访问频率和最近访问时间:新数据先进入一个小的 LRU 窗口区,被窗口淘汰时再和主区将被淘汰的数据比较历史访问频率,频率高的留下,偶发的批量访问挤不掉热点数据,命中率通常高于 LRU。get 传入的加载函数对同一个键只会执行一次,其它并发的请求等待它的结果,避免缓存未命中时大量请求同时查询下游。加载函数抛出异常或返回 null 时不写入缓存,仍未命中的请求会再次执行它。通过 Spring 的 @Cacheable 使用时,默认不合并并发的未命中,要设置 sync = true 才走这个加载函数。 -过期和刷新是两回事:expireAfterWrite 到期后,下一次读取要同步回源,请求会等待;refreshAfterWrite 要在构建时提供加载函数(build(loader) 得到 LoadingCache),到期后的第一次读取触发后台重新加载,刷新还没完成时返回旧值,同一个键在刷新期间不会重复发起刷新。两者常一起用,例如 1 分钟刷新、5 分钟过期,热点键一直由后台刷新,长时间没人访问的键最终过期,不会一直返回很旧的值(Caffeine 3.3 实测)。 +过期和刷新是两回事:expireAfterWrite 到期后,下一次读取要同步回源,请求会等待;refreshAfterWrite 要在构建时提供加载函数(build(loader) 得到 LoadingCache),到期后的第一次读取触发后台重新加载,刷新还没完成时返回旧值,同一个键在刷新期间不会重复发起刷新。两者常一起用,例如 1 分钟刷新、5 分钟过期,热点键一直由后台刷新,长时间没人访问的键最终过期,不会一直返回很旧的值(Caffeine 3.3 实测,见[附录 A10](#a10-caffeine-的刷新与过期))。 maximumSize 限制的是条目数。值的大小相差很大时,例如商品详情从 0.1 KB 到 2 KB,同样 1 万个条目,值本身的大小就相差 20 倍。要按内存限制时改用 maximumWeight 加 weigher,由 weigher 返回每个条目估算的字节数。需要注意的是,权重只在写入或更新时计算一次,只用来判断是否超出上限,不影响淘汰哪一个条目,两种上限也不能同时设置。 ### 数据库缓存 -MySQL 等数据库管理系统具有自己的缓存机制来提高查询效率,例如 InnoDB 的 Buffer Pool 将数据页和索引页缓存在内存中。MySQL 的查询缓存因为命中率低、维护开销大,已经在 8.0 版本中被移除。 +MySQL 等数据库管理系统具有自己的缓存机制来提高查询效率,例如 InnoDB 的 Buffer Pool 将数据页和索引页缓存在内存中。MySQL 的查询缓存要求 SQL 逐字节相同,表中数据有任何修改都会使这张表的全部缓存结果失效,在多核高并发下还容易成为瓶颈,已经在 8.0 版本中被移除。 ### Java 内部的缓存 @@ -139,15 +139,15 @@ CDN 主要有以下优点:

-误判是因为这些位置可能都被其它 Key 置为 1。插入 n 个 Key、位数组为 m 位、使用 k 个哈希函数时,误判率约为 (1 - e-kn/m)k,k 取 (m/n) ln 2 时最小。每个 Key 占 10 位、k = 7 时,100 万个 Key 只需要 1.2 MB,按公式误判率为 0.82%;实际插入 100 万个 Key,再查询 100 万个不存在的 Key,误判率也是 0.82%(见[附录 A6](#a6-布隆过滤器的误判率))。目标误判率为 1% 时,每个 Key 约需要 9.6 位,1 亿个 Key 约 114 MB。 +误判是因为这些位置可能都被其它 Key 置为 1。插入 n 个 Key、位数组为 m 位、使用 k 个哈希函数时,误判率约为 (1 - e-kn/m)k,k 取 (m/n) ln 2 时最小。降低误判率要增加每个 Key 占的位数,再按位数选 k;位数不变时增加哈希函数会让更多的位变为 1,超过最优值后误判率反而上升,例如每个 Key 10 位时,k 为 3、7、14 的误判率分别约为 1.7%、0.82%、1.9%。每个 Key 占 10 位、k = 7 时,100 万个 Key 只需要 1.2 MB,按公式误判率为 0.82%;实际插入 100 万个 Key,再查询 100 万个不存在的 Key,误判率也是 0.82%(见[附录 A6](#a6-布隆过滤器的误判率))。目标误判率为 1% 时,每个 Key 约需要 9.6 位,1 亿个 Key 约 120 MB。 使用时需要注意: -- 容量要预估准确:插入的 Key 超过预期后误判率迅速上升,例如按 100 万个 Key 配置的过滤器插入了 200 万个 Key,按公式误判率会升到约 14%。这是位数组大小固定(例如用 SETBIT 自己实现)的情况;Redis 的 BF.RESERVE 默认在容量用满后自动追加一层容量翻倍的子过滤器,并收紧各层的误判率,使总的误判率仍不超过设定值,代价是更多的内存和更慢的查询,加 NONSCALING 则用满后直接报错; +- 容量要预估准确:插入的 Key 超过预期后误判率迅速上升,例如按 100 万个 Key 配置的过滤器插入了 200 万个 Key,按公式误判率会升到约 14%。这是位数组大小固定(例如用 SETBIT 自己实现)的情况;Redis 的 BF.RESERVE(用法见下文)默认在容量用满后自动追加一层容量翻倍的子过滤器,并收紧各层的误判率,使总的误判率仍不超过设定值,代价是更多的内存和更慢的查询,加 NONSCALING 则用满后直接报错; - 不能删除:一个位可能同时属于多个 Key,清零会让其它 Key 被误判为不存在,需要删除时可以定期用数据库中的全部 Key 重建(重建期间新增的 Key 同时写入新旧过滤器,建完再切换),或者使用计数布隆过滤器(每一位换成计数器,删除时减 1)、布谷鸟过滤器,它们也只能删除确实插入过、尚未删除的 Key; - 新增的数据要同时写入布隆过滤器,否则请求会被误判为不存在而拒绝。先写过滤器再写数据库:数据库写入失败只是多一个误判,反过来过滤器写入失败,这条数据会一直被拒绝。 -Redis 8 起内置了布隆过滤器(BF.RESERVE、BF.ADD、BF.EXISTS),Redis 7 需要加载 RedisBloom 模块。用 BF.RESERVE key 误判率 容量 预先创建,例如 BF.RESERVE product:bf 0.01 100000000;不先创建就执行 BF.ADD 时,会按默认的容量 100、误判率 1% 自动创建一个,之后频繁扩展。 +Redis 8 起官方发行版内置了布隆过滤器(BF.RESERVE、BF.ADD、BF.EXISTS),从源码编译时要加上 BUILD_WITH_MODULES=yes,并在启动时用 redis-full.conf 或 loadmodule 加载模块;Redis 7 需要加载 RedisBloom 模块。用 BF.RESERVE key 误判率 容量 预先创建,例如 BF.RESERVE product:bf 0.01 100000000,可扩展的过滤器第一层按误判率的一半 0.5% 分配,约占 131 MiB,加 NONSCALING 后按 1% 分配,约占 114 MiB(见[附录 A6](#a6-布隆过滤器的误判率));不先创建就执行 BF.ADD 时,会按默认的容量 100、误判率 1% 自动创建一个,之后频繁扩展。 实际使用时通常把几种做法组合起来:先在接口层校验参数,格式不对或者超出已分配范围的 ID 直接拒绝;再用布隆过滤器拦截不存在的 Key;少量误判漏过的请求用空值缓存兜底;同一来源大量查询不存在的数据时进行限流。 @@ -158,13 +158,13 @@ Redis 8 起内置了布隆过滤器(BF.RESERVE、BF.ADD、BF.EXISTS),Redis 解决方案: - 互斥锁:缓存未命中时用 `SET lock:product:1024 <随机值> NX EX 3` 抢锁,抢到的请求先再查一次缓存(可能别人已经写回),仍然没有才查询数据库并写回缓存,最后释放锁(释放时要确认锁仍是自己的,见 [分布式锁](分布式.md#redis-的-set-nx-指令));没抢到的请求等待一小段时间(例如 10 毫秒)后重新读缓存,等待的总时长要有上限,超过后返回默认值或报错,否则持锁的请求崩溃时,其它请求要一直等到锁过期。锁的过期时间要长于重建缓存的耗时,否则锁会在重建期间过期,其它请求再次抢到锁并回源,例如锁 100 毫秒、重建 300 毫秒时,100 个并发请求回源 4 次(见[附录 A5](#a5-缓存击穿的三种做法));耗时难以估计时可以给锁续期,见[分布式锁](分布式.md#redis-的-set-nx-指令); -- 逻辑过期:键不设置过期时间,而是在值中保存一个过期时间。读到已经过期的值时,抢到锁的请求启动后台线程重建缓存,所有请求都直接返回旧值,不等待。这些键不会被 volatile 开头的淘汰策略淘汰,不再需要时要主动删除。 +- 逻辑过期:键不设置过期时间,而是在值中保存一个过期时间。读到已经过期的值时,抢到锁的请求启动后台线程重建缓存,所有请求都直接返回旧值,不等待。这些键不会被 volatile 开头的淘汰策略(只淘汰设置了过期时间的键,见[数据淘汰策略](Redis.md#七数据淘汰策略))淘汰,但 allkeys 开头的策略仍可能淘汰它们,读到键不存在时按互斥锁的做法重建;不再需要时要主动删除。

两者都只让一个请求查询数据库,区别在于等待重建还是返回旧值。热点键刚过期时 100 个请求同时到达,数据库查询耗时 50 毫秒:不加保护时查询了数据库 68~100 次;互斥锁只查询 1 次,请求耗时的中位数约 90~100 毫秒;逻辑过期也只查询 1 次,耗时中位数约 12 毫秒,但 100 个请求拿到的都是旧值(Redis 7.4、MySQL 8.0 实测,见[附录 A5](#a5-缓存击穿的三种做法))。要求数据准确时用互斥锁,能接受短暂的旧值、更看重响应时间时用逻辑过期。 -写请求按 Cache Aside 删除热点键后同样会击穿。用逻辑过期时,写请求不删除键,而是把值中的过期时间改为已过期,由后台重建。 +写请求按旁路缓存(Cache Aside,见[缓存一致性](#缓存一致性))模式删除热点键后同样会击穿。用逻辑过期时,写请求不删除键,而是把值中的过期时间改为已过期,由后台重建。 ### 缓存雪崩 @@ -182,7 +182,7 @@ Redis 8 起内置了布隆过滤器(BF.RESERVE、BF.ADD、BF.EXISTS),Redis ### 缓存一致性 -缓存一致性(也常称为双写一致性)要求数据更新之后缓存中不能长期保留旧数据。常用的是 Cache Aside 模式: +缓存一致性(也常称为双写一致性)要求数据更新之后缓存中不能长期保留旧数据。常用的是旁路缓存(Cache Aside)模式: - 读:先读缓存,未命中则读数据库,并将结果写入缓存; - 写:先更新数据库,再删除缓存。 @@ -207,7 +207,7 @@ Redis 8 起内置了布隆过滤器(BF.RESERVE、BF.ADD、BF.EXISTS),Redis 第二种情况要求缓存恰好失效,并且读请求从查询数据库到写回缓存的耗时比写请求更新数据库再删除缓存还长,因此概率很小。 -用 8 个读进程不停读取同一个键,写入 1000 次:先删缓存再更新数据库有 980 次留下了旧值,先更新数据库再删缓存为 0 次。让缓存在每次写入前过期、读请求写回缓存前随机停顿 0~5 毫秒之后,先更新数据库再删缓存也有 542 次留下了旧值,加上延迟双删后为 0 次(MySQL 8.0、Redis 7.4 实测,见[附录 A4](#a4-缓存一致性的三种写法))。 +用 8 个读进程不停读取同一个键,写入 1000 次:先删缓存再更新数据库有 980 次留下了旧值,先更新数据库再删缓存为 0 次。让缓存在每次写入前过期、读请求写回缓存前随机停顿 0~5 毫秒之后,先更新数据库再删缓存也有 542 次留下了旧值,加上延迟双删(做法见下文)后为 0 次(MySQL 8.0、Redis 7.4 实测,见[附录 A4](#a4-缓存一致性的三种写法))。 常用的补救措施: @@ -219,7 +219,7 @@ Redis 8 起内置了布隆过滤器(BF.RESERVE、BF.ADD、BF.EXISTS),Redis 延迟双删的第二次删除不能让写请求同步等待,通常交给线程池或者延迟消息执行。间隔要大于读请求从查询数据库到写回缓存的耗时,读请求走从库时还要加上主从复制的延迟:附录 A4 中读请求最多停顿 5 毫秒,间隔取 50 毫秒时没有留下旧值;间隔太短清不掉旧值,太长则旧值在缓存中停留更久。第二次删除也可能失败,同样要重试,最后靠过期时间兜底。 -常见的组合是先更新数据库再删除缓存,删除失败时重试,再用过期时间兜底。读主库时,延迟双删针对的情况概率很小,还会让热点键多一次未命中,对一致性要求较高时再加。 +常见的组合是先更新数据库再删除缓存,删除失败时重试,再用过期时间兜底。读主库时,延迟双删针对的情况概率很小,还会让热点键多一次未命中,对一致性要求较高时再加。用了本地缓存时,还要通知各实例删除自己的本地缓存,见[多级缓存](#多级缓存)。 读写分离时,主库提交并删除缓存后从库可能还没有这次更新,未命中的读请求会把从库中的旧值写回缓存。这种情况不需要读请求很慢,只要它在复制延迟期间读从库就会发生。可以在写入后的一小段时间内让这个键的读请求查主库,或者订阅从库的 binlog 删除缓存;延迟双删也可以,间隔要求见上文。上面的租约挡不住这种情况,因为读请求是在删除之后才拿到令牌的。 @@ -257,7 +257,7 @@ Redis 8 起内置了布隆过滤器(BF.RESERVE、BF.ADD、BF.EXISTS),Redis 热 Key 的问题是请求集中到同一个节点,集群中其它节点再多也无法分担。处理方法: -- 发现:redis-cli --hotkeys,它读取的是 LFU 的访问计数,要求淘汰策略为 LFU,见 [七、数据淘汰策略](Redis.md#七数据淘汰策略)。这个计数按概率对数增长,默认配置下连续访问 10 万次约为 148,100 万次就到上限 255(Redis 7.4 实测,每次结果略有波动);停止访问后每分钟减 1。它反映的是带衰减的累计热度,分不出两个都已饱和的键,也不能可靠地判断哪个键刚刚变热。实时发现要在客户端或者代理中按时间窗口计数,例如 2 秒内访问超过 10 次; +- 发现:redis-cli --hotkeys,它读取的是 LFU 的访问计数,要求淘汰策略为 LFU,见 [七、数据淘汰策略](Redis.md#七数据淘汰策略)。这个计数按概率对数增长,默认配置下连续访问 10 万次约为 146,100 万次就到上限 255(Redis 7.4 实测,见 [Redis 附录 A10](Redis.md#a10-lfu-计数器),每次结果略有波动);停止访问后每分钟减 1。它反映的是带衰减的累计热度,分不出两个都已饱和的键,也不能可靠地判断哪个键刚刚变热。实时发现要在客户端或者代理中按时间窗口计数,例如 2 秒内访问超过 10 次; - 本地缓存:在应用中缓存热 Key 的值,大部分请求不再访问 Redis,代价是数据会有短暂的不一致,见上文的 [本地缓存](#本地缓存)。热 Key 事先不知道时,可以由探测服务汇总各实例上报的访问次数,判定为热点后把键名推送给所有实例,实例只为名单中的键开启本地缓存,并按规则设置过期时间,例如京东开源的 hotkey; - 复制多份:把同一个值写到 product:1024#0 到 product:1024#9 这 10 个键中,读取时随机选一个。这些键分布在不同的槽上,请求就分散到了多个节点,代价是写入时要更新所有副本,只适合读多写少的数据; - 写热点:上面两种做法只分担读请求。库存可以拆成几份放在不同的键中分别扣减,见[秒杀系统](系统设计基础.md#六秒杀系统);点赞数这类计数可以先在应用内累加,每隔一秒用一次 INCRBY 写入,见[热门视频的计数](系统设计基础.md#1-热门视频的计数)。 @@ -291,7 +291,7 @@ Redis 8 起内置了布隆过滤器(BF.RESERVE、BF.ADD、BF.EXISTS),Redis 将哈希空间 [0, 2n-1] 看成一个哈希环,每个服务器节点都通过哈希配置到哈希环上。每个数据对象通过哈希函数得到哈希值之后,存放到哈希环中顺时针方向第一个大于等于该哈希值的节点上。 -一致性哈希在增加或者删除节点时只会影响到哈希环中相邻的节点,例如下图中在 B 和 C 之间新增节点 X,只需要将节点 C 上哈希值位于 B 和 X 之间的数据迁移到 X 上即可,对于节点 A、B、D 都没有影响。同样从 4 个节点增加到 5 个,理论上约 1/5 的键需要迁移,100 万个键实测为约 18%。 +一致性哈希在增加或者删除节点时只会影响到哈希环中相邻的节点,例如下图中在 B 和 C 之间新增节点 X,只需要将节点 C 上哈希值位于 B 和 X 之间的数据迁移到 X 上即可,对于节点 A、B、D 都没有影响。同样从 4 个节点增加到 5 个,理论上约 1/5 的键需要迁移,100 万个键实测为约 18%(见[附录 A3](#a3-哈希分布与一致性哈希))。

@@ -307,11 +307,12 @@ Redis Cluster 使用的不是一致性哈希,而是把 Key 映射到固定的 ## 七、LRU 🔥 -以下是基于双向链表和 HashMap 的 LRU 算法实现,对算法的解释如下: +用双向链表和 HashMap 可以实现 O(1) 的 LRU,思路如下: - 访问某个节点时,将其从原来的位置删除,并重新插入到链表头部。这样就能保证链表尾部存储的就是最近最久未使用的节点,当节点数量大于缓存最大空间时就淘汰链表尾部的节点; - 为了使删除操作时间复杂度为 O(1),就不能采用遍历的方式找到某个节点。HashMap 存储着 Key 到节点的映射,通过 Key 就能以 O(1) 的时间得到节点,然后再以 O(1) 的时间将其从双向链表中删除; -- 用双向链表是因为删除节点时要修改前一个节点的指针,单向链表只能从头遍历才能找到它;节点中还要保存 Key,淘汰尾部节点时才能用它删除 HashMap 中对应的项。 +- 用双向链表是因为删除节点时要修改前一个节点的指针,单向链表只能从头遍历才能找到它;节点中还要保存 Key,淘汰尾部节点时才能用它删除 HashMap 中对应的项; +- head 和 tail 是不存数据的哨兵节点,链表为空或只有一个节点时,插入和删除也不需要判断前后节点是否为 null。

@@ -462,11 +463,11 @@ public class LRU implements Iterable { } ``` -上面的实现不是线程安全的:get() 也会移动链表中的节点,多个线程同时访问会破坏链表,所以读操作也要加锁。简单的做法是 get() 和 put() 使用同一把锁,或者用 Collections.synchronizedMap() 包装上面的 LinkedHashMap。需要注意的是,不能用读写锁的读锁保护 get():8 个线程并发访问时没有抛出异常,但链表已被破坏,size() 为 1999,遍历只能走到 1 个节点(JDK 21 实测,见[附录 A9](#a9-lru-的并发访问))。 +上面的实现不是线程安全的:get() 也会移动链表中的节点,多个线程同时访问会破坏链表,所以读操作也要加锁。简单的做法是 get() 和 put() 使用同一把锁,或者用 Collections.synchronizedMap() 包装上面的 LinkedHashMap。需要注意的是,不能用[读写锁](Java%20并发.md#java-中的锁)的读锁保护 get(),读锁允许多个线程同时持有:容量为 1000 的缓存被 8 个线程并发访问时没有抛出异常,但链表已被破坏,size() 为 1999,遍历只能走到 1 个节点(数值可能随运行略有不同,JDK 21 实测,见[附录 A9](#a9-lru-的并发访问))。 -并发高时有两种做法:一是分段,按 Key 的哈希分到 16 个各自加锁的 LRU,代价是只在段内淘汰;二是用 Caffeine,它不在每次读取时调整顺序,而是把访问记录写入缓冲区,再批量调整,读操作不需要获取全局锁。 +并发高时有两种做法:一是分段,按 Key 的哈希分到 16 个各自加锁的 LRU,代价是只在段内淘汰;二是用 Caffeine,它不在每次读取时调整顺序,而是把访问记录写入缓冲区,再批量调整,读操作不需要等待全局锁:缓冲区满时只尝试获取锁,锁被占用就直接返回。 -LRU 只看最近一次访问,一次全表扫描读入的冷数据就会把热点挤出去。MySQL 的 Buffer Pool 因此把链表分为 young 和 old 两段:新读入的页先放在 old 段,距首次访问超过 innodb_old_blocks_time(默认 1000 ms)后再被访问才移到 young 段,全表扫描读入的页很快就被淘汰。Redis 则不维护链表,随机抽样近似 LRU,见 [七、数据淘汰策略](Redis.md#七数据淘汰策略)。 +LRU 只看最近一次访问,一次全表扫描读入的冷数据就会把热点挤出去。MySQL InnoDB 的 Buffer Pool(在内存中缓存数据页的区域)因此把链表分为 young 和 old 两段:新读入的页先放在 old 段,距首次访问超过 innodb_old_blocks_time(默认 1000 ms)后再被访问才移到 young 段,全表扫描对同一页的几次访问紧挨着发生,达不到这个间隔,读入的页一直留在 old 段,很快就被淘汰。Redis 则不维护链表,随机抽样近似 LRU,见 [七、数据淘汰策略](Redis.md#七数据淘汰策略)。 ## 附录:实测 @@ -656,6 +657,15 @@ n=1000000 m/n=20 k=14 位数组 2.38 MiB:实测误判率 0.0065%,公式 0.00 目标误判率 0.1%:每个 Key 14.38 位,k = 10.0,1 亿个 Key 约 171 MiB ``` +Redis 7.4.1 加载 RedisBloom 2.8 模块,按 1 亿个 Key、1% 创建,BF.INFO 返回的 Size(字节): + +```text +BF.RESERVE product:bf 0.01 100000000 Size 137847016 +BF.RESERVE product:bf2 0.01 100000000 NONSCALING Size 119813328 +``` + +可扩展的过滤器第一层按误判率的一半(0.5%)分配,每个 Key 11.0 位、8 个哈希函数;NONSCALING 按 1% 分配,每个 Key 9.6 位、7 个哈希函数,与上面按公式算出的 114 MiB 一致。 + ### A7 空值缓存的内存 向空的 Redis 写入 10 万个随机的商品 ID,值为空字符串,过期时间 60 秒: @@ -699,11 +709,58 @@ if (r.nextInt(10) == 0) { 互斥锁 : 线程结果=[ok] size()=1000 遍历链表得到=1000 遍历=ok ``` +### A10 Caffeine 的刷新与过期 + +JDK 21.0.13,Caffeine 3.3.1,Apple M1 Pro。ticker 换成可以手动推进的假时钟,executor 换成先把任务放进队列、再手动执行的实现,配置 1 分钟刷新、5 分钟过期: + +```java +import com.github.benmanes.caffeine.cache.*; +import java.time.Duration; +import java.util.*; +import java.util.concurrent.*; +import java.util.concurrent.atomic.*; + +/** 用假时钟控制时间,刷新任务放进队列、手动执行,观察 1 分钟刷新、5 分钟过期的行为。 */ +public class Refresh { + public static void main(String[] args) { + AtomicLong now = new AtomicLong(0); + Queue tasks = new ConcurrentLinkedQueue<>(); + AtomicInteger ver = new AtomicInteger(); + LoadingCache cache = Caffeine.newBuilder() + .ticker(now::get).executor(tasks::add) + .refreshAfterWrite(Duration.ofMinutes(1)) + .expireAfterWrite(Duration.ofMinutes(5)) + .build(k -> "v" + ver.incrementAndGet()); + System.out.println("t=0 get -> " + cache.get("k")); + now.set(Duration.ofSeconds(90).toNanos()); + System.out.println("t=90s get -> " + cache.get("k") + ",等待执行的任务数=" + tasks.size()); + System.out.println("t=90s 再 get -> " + cache.get("k") + ",加载函数累计执行=" + ver.get()); + Runnable r; + while ((r = tasks.poll()) != null) r.run(); + System.out.println("执行队列中的任务后 get -> " + cache.get("k") + ",加载函数累计执行=" + ver.get()); + now.addAndGet(Duration.ofMinutes(6).toNanos()); + System.out.println("再过 6 分钟 getIfPresent -> " + cache.getIfPresent("k")); + System.out.println("过期后 get -> " + cache.get("k")); + } +} +``` + +```text +t=0 get -> v1 +t=90s get -> v1,等待执行的任务数=2 +t=90s 再 get -> v1,加载函数累计执行=1 +执行队列中的任务后 get -> v2,加载函数累计执行=2 +再过 6 分钟 getIfPresent -> null +过期后 get -> v3 +``` + +90 秒时已经超过刷新时间,get 仍然返回旧值 v1,并把刷新交给 executor;队列中的任务执行之后才变为 v2,加载函数没有被重复调用。超过 5 分钟没有写入后条目过期,再 get 时同步加载出 v3。 + ## 参考资料 - 杨传辉. 大规模分布式存储系统:原理解析与架构实战 [M]. 机械工业出版社, 2013. - [Designing Data-Intensive Applications 中文版](https://github.com/vonng/ddia) -- [缓存那些事](https://tech.meituan.com/cache_about.html) +- [缓存那些事](https://tech.meituan.com/2017/03/17/cache-about.html) - [一致性哈希算法](https://my.oschina.net/jayhu/blog/732849) - [内容分发网络](https://zh.wikipedia.org/wiki/%E5%85%A7%E5%AE%B9%E5%82%B3%E9%81%9E%E7%B6%B2%E8%B7%AF) - [How Aspiration CDN helps to improve your website loading speed?](https://www.aspirationhosting.com/aspiration-cdn/)