From 3d46601de50b36136dc49d3881f77bc3a2067c7f 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=B3=BB=E7=BB=9F=E8=AE=BE=E8=AE=A1?= =?UTF-8?q?=E5=9F=BA=E7=A1=80.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 调整高频标记;限流、秒杀、Feed 流、容量估算、文件上传、权限、超时关单与支付等小节的补充与校对,附录同步更新。 --- notes/系统设计基础.md | 118 +++++++++++++++++++++++------------------- 1 file changed, 65 insertions(+), 53 deletions(-) diff --git a/notes/系统设计基础.md b/notes/系统设计基础.md index c326f242..8e5e31ae 100644 --- a/notes/系统设计基础.md +++ b/notes/系统设计基础.md @@ -9,10 +9,10 @@ * [六、秒杀系统](#六秒杀系统) 🔥🔥 * [七、海量数据处理](#七海量数据处理) * [八、短链系统](#八短链系统) - * [九、Feed 流](#九feed-流) 🔥 + * [九、Feed 流](#九feed-流) * [十、高并发系统的设计](#十高并发系统的设计) 🔥🔥 * [十一、大文件上传](#十一大文件上传) - * [十二、权限系统](#十二权限系统) + * [十二、权限系统](#十二权限系统) 🔥 * [十三、系统设计题的思路](#十三系统设计题的思路) * [十四、即时通讯](#十四即时通讯) * [十五、订单与支付](#十五订单与支付) @@ -43,7 +43,7 @@ 三者的关系为:并发数 = 吞吐量 × 响应时间,三者都取平均值,在系统处于稳定状态时成立,称为利特尔法则(Little's Law)。在没有并发存在的系统中,请求被顺序执行,此时响应时间为吞吐量的倒数。例如系统支持的吞吐量为 100 req/s,那么平均响应时间应该为 0.01 s。 -这里的并发数指同时在处理的请求数。按在线用户估算时,要加上用户两次操作之间的思考时间 Z:在线用户数 = 吞吐量 ×(响应时间 + Z)。例如 1 万个在线用户平均每 10 秒操作一次、响应时间 0.1 秒,吞吐量约为 990 次/秒,同时在处理的请求只有约 99 个。 +这里的并发数指同时在处理的请求数。按在线用户估算时,要加上用户两次操作之间的思考时间 Z:在线用户数 = 吞吐量 ×(响应时间 + Z)。例如 1 万个在线用户两次操作之间平均思考 10 秒、响应时间 0.1 秒,吞吐量约为 990 次/秒,同时在处理的请求只有约 99 个。 多线程能够提高吞吐量,主要有两个原因: @@ -125,7 +125,7 @@ I/O 多路复用用的是第二个原因:一个线程同时等待多个连接 ### 限流、降级与熔断 - 限流:请求量超过系统的处理能力时,拒绝多余的请求; -- 降级:主动关闭部分非核心功能,从而保证核心功能可用; +- 降级:资源不足或依赖故障时,关闭非核心功能或返回简化的结果,从而保证核心功能可用; - 熔断:某个依赖的服务持续出错时,暂时不再调用它而是直接返回默认结果,避免故障沿着调用链扩散。 三者针对的对象不同:限流保护的是自己,按进入的请求量拒绝多余的请求;熔断针对的是下游依赖,按依赖的失败情况停止调用;降级是被限流、被熔断或主动关闭功能之后返回的替代结果。三者通常一起使用,例如熔断器打开时执行的就是降级逻辑。 @@ -152,14 +152,14 @@ I/O 多路复用用的是第二个原因:一个线程同时等待多个连接

-令牌桶不需要定时放入令牌,只要记下剩余的令牌数和上次更新的时间,请求到来时补上这段时间应放入的令牌,再判断够不够。Guava 的 RateLimiter 和 Spring Cloud Gateway 的 Redis 限流器都是这样实现的。RateLimiter 的 acquire() 在令牌不足时让调用线程等待,tryAcquire() 则立即返回 false(Guava 33.4 实测,见[附录 A14](#a14-guava-的-ratelimiter))。 +令牌桶不需要定时放入令牌,只要记下剩余的令牌数和上次更新的时间,请求到来时补上这段时间应放入的令牌,再判断够不够。Guava 的 RateLimiter 和 Spring Cloud Gateway 的 Redis 限流器都是这样实现的。RateLimiter 把当前请求欠下的令牌记到后面的请求上:没有尚未偿还的等待时间时,即使令牌不足也立即通过;前面的请求预支过时,acquire() 阻塞调用线程直到偿还完,无参的 tryAcquire() 则立即返回 false(Guava 33.4 实测,见[附录 A14](#a14-guava-的-ratelimiter))。 四种算法的对比: | 算法 | 突发请求 | 需要保存的数据 | 适用场景 | | --- | --- | --- | --- | | 固定窗口 | 窗口边界处最多放行 2 倍 | 每个窗口一个计数器 | 精度要求不高的限制,例如每天的调用次数 | -| 滑动窗口 | 任意 1 秒内都不超过上限 | 每个请求一条记录,或分格计数 | 按用户、按接口的精确限制 | +| 滑动窗口 | 记录每个请求时任意 1 秒内都不超过上限,分格计数时格子的边界处仍可能多放行 | 每个请求一条记录,或分格计数 | 按用户、按接口的精确限制 | | 漏桶 | 排队,按固定速率处理 | 请求队列 | 保护处理能力固定的下游,例如调用外部接口 | | 令牌桶 | 允许不超过桶容量的突发 | 令牌数和时间戳 | 允许短时突发的接口限流 | @@ -169,7 +169,7 @@ I/O 多路复用用的是第二个原因:一个线程同时等待多个连接 判断和扣减必须是原子的。令牌桶要先读出令牌数、计算后再写回,几条命令之间可能插入其它请求的命令:桶中有 5 个令牌时同时来 50 个请求,先 HMGET 再 HSET 的写法把 50 个全部放行(见[附录 A13](#a13-限流算法))。 -WATCH 加 MULTI 也能保证只放行 5 个,但冲突时要反复重试,因此一般用 Lua 脚本,脚本执行期间不会插入其它命令。令牌数和更新时间存在一个哈希表中: +WATCH 加 MULTI 也能保证只放行 5 个,但冲突时要反复重试,因此一般用 Lua 脚本,脚本执行期间不会插入其它命令(原理和注意事项见 [Lua 脚本](Redis.md#lua-脚本))。令牌数和更新时间存在一个哈希表中: ```lua -- KEYS[1] 限流键;ARGV:每秒放入的令牌数、桶的容量、当前时间(毫秒) @@ -248,7 +248,7 @@ Sentinel 的半开状态只放行一个请求,这个请求成功就结束熔 熔断依赖超时:没有设置超时的调用只会一直等待,不会失败,熔断器也就无从统计,所以每个远程调用都要先设好超时,见 [OpenFeign](微服务.md#openfeign) 中的超时配置。 -重试则要克制。只对幂等的操作、可能自行恢复的错误(例如超时、连接被拒绝、429)重试,次数要有上限,间隔按指数增长并加上随机抖动,响应带有 Retry-After 时按它等待;参数错误、余额不足这类重试也不会成功的错误直接失败。还要避免每一层都重试:调用链上 3 层各重试 3 次,一次用户操作在最底层最多产生 4 × 4 × 4 = 64 次请求。反向代理也算一层,例如 Nginx 默认在连接出错或超时时把请求转给下一台后端(proxy_next_upstream error timeout),已经发给后端的 POST、LOCK、PATCH 请求除外。除了每个请求的次数上限,还可以限制重试占全部请求的比例,例如 Google SRE 书中只在重试占比低于 10% 时才重试,gRPC 的重试限流也用令牌桶实现类似的效果。熔断器打开后,对这个依赖的重试也随之停止。 +重试则要克制。只对幂等的操作、可能自行恢复的错误(例如超时、连接被拒绝、429)重试,次数要有上限,间隔按指数增长并加上随机抖动,响应带有 Retry-After 时按它等待;参数错误、余额不足这类重试也不会成功的错误直接失败。还要避免每一层都重试:调用链上 3 层各重试 3 次,一次用户操作在最底层最多产生 4 × 4 × 4 = 64 次请求。反向代理也算一层,例如 Nginx 默认在连接出错或超时时把请求转给下一台后端(proxy_next_upstream error timeout),已经发给后端的 POST、LOCK、PATCH 请求除外。除了每个请求的次数上限,还可以限制重试占全部请求的比例,例如 Google SRE 书中只在重试占比低于 10% 时才重试,gRPC 的重试限流也是这个思路:可重试的失败扣一个令牌,每次成功补回配置的 tokenRatio,令牌不超过上限的一半时暂停重试。熔断器打开后,对这个依赖的重试也随之停止。 #### 4. 降级 @@ -366,9 +366,9 @@ return 0 -- 抢购成功 Redis 执行 Lua 脚本时不会穿插执行其它命令,判断是否已购、判断库存、扣减库存和记录用户这四步作为一个整体完成。如果在应用中先 GET 库存、判断大于 0 之后再 DECR,两个请求可能同时读到库存为 1,并且都扣减成功。例如库存为 100、1000 个用户各请求 2 次、64 个线程并发:Lua 脚本恰好卖出 100 件;先查询后扣减的写法运行 3 次,分别卖出了 113、106、114 件,库存变成了负数(Redis 7.4 实测,见[附录 A1](#a1-秒杀))。 -不用 Lua 时,可以利用单条命令的原子性:先 SADD 已购集合,返回 0 说明买过;再 DECR 库存,返回值小于 0 说明没货,INCR 加回并 SREM 撤销。这样也恰好卖出 100 件,但没抢到的用户同时发出的另一个请求可能看到还没撤销的占位,被告知已经买过(见附录 A1);应用在两步之间宕机还会留下残留。只用 MULTI 事务时不能根据读到的库存决定是否扣减,见 [Lua 脚本](Redis.md#lua-脚本)。 +不用 Lua 时,可以利用单条命令的原子性:先 SADD 已购集合,返回 0 说明买过;再 DECR 库存,返回值小于 0 说明没货,INCR 加回并 SREM 撤销。这样也恰好卖出 100 件,但没抢到的用户同时发出的另一个请求可能看到还没撤销的占位,被告知已经买过(见[附录 A1](#a1-秒杀));应用在两步之间宕机还会留下残留。只用 MULTI 事务时不能根据读到的库存决定是否扣减,见 [Lua 脚本](Redis.md#lua-脚本)。 -库存键本身也是热点。一个商品的库存只有一个键,只能落在一个 Redis 节点上,集群的节点再多也分担不了;对单个库存键执行上面的脚本,每秒约 7.5 万~8.6 万次(见附录 A1)。请求量超过这个量级时,常用的做法有: +库存键本身也是热点。一个商品的库存只有一个键,只能落在一个 Redis 节点上,集群的节点再多也分担不了;对单个库存键执行上面的脚本,每秒约 7.5 万~8.6 万次(见[附录 A1](#a1-秒杀))。请求量超过这个量级时,常用的做法有: - 网关按库存放行:100 件商品只放前 1 万个请求进入预扣,其余直接返回已抢完; - 进程内售罄标记:脚本返回库存不足后,应用实例在内存中记下这个商品已售罄,之后的请求不再访问 Redis,回补库存时清除标记; @@ -382,7 +382,7 @@ Redis 执行 Lua 脚本时不会穿插执行其它命令,判断是否已购、 UPDATE goods SET stock = stock - 1 WHERE id = 1001 AND stock > 0; ``` -一人一单可以用订单表上(用户 ID,商品 ID)的唯一索引保证,消息被重复消费时插入失败,也就实现了幂等。前提是扣减数据库库存和插入订单在同一个事务中,插入失败时整个事务回滚,库存不会被多扣。 +一人一单可以用订单表上(用户 ID,商品 ID)的唯一索引保证,消息被重复消费时插入失败,也就实现了幂等。前提是扣减数据库库存和插入订单在同一个事务中,插入失败时回滚整个事务,库存不会被多扣。需要注意的是,MySQL 遇到唯一键冲突只回滚这一条 INSERT,回滚整个事务要由应用执行:消费者捕获冲突后如果照常提交,前面的扣减仍会生效。 ### 防止超卖的几种做法 @@ -396,7 +396,7 @@ UPDATE goods SET stock = stock - 1 WHERE id = 1001 AND stock > 0; - 乐观锁:表中加一个版本号,UPDATE 时带上条件 version = 读到的值,影响行数为 0 说明这一行已被别人修改,放弃或重试; - 条件更新:把判断写进 UPDATE 的条件 stock > 0,判断和扣减由一条语句在行锁的保护下完成。 -也可以在应用中加锁。synchronized 这类本地锁只在一个进程内有效,多实例部署时无效;分布式锁能保证正确,但同一商品的请求全部排队,见[分布式锁的对比](分布式.md#三种实现的对比)。一人一单按用户加锁冲突很少,可以使用,但锁可能因过期或主从切换失效,最终仍以唯一索引为准。 +也可以在应用中加锁。synchronized 这类本地锁只在一个进程内有效,多实例部署时无效;分布式锁能让多个实例互斥,但同一商品的请求全部排队,见[分布式锁的对比](分布式.md#三种实现的对比)。一人一单按用户加锁冲突很少,可以使用,但锁可能因过期或主从切换失效,最终仍以唯一索引为准。 用 64 个线程模拟抢购库存为 100 的商品,每个用户请求 1 次,每种写法运行 3 轮(MySQL 8.0 实测,见[附录 A19](#a19-防止超卖的几种写法)): @@ -424,7 +424,7 @@ UPDATE goods SET stock = stock - 1 WHERE id = 1001 AND stock > 0; - Lua 脚本扣减成功,发送消息失败:明确返回失败时立即执行一段反向的脚本,把库存加回、把用户移出已购集合;发送超时的消息可能已经送达,不能直接回补,交给对账判断;应用恰好在两步之间宕机时,这次扣减只留在 Redis 中,由对账发现。也可以用 RocketMQ 的[事务消息](分布式.md#本地消息表),先发送半消息,执行 Lua 脚本后再提交,应用宕机时由 Broker 回查用户是否在已购集合中; - 消息已发出,订单服务创建订单失败:用户校验不通过这类业务上的失败,订单服务记录失败结果并回补 Redis;网络超时、数据库暂时不可用这类异常则依靠消息重试,订单表的唯一索引保证重试不会创建两个订单; -- 订单创建后用户未支付:超时取消订单时,在同一个事务中修改订单状态并把数据库的库存加回,提交后再回补 Redis,超时取消可以用[延迟消息](消息队列.md#延迟消息)实现。 +- 订单创建后用户未支付:超时取消订单时,在同一个事务中修改订单状态并把数据库的库存加回,提交后再回补 Redis,超时取消可以用[延迟消息](消息队列.md#延迟消息)实现,到期时用户可能正在付款,处理方法见[超时关单](#超时关单)。 回补 Redis 时要防止重复执行,例如在脚本中先 SREM 已购集合,返回 1(用户确实在集合中)才把库存加 1,同一条回补消息执行两次也只加一次。如果回补后允许用户再抢一次,迟到的重复回补消息会删掉新的购买记录,这时已购记录要保存这次抢购的请求 ID,回补时请求 ID 一致才执行。 @@ -544,7 +544,7 @@ UPDATE red_packet SET remain_amount = remain_amount - 276, remain_num = remain_n WHERE id = 8001 AND remain_num > 0 AND remain_amount >= 276; ``` -领取记录表在(packet_id, user_id)上有唯一索引,重复投递的消息插入失败,整个事务回滚,剩余金额不会被扣两次(见[接收端的可靠性](消息队列.md#接收端的可靠性));UPDATE 的条件是数据库这一层的兜底。 +领取记录表在(packet_id, user_id)上有唯一索引,重复投递的消息插入失败,消费者捕获冲突后回滚事务,不再执行后面的 UPDATE,剩余金额不会被扣两次(见[接收端的可靠性](消息队列.md#接收端的可靠性));UPDATE 的条件是数据库这一层的兜底。 应用在脚本执行成功之后、消息发出之前宕机时,这条领取只记录在 Redis 中。因此红包抢完或过期后,要用 Redis 中的领取记录与数据库对账,补发缺失的消息。例如每条消息都投递两次、其中一个用户的消息全部丢失:18 条消息插入 9 条、冲突 9 条,对账补发后剩余金额为 0、领取记录 10 条,合计正好 100 元(MySQL 8.0 实测,见[附录 A16](#a16-并发抢红包与异步落库))。 @@ -578,7 +578,7 @@ WHERE id = 8001 AND remain_num > 0 AND remain_amount >= 276; 两个文件各有 50 亿个 URL,每个 URL 64 字节,找出两个文件共同的 URL。每个文件有 320 GB,用同一个哈希函数把两个文件各切成 1000 份,每份约 320 MB。相同的 URL 一定落在编号相同的一对小文件中,只需要依次把 ai 读入 HashSet,再逐行检查 bi。 -如果允许少量误判,可以用 [布隆过滤器](缓存.md#缓存穿透):把 a 中的 URL 都加入布隆过滤器,再逐个检查 b 中的 URL。4 GB 内存约有 344 亿位,每个 URL 平均 6.9 位,使用 5 个哈希函数时误判率约为 3.7%;要把误判率降到 1%,每个 URL 需要约 9.6 位,共需 5.6 GB。 +如果允许少量误判,可以用 [布隆过滤器](缓存.md#缓存穿透):把 a 中的 URL 都加入布隆过滤器,再逐个检查 b 中的 URL。4 GB 内存约有 344 亿位,每个 URL 平均 6.9 位,使用 5 个哈希函数时误判率约为 3.7%;要把误判率降到 1%,每个 URL 需要约 9.6 位(哈希函数增加到 7 个),共需 5.6 GB。 ### 去重与判断是否存在 @@ -642,7 +642,7 @@ Base62 区分大小写,code 列要用区分大小写的排序规则。MySQL 8. 设置了有效期的短链,跳转时先判断 expire_at,过期的不再跳转,返回失效提示;写缓存时让过期时间与 expire_at 对齐(例如 SET ... EXAT 时间戳),后台任务再按 expire_at 索引分批删除过期的记录。用哈希或随机方法生成、靠唯一约束判重的短码,删掉记录后就可能再分配给新的链接,旧短信、海报上的短链会跳到别人的地址,所以删除时保留短码本身(例如只清空长链接),不再分配。 -## 九、Feed 流 🔥 +## 九、Feed 流 Feed 流指的是把关注的人发布的内容按时间倒序合并后展示,例如朋友圈和微博的首页。每个用户有一个发件箱,保存自己发的帖子;难点在于怎样把几百个人的发件箱合成一个首页。 @@ -653,7 +653,9 @@ Feed 流指的是把关注的人发布的内容按时间倒序合并后展示, - 拉模式(读扩散):打开首页时,读取自己关注的所有用户的发件箱,合并后取最新的一页。发帖只写一次,但关注的人越多读得越慢; - 推模式(写扩散):发帖时把帖子写入每个粉丝的收件箱,打开首页只需读自己的收件箱。读很快,但粉丝越多写得越多,而且每个粉丝都存一份帖子 ID。 -用有序集合实现时(分值为发布时间),一个帖子推给 10 万个粉丝,用流水线写入 10 万个收件箱共约 480 ms,已有的收件箱每多一条约占 16 字节;读自己的收件箱一页只需 0.11 ms;拉模式从 500 个发件箱各取最新 20 条再合并,一次要 22.8 ms(Redis 7.4 实测,见[附录 A3](#a3-feed-流))。按这个速度,一个有 1000 万粉丝的大 V 发一条帖子,单个节点要写入约 50 秒;粉丝的收件箱都已存在时多占用约 150 MB 内存,需要新建收件箱时约 1 GB。 +用有序集合实现时(分值为发布时间),一个帖子推给 10 万个粉丝,用流水线写入 10 万个收件箱共约 480 ms,条数很少的收件箱每多一条约占 16 字节;读自己的收件箱一页只需 0.11 ms;拉模式从 500 个发件箱各取最新 20 条再合并,一次要 22.8 ms(Redis 7.4 实测,见[附录 A3](#a3-feed-流))。按这个速度,一个有 1000 万粉丝的大 V 发一条帖子,单个节点要写入约 50 秒。 + +内存方面,粉丝的收件箱都已存在且条数很少时多占用约 150 MB 内存,需要新建收件箱时约 1 GB。收件箱超过 128 条后,有序集合从紧凑的 listpack 编码改为跳表,每条约 120 字节,1000 万个收件箱各多一条就是约 1.2 GB;按下文裁剪到 1000 条之后,每写入一条就删掉一条,总量不再增长。 粉丝数差别很大时,常用推拉结合: @@ -691,7 +693,7 @@ p20 p19 p18 ... p11 容量要按高峰计算,不能按全天的平均值:平时高峰小时的 QPS 约是全天平均的 1.4 倍,大促则约是 14 倍。高峰小时内还有秒级的突发,所以估算值只是起点,要留出余量,并用秒级的监控和压测确认。 -10 万 QPS 直接落到数据库上风险很大。实测的 MySQL 主键点查在 16 至 128 个连接时达到 17 万至 19 万 QPS(见[附录 A4](#a4-mysql-主键点查的并发扫描)),但这是客户端与服务端同机、没有网络开销的结果;生产环境经过网络和其它负载后的上限会低很多。因此需要在数据库之前挡住绝大部分请求。 +10 万 QPS 直接落到数据库上风险很大。实测的 MySQL 主键点查在 16 至 128 个连接时为 14 万至 19 万 QPS(见[附录 A4](#a4-mysql-主键点查的并发扫描)),但这是客户端与服务端同机、没有网络开销的结果;生产环境经过网络和其它负载后的上限会低很多。因此需要在数据库之前挡住绝大部分请求。 ### 读路径的逐层分流 @@ -798,7 +800,7 @@ JMeter、wrk、k6 等工具负责按设定的并发或速率发出请求,并 大促前通常还要在生产环境做全链路压测,因为测试环境很难复现生产的规模和依赖关系。压测请求带上专门的标记(例如一个请求首部),每个服务识别这个标记并传给下游,传递方式与[链路追踪](微服务.md#八链路追踪)中的 traceId 相同,消息和异步任务中也要带上;带标记的请求写入影子库或影子表,不污染真实的订单和库存。压测安排在业务低峰期,并准备好随时停止压测的开关。 -用[利特尔法则](#3-并发用户数)可以估算同时在处理的请求数。例如 10 万 QPS、平均响应时间 5 ms(假设)时,系统中约有 500 个请求同时在处理。单台实例按 1200 QPS 计算时,同时处理约 6 个请求,线程池和连接池要在此基础上留出余量。 +用[利特尔法则](#3-并发用户数)可以估算同时在处理的请求数。例如应用层的 4 万 QPS、平均响应时间 5 ms(假设)时,约有 200 个请求同时在处理。单台实例按 1200 QPS 计算时,同时处理约 6 个请求,线程池和连接池要在此基础上留出余量。 实例数的估算方法是:所需实例数 = 峰值 QPS ÷(单实例拐点 QPS × 目标利用率),再按可用区向上取整。例如应用层的回源为 4 万 QPS,单实例拐点按 2000 QPS 计算(假设,需用服务自己的压测结果替换),目标利用率为 60%:4 万 ÷ 1200 ≈ 33.3,取 34 台,三个可用区各 12 台,共 36 台。一个可用区故障时剩余 24 台,每台约 1667 QPS,仍低于拐点。 @@ -822,7 +824,7 @@ JMeter、wrk、k6 等工具负责按设定的并发或速率发出请求,并 以 Qwen2.5-7B-Instruct 为例,每个 token 的 KV Cache 为 56 KiB,权重约 14.2 GiB(见[附录 A8](#a8-由配置推算-qwen25-7b-的参数与-kv-cache))。24 GiB 的显卡扣除权重、再保留 2 GiB 给框架与激活(假设)后,约能缓存 14.6 万个 token,平均每个请求 2000 token 时同时只能处理约 73 个。计算方法和减少 KV Cache 的做法见[显存:权重与 KV Cache](大模型应用.md#3-显存权重与-kv-cache)。 -因此大模型服务的限流通常按 token 计算,而不是按请求数。vLLM 用分页的方式管理 KV Cache(PagedAttention),减少显存的浪费,从而提高可同时处理的请求数。 +因此大模型服务的限流不能只看请求数,通常还要按 token 计算,例如限制每分钟的 token 数。vLLM 用分页的方式管理 KV Cache(PagedAttention),减少显存的浪费,从而提高可同时处理的请求数。 ## 十一、大文件上传 @@ -865,7 +867,7 @@ JMeter、wrk、k6 等工具负责按设定的并发或速率发出请求,并 秒传指的是服务端已经有内容相同的文件时,客户端不需要上传任何分片,直接建立引用。判断依据是文件的内容哈希:客户端在初始化前计算整文件的 SHA-256,服务端在文件表中查到相同的哈希,就直接返回文件已存在。 -秒传的代价在于先要读完整个文件来计算哈希。同时计算整文件和全部分片的 SHA-256,300 MiB 耗时约 0.31 秒,2 GiB 约 2 秒(Python hashlib 实测,见[附录 A9](#a9-分片上传的最小实现与实测))。浏览器中的 Web Crypto API 不支持流式输入,digest 要求把完整数据读入内存,因此大文件的哈希通常要用增量算法计算。 +秒传的代价在于先要读完整个文件来计算哈希。同时计算整文件和全部分片的 SHA-256,300 MiB 耗时约 0.31 秒(Python hashlib 实测,见[附录 A9](#a9-分片上传的最小实现与实测)),按此推算 2 GiB 约 2 秒(见[附录 A10](#a10-推算数字))。浏览器中的 Web Crypto API 不支持流式输入,digest 要求把完整数据读入内存,因此大文件的哈希通常要用增量算法计算。 需要注意的是,只按哈希判断文件是否存在时,任何知道哈希的用户都可以“秒传”别人的文件,并借此探测某个文件是否存在。秒传应当只在当前用户自己的文件空间内建立引用,存储中的文件仍然只保存一份。实测中,同一内容换了文件名再次上传,初始化直接返回已存在,没有发送任何分片。 @@ -915,9 +917,9 @@ S3 的完成请求要求列出每个分片的分片号和 ETag,服务端按分 分片本身不是对象,只有完成请求之后才生成对象,分片也随之消失。因此合并是分片上传的最后一步。在 S3 中,合并由存储服务按分片号组合,应用不需要再下载、拼接并重新上传一次。 -MinIO 兼容 S3 的分片上传接口,分片号和最小分片的限制与 S3 一致:分片号必须在 1 到 10000 之间,除最后一片外每片至少 5 MiB,否则完成上传时返回 EntityTooSmall 错误;单个分片最大 5 TiB,比 S3 的 5 GiB 大。应用侧的流程与上文相同,区别在于分片由 MinIO 保存,完成时由 MinIO 组合成对象。如果希望大文件不经过应用服务器,也可以让客户端用预签名 URL 直接上传到对象存储,应用服务只保存上传状态。 +MinIO 兼容 S3 的分片上传接口,分片号和最小分片的限制与 S3 一致:分片号必须在 1 到 10000 之间,超出时上传分片的请求直接被拒绝;除最后一片外每片至少 5 MiB,否则完成上传时返回 EntityTooSmall 错误;单个分片最大 5 TiB,比 S3 的 5 GiB 大(MinIO 社区版 RELEASE.2025-10-15,该仓库已归档,以官方最新文档为准)。应用侧的流程与上文相同,区别在于分片由 MinIO 保存,完成时由 MinIO 组合成对象。如果希望大文件不经过应用服务器,也可以让客户端用预签名 URL 直接上传到对象存储,应用服务只保存上传状态。 -## 十二、权限系统 +## 十二、权限系统 🔥 权限系统要解决两个问题:功能权限指的是用户能不能执行某个操作,数据权限指的是用户能看到哪些数据。例如在采购后台中,采购员可以创建采购订单,但只能看到自己创建的订单;采购主管可以审批订单,并能看到本部门的全部订单。前者由接口权限决定,后者由数据范围决定。 @@ -1056,7 +1058,7 @@ SELECT id, title FROM sys_order ORDER BY id; 常见做法是在 Mapper 或 DAO 层用注解标记需要过滤的查询,由 AOP 或 MyBatis 拦截器在执行前把范围条件追加到 WHERE 中,业务代码不需要关心范围。这种做法需要注意以下几点: - 条件的值必须通过参数绑定传入,不能拼接字符串; -- 多表关联或子查询中,条件要加在正确的表别名上,原条件还要先加括号。例如 status = 1 OR status = 2 直接拼上 AND dept_id = 20,AND 的优先级高于 OR,其它部门 status = 1 的订单也会返回,所以拦截器要用 SQL 解析器改写,而不是拼接字符串; +- 多表关联或子查询中,条件要加在正确的表别名上,原条件还要先加括号。例如 amount < 200 OR amount > 5000 直接拼上 AND dept_id = 20,AND 的优先级高于 OR,其它部门 amount < 200 的订单也会返回,所以拦截器要用 SQL 解析器改写,而不是拼接字符串; - MyBatis 拦截器要在 Executor.query 中、计算缓存键之前改写 SQL。在 StatementHandler.prepare 中改写时,缓存键仍按原 SQL 和参数计算,开启二级缓存后,另一个部门的用户会命中前一个用户的查询结果; - 分页的总数(COUNT)也要带同一条件。张三的订单列表只有 2 条,不带条件的 COUNT(*) 却返回 4,分页会显示错误的总数; - 修改和删除同样要带范围条件。张三修改订单 2 时,执行 UPDATE sys_order SET amount = 1 WHERE id = 2 AND creator_id = 1001,影响行数为 0,应用据此拒绝请求。这是为了防止不安全的直接对象引用(Insecure Direct Object Reference, IDOR),即用户只改动 URL 中的 ID 就访问到别人的数据; @@ -1157,7 +1159,7 @@ CREATE TABLE video_stat ( ```sql BEGIN; -INSERT INTO video_like (user_id, video_id) VALUES (1001, 1024); -- 重复点赞时报错 1062,回滚 +INSERT INTO video_like (user_id, video_id) VALUES (1001, 1024); -- 重复点赞时报错 1062,只撤销这条语句,应用要执行 ROLLBACK UPDATE video_stat SET like_count = like_count + 1 WHERE video_id = 1024; COMMIT; ``` @@ -1183,7 +1185,7 @@ COMMIT; 点赞数直接从 Redis 中读。“是否点过”按用户查询,一页 10 个视频用一条按 user_id 的查询就能查完,再缓存用户最近点过赞的视频,大部分请求不需要访问数据库。 -用 Redis 的 SET 保存每个视频的点赞用户看起来更直接,但热门视频的集合很大:100 万个用户 ID 约占 30 MB(Redis 7.4 实测,见附录 A21),1000 万个就是约 300 MB 的大 Key,删除和迁移时都会阻塞 Redis,见 [大 Key 与热 Key](缓存.md#大-key-与热-key)。所以“谁赞过什么”按用户保存,而不是按视频保存。 +用 Redis 的 SET 保存每个视频的点赞用户看起来更直接,但热门视频的集合很大:100 万个用户 ID 约占 30 MB,1000 万个约占 415 MB(Redis 7.4 实测,见附录 A21),是一个大 Key,删除和迁移时都会阻塞 Redis,见 [大 Key 与热 Key](缓存.md#大-key-与热-key)。所以“谁赞过什么”按用户保存,而不是按视频保存。 #### 3. 数据量 @@ -1326,13 +1328,13 @@ WHERE id = 1024 AND status IN ('UNPAID', 'CLOSING'); ### 超时关单 -到期触发用延迟消息加扫描兜底:下单时发送一条 30 分钟后投递的消息,再用一个低频的定时任务扫描超时仍未关闭的订单,补上丢失的消息,两者的取舍见[定时扫描与延迟消息](分布式.md#定时扫描与延迟消息)。关单消息要和订单一起成功,可以在同一个本地事务中写入[本地消息表](分布式.md#本地消息表),或者使用事务消息,否则会出现订单已创建、关单消息却没有发出的情况。 +到期触发用延迟消息加扫描兜底:下单时发送一条 30 分钟后投递的消息,再用一个低频的定时任务扫描超时仍未关闭的订单,补上丢失的消息,两者的取舍见[定时扫描与延迟消息](分布式.md#定时扫描与延迟消息)。关单消息要和订单一起成功,可以在同一个本地事务中写入[本地消息表](分布式.md#本地消息表),或者用事务消息发一条普通消息,由它的消费者再发送延迟消息(RocketMQ 的事务消息不能同时设置延迟),否则会出现订单已创建、关单消息却没有发出的情况。 关单的难点是到期时用户可能正在付款。如果只改本地状态(status 从 UNPAID 改为 CLOSED),支付平台上的这笔交易仍然可以支付,用户在 10:30 之后打开旧的支付页面照样能付款,结果是平台已收款、本地已关闭,只能退款。所以关单要以支付平台为准,分三步: 1. 用条件更新把订单从待支付改为关单中。影响 0 行时查看当前状态:已支付或已关闭就结束,仍是关单中(上一次执行到一半)就继续下一步; 2. 调用支付平台的关单接口,关单可以重复调用,返回成功或订单已关闭时,把订单从关单中改为已关闭,在同一个事务中回补库存。用户从未发起过支付的订单,平台上没有这笔交易,直接关闭; -3. 关单失败时查单:平台返回已支付,就按支付成功处理,与回调走同一段代码;返回订单不存在,说明平台上没有这笔交易,可以关闭:即使下单请求迟到、平台稍后才建单,交易的截止时间也已经过了,用户无法再付款(截止时间见下文的 time_expire);结果不明时保持关单中,由扫描任务稍后从第 1 步重新执行。 +3. 关单失败时查单:平台返回已支付,就按支付成功处理,与回调走同一段代码;返回订单不存在,说明平台上没有这笔交易,可以关闭:即使下单请求迟到、平台稍后才建单,本地的截止时间也已经过了,迟到的交易按下文的 time_expire 由平台拒绝付款,平台仍接受的付款按重复支付退款;结果不明时保持关单中,由扫描任务稍后从第 1 步重新执行。

@@ -1340,13 +1342,13 @@ WHERE id = 1024 AND status IN ('UNPAID', 'CLOSING'); 300 轮随机交错的实验中(回调 10% 丢失),只改本地状态的写法有 260 轮平台已付、本地已关;先向平台关单、失败只等回调的写法有 22 轮停在待支付,要靠查单或对账补上;按上面三步的写法 300 轮全部一致,都没有重复发货(MySQL 8.0 实测,见[附录 A23](#a23-超时关单与支付回调))。 -下单时还要把同一个截止时间传给支付平台,例如微信支付的 time_expire 设为 10:30,超过后平台拒绝支付。不传时平台默认 7 天内都可以支付,本地 30 分钟的超时就挡不住用户付款。 +下单时还要把同一个截止时间传给支付平台,例如微信支付的 time_expire 设为 10:30,超过后平台拒绝支付。需要注意的是,微信支付会把早于下单后 1 分钟的截止时间调整为下单后 1 分钟,迟到的下单请求在平台上仍有约 1 分钟可以付款,这笔钱在回调到达时按下文的[重复支付](#支付回调与重复支付)记下并退款。不传时平台默认 7 天内都可以支付,本地 30 分钟的超时就挡不住用户付款。 ### 支付回调与重复支付 支付结果有两个来源:支付平台主动发送的回调,以及订单服务主动查单。回调可能丢失,平台也要求不能只依赖回调,所以用户回到订单页、关单之前和定时任务都会查单。 -回调会重复发送,例如微信支付在 5 秒内没有收到成功应答,会在约 24 小时内按逐渐拉长的间隔重发,最多 15 次。处理时先验签,再核对通知中的商户号、订单号和金额与本地订单一致,并确认交易状态是支付成功(例如支付宝只有 TRADE_SUCCESS、TRADE_FINISHED 表示已付款,关单、退款也会发通知),然后把去重记录和条件更新放在同一个事务中: +回调会重复发送,例如微信支付在 5 秒内没有收到成功应答,会在约 24 小时内按逐渐拉长的间隔重发,最多 15 次。处理时先验签,再核对通知中的商户号、订单号和金额(微信支付以分为单位,下例的 5900 即 59 元)与本地订单一致,并确认交易状态是支付成功(例如支付宝只有 TRADE_SUCCESS、TRADE_FINISHED 表示已付款,关单、退款也会发通知),然后把去重记录和条件更新放在同一个事务中: ```sql BEGIN; @@ -1371,7 +1373,7 @@ COMMIT; ### 对账 -回调、查单和关单都可能因为程序缺陷或长时间故障漏掉一些订单,对账是最后的兜底:每天(T+1)下载支付平台前一天的交易账单,本地也取同一渠道、同一天支付成功的订单,按订单号逐笔核对,结果分为四类: +回调、查单和关单都可能因为程序缺陷或长时间故障漏掉一些订单,对账是最后的兜底:每天(T+1)下载支付平台前一天的交易账单,按订单号与本地订单逐笔核对(查找本地成功、账单中没有的订单时,本地只取同一渠道、同一天支付成功的订单),结果分为四类: - 双方都是支付成功:对平,金额或交易号不一致时也算差异,例如订单 1029 在支付宝和微信各付了一次,订单号相同、交易号不同; - 平台成功、本地未成功:例如订单 1025 在本地已关闭,补发货或者退款。是否支付过要看本地保留的交易号,而不是订单的当前状态,已进入退款中的订单也付过款,退款用退款账单另外核对; @@ -1382,12 +1384,12 @@ COMMIT; ### 转账与余额扣减 -转账要满足三点:余额不能扣成负数,钱的总数不能变,同一个请求不能执行两次。以用户 1 给用户 2 转 100 元为例,两个账户在同一个数据库中时,用一个事务完成: +转账要满足三点:余额不能扣成负数,钱的总数不能变,同一个请求不能执行两次。以用户 1 给用户 2 转 100 元为例(两个账户原有余额都是 1000 元),两个账户在同一个数据库中时,用一个事务完成: ```sql BEGIN; INSERT INTO transfer (request_id, from_id, to_id, amount, status) -VALUES ('req-7f3a', 1, 2, 100, 'DONE'); -- 请求号为主键,重复提交报 1062 +VALUES ('req-7f3a', 1, 2, 100, 'DONE'); -- 请求号为主键,重复提交时报错 1062,只撤销这条语句,应用要执行 ROLLBACK SELECT balance FROM account WHERE id = 1 FOR UPDATE; -- 先锁 id 小的账户 SELECT balance FROM account WHERE id = 2 FOR UPDATE; UPDATE account SET balance = balance - 100 @@ -1415,7 +1417,7 @@ COMMIT; ### A1 秒杀 -库存 stock 为 100,用户 0~999 各请求 2 次,共 2000 个请求由 64 个线程并发执行。Lua 脚本与正文相同;对比的写法依次执行 SISMEMBER、GET、DECR、SADD 四条命令: +库存 stock 为 100,用户 0~999 各请求 2 次,同一用户的 2 个请求相邻提交、几乎同时执行,共 2000 个请求由 64 个线程并发执行。Lua 脚本与正文相同;对比的写法依次执行 SISMEMBER、GET、DECR、SADD 四条命令: ```python def naive(u): @@ -1432,6 +1434,8 @@ Lua 脚本:成功 100,库存不足 1800,重复购买 100,剩余库存 0 先 GET 再 DECR(第 3 次):成功 114,库存不足 1886,重复购买 0,剩余库存 -14 ``` +先 GET 再 DECR 的写法中重复购买为 0,是因为同一用户的两个请求几乎同时通过了 SISMEMBER 的判断,一人一单也被破坏:按相同方法再运行 3 次,成功 107~109 次,已购集合中只有 55~57 个用户。 + 不用 Lua、按 SADD 和 DECR 的返回值判断的写法,同样的请求运行 3 次: ```python @@ -1499,6 +1503,8 @@ HIT /target OBJECT ENCODING inbox:0 -> listpack ``` +收件箱逐步增长时(2000 个收件箱,成员形如 post:<10 位数字>),超过 128 条后编码变为 skiplist,129~1000 条之间每条约 117~126 字节。 + ### A4 MySQL 主键点查的并发扫描 环境:MySQL 8.0.44,通过 unix socket 连接;Apple M1 Pro(10 核),macOS 15.8.1;客户端 mysqlslap 与服务端在同一台机器上。表 `item` 有 10 万行,主键为 `id BIGINT`,表大小约 5.5 MB,小于 128 MB 的 InnoDB 缓冲池,预热后查询都在内存中完成。 @@ -1616,15 +1622,17 @@ def put_part(self, uid, n): if not buf: # 客户端中途断开 break f.write(buf); h.update(buf); md5.update(buf); got += len(buf) - expect = q("SELECT expect_sha256 FROM upload_part WHERE upload_id=%s AND part_no=%s", + expect = q("SELECT expect_sha256, etag FROM upload_part WHERE upload_id=%s AND part_no=%s", (uid, n), 'one') if got != length or h.hexdigest() != expect['expect_sha256']: os.remove(tmp) - return self.send(400 if got != length else 409, {'error': 'part rejected'}) + if got != length: + return self.send(400, {'error': 'incomplete body'}) + return self.send(409, {'error': 'part sha256 differs from manifest', 'part': n}) os.replace(tmp, part_path(uid, n)) # 同号分片被覆盖 q("UPDATE upload_part SET size=%s, etag=%s WHERE upload_id=%s AND part_no=%s", (got, md5.hexdigest(), uid, n)) - self.send(200, {'part': n, 'etag': md5.hexdigest()}) + self.send(200, {'part': n, 'size': got, 'etag': md5.hexdigest(), 'overwritten': expect['etag'] is not None}) # 服务端:完成上传。条件更新保证只有一个请求进入合并,合并时流式计算整文件哈希 if q("UPDATE upload_task SET status='completing' WHERE id=%s AND status='uploading'", (uid,)) == 0: @@ -1638,6 +1646,7 @@ with open(tmp, 'wb') as out: out.write(buf); h.update(buf) if h.hexdigest() != u['sha256']: os.remove(tmp) + q("UPDATE upload_task SET status='uploading' WHERE id=%s", (uid,)) # 合并失败时改回,客户端可以重试 return self.send(409, {'error': 'file sha256 mismatch'}) os.replace(tmp, os.path.join(DATA, 'files', u['sha256'])) ``` @@ -1750,7 +1759,7 @@ $ 客户端 complete 762fa9bd16a44d31 (409, {'error': 'stored parts corrupted, re-upload them', 'parts': [7]}) [exit 0] $ 客户端 status 762fa9bd16a44d31 -(200, {'status': 'uploading', 'part_count': 20, 'uploaded': [1, 2, 3, 4, 5, 6, …, 19, 20]}) +(200, {'status': 'uploading', 'part_count': 20, 'uploaded': [1, 2, 3, 4, 5, 6, 8, 9, …, 19, 20]}) [exit 0] == C2 只重传被标记的分片,然后完成 @@ -1796,7 +1805,7 @@ incomplete body: upload e355c1f1002e409d part 2 got 2621440 of 5242880 ### A10 推算数字 -按正文的数值计算,输出如下(脚本与输出保存在实验目录中): +按正文的数值用 Python 计算,MiB、GiB、TiB 按 2 的幂,10 Mbps 按每秒 107 位,输出如下: ```text 2 GiB 文件、5 MiB 分片:分片数 410,最后一片 3 MiB @@ -1815,7 +1824,7 @@ SHA-256 扫描 300 MiB 实测 0.31 s,换算 2 GiB 约 2.12 s ### A11 权限判断与执行计划 -环境:MySQL 8.0.44,macOS(Apple M1 Pro),库 rbac,客户端字符集 utf8mb4。判断查询与正文相同,五个用例只替换 user_id、请求方法和路径。原始输出如下: +环境:MySQL 8.0.44,macOS(Apple M1 Pro),库 rbac,客户端字符集 utf8mb4。判断查询与正文相同,五个用例只替换 user_id、请求方法和路径。执行计划是把 EXISTS 中的子查询单独取出、SELECT 1 改为 SELECT p.code 后得到的,直接 EXPLAIN 正文的查询时多一行 No tables used 的外层查询,三张表的访问方式和预估行数相同。原始输出如下: ```text +--------------------------------+---------+ @@ -1839,13 +1848,13 @@ SHA-256 扫描 300 MiB 实测 0.31 s,换算 2 GiB 约 2.12 s ### A12 数据范围、分页总数与写操作 -环境同[附录 A11](#a11-权限判断与执行计划)。数据范围的查询与正文相同,COUNT 和 UPDATE 为: +环境同[附录 A11](#a11-权限判断与执行计划)。数据范围的查询与正文相同,输出时多选了用户标签、creator_id 和 dept_id,孙七一行统计的是追加 WHERE 1 = 0 后的行数;COUNT 和 UPDATE 为: ```sql -SELECT COUNT(*) FROM sys_order WHERE creator_id = 1001; -SELECT COUNT(*) FROM sys_order; +SELECT COUNT(*) AS count_with_scope FROM sys_order WHERE creator_id = 1001; +SELECT COUNT(*) AS count_without_scope FROM sys_order; UPDATE sys_order SET amount = 1 WHERE id = 2 AND creator_id = 1001; -SELECT ROW_COUNT(); +SELECT ROW_COUNT() AS affected_rows; SELECT id, amount FROM sys_order WHERE id = 2; ``` @@ -2169,7 +2178,7 @@ CREATE TABLE red_packet_grab ( amount INT NOT NULL, UNIQUE KEY uk_packet_user (packet_id, user_id)); ``` -10 条领取消息各投递两次并打乱顺序,去掉其中一个用户的两条,剩余 18 条由 8 个线程并发消费;之后查出数据库中已有的领取者,与 Redis 中的领取记录比较,补发缺失的消息: +10 条领取消息各投递两次并打乱顺序,去掉其中一个用户的两条,剩余 18 条由 8 个线程并发消费;之后查出数据库中已有的领取者,与领取记录(脚本中用列表代替 Redis 中的 Hash)比较,补发缺失的消息: ```text 消息 18 条:插入成功 9,唯一索引冲突 9 @@ -2204,7 +2213,7 @@ return redis.call('HINCRBY', KEYS[2], ARGV[1], 1) -- 返回第几张,落库 核销在 MySQL 8.0.44 上执行,表结构与正文相同。用户 1001 有两张券:70001 未过期,70002 已于前一天过期: ```text -重复消息再插入 (1001, 501, 1):ERROR 1062 (23000): Duplicate entry '1001-501-1' for key 'uk_user_coupon' +重复消息再插入 (1001, 501, 1):ERROR 1062 (23000): Duplicate entry '1001-501-1' for key 'user_coupon.uk_user_coupon' 订单 9001 锁定 70001:影响 1 行 订单 9002 再锁定 70001:影响 0 行 订单 9002 锁定已过期的 70002:影响 0 行 @@ -2419,23 +2428,26 @@ MySQL 8.0.44,Apple M1 Pro,默认配置。video_like 表与正文相同,10 ```text 插入 999997 行,用时 52.9 秒 -COUNT(*) = 999997,data_length = 68.6 MB,index_length = 38.6 MB,每行合计 112 字节 -表空间文件 116.0 MB,每行 122 字节 +COUNT(*) = 999997,data_length = 68.6 MiB,index_length = 38.6 MiB,每行合计 112 字节 +表空间文件 116.0 MiB,每行 122 字节 重复点赞: (1062, "Duplicate entry '10064451-51075055' for key 'video_like.PRIMARY'") INSERT IGNORE 重复点赞,影响行数 0 一次查询 5 个视频是否点过: (None, 'ref', 'PRIMARY,idx_user_time', 'idx_user_time', '8', 'const', 10) ``` -最后一行是 EXPLAIN 的 type、possible_keys、key、key_len、ref、rows 列:查一个用户对 5 个视频是否点过赞,用 user_id 等值查询,扫描 10 行。 +最后一行是 EXPLAIN 的 partitions、type、possible_keys、key、key_len、ref、rows 列:查一个用户对 5 个视频是否点过赞,用 user_id 等值查询,扫描 10 行。 -Redis 7.4.1,同一台机器。向一个 SET 中加入 n 个 8 位数字的用户 ID,记录 INFO memory 中 used_memory 的增量;MEMORY USAGE 是估算值,偏大: +Redis 7.4.1,同一台机器。向一个 SET 中加入 n 个 8 位数字的用户 ID,记录 INFO memory 中 used_memory 的增量;MEMORY USAGE 是估算值,hashtable 编码时偏大: ```text SET 中 100 个用户 ID:编码 intset,used_memory 增加 592 字节(每个 6 字节),MEMORY USAGE 488 字节 SET 中 10000 个用户 ID:编码 hashtable,used_memory 增加 410704 字节(每个 41 字节),MEMORY USAGE 596736 字节 SET 中 1000000 个用户 ID:编码 hashtable,used_memory 增加 30070800 字节(每个 30 字节),MEMORY USAGE 48388736 字节 +SET 中 10000000 个用户 ID:编码 hashtable,used_memory 增加 415314000 字节(每个 42 字节) ``` +每个元素的开销随哈希表扩容时的桶数变化,所以不能按 100 万个的结果线性外推。 + 重复取消点赞(MySQL 8.0.44,同一台机器):用户 1001 点赞视频 1024 后,连续执行两次 `DELETE FROM video_like WHERE user_id = 1001 AND video_id = 1024`,用 ROW_COUNT() 查看影响行数: ```text @@ -2481,9 +2493,9 @@ TCP: inuse 0 orphan 0 tw 0 alloc 200026 mem 1535 150 s 连接 99000 收到心跳累计 482088 因超时关闭 1000 堆已用 87 MB ``` -由此计算:服务端进程的 VmRSS 增加约 120 MB,每个连接约 1.2 KB;Slab 增加 843 MB,每个套接字约 4.2 KB;心跳阶段服务端 60 秒内用了 6.88 秒 CPU,约为一个核的 11%。 +由此计算:服务端进程的 VmRSS 增加 120424 kB(约 118 MiB),每个连接约 1.2 KiB;Slab 增加 842916 kB(约 823 MiB),每个套接字约 4.2 KiB;心跳阶段服务端 60 秒内用了 6.88 秒 CPU,约为一个核的 11%。 -群聊的未读数和拉取,表结构与正文相同,群 88 的成员 1002 读到第 1 条,群里共有 10 条消息: +群聊的未读数和拉取(MySQL 8.0.44,Apple M1 Pro),表结构与正文相同,群 88 的成员 1002 读到第 1 条,群里共有 10 条消息: ```text +-----------------+ @@ -2575,7 +2587,7 @@ def close_full(c, p, oid): # C 关单中 + 平台关单 + 失 c.commit() ``` -最后一行模拟关单任务改为关单中后崩溃:2001 崩溃前已在平台关单成功,2002 在崩溃期间被支付且回调丢失,2003 从未发起支付,2004 发起过支付但平台下单失败,2005 的下单请求在关单之后才到达平台,扫描任务对它们重新执行 close_full;之后平台为 2005 建单,桩按已过 time_expire 拒绝付款。300 轮实验中的订单都已发起支付(pay_started = 1);多次运行时 A、B 两行的数字因线程调度相差几轮。重复回调的对照写法先 SELECT 订单状态,为 UNPAID 时再执行不带条件的 UPDATE 并写发货消息;10 个线程用 Barrier 同时开始。原始输出: +最后一行模拟关单任务改为关单中后崩溃:2001 崩溃前已在平台关单成功,2002 在崩溃期间被支付且回调丢失,2003 从未发起支付,2004 发起过支付但平台下单失败,2005 的下单请求在关单之后才到达平台,扫描任务对它们重新执行 close_full;之后平台为 2005 建单,桩按已过 time_expire 拒绝付款(桩没有模拟微信支付把截止时间延长到下单后 1 分钟的规则)。300 轮实验中的订单都已发起支付(pay_started = 1);多次运行时 A、B 两行的数字因线程调度相差几轮,先查后改的个别轮次发货少于 10 次。重复回调的对照写法先 SELECT 订单状态,为 UNPAID 时再执行不带条件的 UPDATE 并写发货消息;10 个线程用 Barrier 同时开始。原始输出: ```text 300 轮,用户在 0~20 ms 内付款,回调在付款后 0~20 ms 到达、10% 丢失,关单任务在 0~20 ms 内执行