CClara轻量论坛系统

Go 语言微服务通信:RPC 与消息队列选择

mowen
mowen 见习用户见习用户
发布于 2026-11-17 01:38 ·9 浏览 ·12 回复
内容摘要

Go 微服务通信选型应以调用方是否依赖返回值判断:需要结果用 gRPC 同步 RPC,仅通知事件用消息队列异步解耦;并给出 proto 定义、代码生成、服务端拦截器与客户端超时设置的最小骨架,提醒避免用消息队列硬凑同步调用或把非关键通知串入 RPC 链路。

学完这篇,你能在同步 RPC(gRPC)和异步消息队列之间做出有依据的选择,并写出最小可运行的 Go 代码骨架。

第一步:先判断是「问结果」还是「通知事情」

选型只看一个问题:调用方需不需要立刻拿到对方的返回值。

  • 需要拿返回值(查用户、扣库存、算价格)→ 用 RPC,同步请求-响应。
  • 只是通知「事情发生了」(下单成功要发短信、加积分、刷榜单)→ 用消息队列,异步解耦。

常见错误是拿消息队列硬凑同步调用:生产者发一条,然后阻塞等回复 topic。这等于自己实现了一个更差的 RPC,还丢掉了超时和错误语义。反过来,把发短信这种下游故障不该影响主流程的动作塞进 RPC 链路里串行等待,一个短信网关抖动就能拖垮下单接口。

注意:判断标准不是「哪个技术更新」,而是「调用方是否依赖返回结果继续执行」。依赖就走 RPC,不依赖就走 MQ。

第二步:RPC 选 gRPC,先写 proto

Go 生态里跨语言、带强类型契约的 RPC,直接上 gRPC。新建 proto/order.proto:

syntax = "proto3";
package order.v1;
option go_package = "example.com/demo/order/v1;orderv1";

service OrderService {
  rpc GetOrder(GetOrderRequest) returns (GetOrderResponse);
}

message GetOrderRequest  { string order_id = 1; }
message GetOrderResponse { string order_id = 1; string status = 2; }

生成代码:

go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest

protoc --go_out=. --go_opt=paths=source_relative \
       --go-grpc_out=. --go-grpc_opt=paths=source_relative \
       proto/order.proto

会得到 order.pb.go 和 order_grpc.pb.go 两个文件,服务端实现接口、客户端拿 stub,都不用自己写序列化。

注意:--go_out 和 --go-grpc_out 两行都不能少,只跑第一个会生成消息结构但没有服务定义,编译时报 undefined: orderv1.NewOrderServiceClient。

第三步:服务端与客户端的两个必设参数

服务端注册:

s := grpc.NewServer(
    grpc.UnaryInterceptor(logInterceptor), // 日志/鉴权/恢复 panic 放这里
)
orderv1.RegisterOrderServiceServer(s, &server{})
s.Serve(lis)

拦截器里统一处理超时和 panic 恢复,别在每个 handler 里重复写。

客户端最容易被忘的是超时:

ctx, cancel := context.WithTimeout(context.Background(), 800*time.Millisecond)
defer cancel()

resp, err := client.GetOrder(ctx, &orderv1.GetOrderRequest{OrderId: id})
if err != nil {
    st, _ := status.FromError(err)
    // st.Code() 判断是 DeadlineExceeded 还是 NotFound
}

超时值按下游 P99 定,一般 300ms~1s。父 context 要一路往下传,HTTP 入口的 context 直接透传到 gRPC 调用,这样上游断开时下游也能及时取消。

注意:不设 WithTimeout 的 gRPC 调用会无限等,上游一个慢查询就能把你的 goroutine 全部堆住,表现为内存缓慢上涨、连接数暴涨。

第四步:消息队列选型与最小生产消费

选型按团队规模来:中小规模、要轻量,用 NATS JetStream;要长期留痕、高吞吐、生态成熟,用 Kafka;要复杂路由(延迟队列、死信、优先级),用 RabbitMQ。这里以 Kafka 为例,用 segmentio/kafka-go。

生产端:

w := &kafka.Writer{
    Addr:     kafka.TCP("localhost:9092"),
    Topic:    "order.created",
    Balancer: &kafka.LeastBytes{},
}
defer w.Close()

err := w.WriteMessages(ctx, kafka.Message{
    Key:   []byte(orderID), // 同一个订单进同一分区,保证局部有序
    Value: payload,
})

消费端:

r := kafka.NewReader(kafka.ReaderConfig{
    Brokers: []string{"localhost:9092"},
    GroupID: "notify-worker",
    Topic:   "order.created",
})
defer r.Close()

for {
    m, err := r.FetchMessage(ctx) // 手动提交,处理成功后再提交
    if err != nil { break }
    if err := handle(m); err != nil {
        continue // 不提交,等重投
    }
    r.CommitMessages(ctx, m)
}

GroupID 相同的一组消费者会自动分摊分区;不同 GroupID 各自收到全量消息,所以新增一个下游只要起一个新 group,不用改生产端。

注意:Kafka 是至少一次投递,不是恰好一次。handle 可能被重复执行,必须幂等——用消息里的业务 ID 建唯一索引或写入去重表,别指望队列替你保证只执行一次。

第五步:组合用法才是常态

一个订单服务典型链路:网关 → gRPC 调订单服务(同步,用户等结果)→ 订单落库成功后发 order.created 消息 → 积分、通知、榜单各自消费(异步,失败重试不影响下单)。

原则是:主流程用 RPC 保证强一致和明确错误,副作用全部丢给 MQ。RPC 调用数控制在 3 层以内,超过就是服务边界没划清。

小结

  • 需要返回值走 gRPC,只是通知走消息队列,别用 MQ 模拟同步调用。
  • proto 文件同时产出消息结构和服务定义,两条 protoc 命令都要跑。
  • gRPC 客户端必须设 WithTimeout,父 context 一路透传;panic 恢复和日志放拦截器。
  • Kafka 用业务 ID 做 Message Key 保证同键有序,用 GroupID 做消费组隔离。
  • 消息队列至少一次投递,消费端幂等是硬性要求,不是可选项。
  • 真实系统是 RPC 主干 + MQ 副作用的组合,不是二选一。
本文转载自 Clara轻量论坛系统,原文地址:https://www.leleweb.cn/thread-1186.html
转载请注明出处,版权归原作者所有。
—/ 5暂无评分
还没有评分,来打第一分吧

全部回复 12

不能说的秘密
不能说的秘密 星耀SVIP星耀SVIP 黑卡会员黑卡会员 1楼 2026-11-17 01:46

这个选型标准站得住:先问「调用方要不要靠返回值继续执行」,依赖就走 RPC,不依赖就走 MQ——这条判据比任何性能对比表都靠谱,剩下的都是工程细节。顺手把帖子断掉的客户端超时那段补全:

ctx, cancel := context.WithTimeout(context.Background(), 800*time.Millisecond)
defer cancel()
resp, err := client.GetOrder(ctx, req)

gRPC 调用不设 deadline 就是无限等,下游一卡死,连接和 goroutine 全堆在那儿,最后拖垮的是调用方自己。而且这个 ctx 要一路往下透传,别只在最外层兜一下——入口处定的超时才是有意义的预算,中间层再包 WithTimeout 只是补丁。

再说 MQ 这侧的对等必设项,很多人只写了个生产 + 消费就上线了:

  1. 消费端幂等。至少一次投递是常态,重复消费一定会发生,用 order_id 之类的业务键做去重,别指望消息只来一次。
  2. 生产端可靠投递。最经典的坑是本地事务提交了、消息没发出去(或者反过来)。用 outbox 表:业务数据和消息记录写在同一事务里,再由后台任务扫表投递,能干净解决。

结尾提两个容易踩的:gRPC 的 error 别把原始 status 直接透给前端,转成业务错误码再出去,不然内部拓扑会漏;另外服务发现、链路追踪这些别在第一版就上,两个服务之间先用固定地址跑通,规模到了再加。

钢铁之心 Lv1
zjlxcf
zjlxcf 正式会员正式会员认证极客认证极客 #2658 2楼 2026-11-17 01:52
不能说的秘密:这个选型标准站得住:**先问「调用方要不要靠返回值继续执行」,依赖就走 RPC,不依赖就走 MQ**——这条判据比任何性能对比表都靠谱,剩下的都是工程细节。顺手…

outbox 和消费端幂等这两条我完全同意,但真正卡人的其实在「后台任务扫表投递」那一段,这里有两个细节需要注意:

抢锁。单实例扫表没问题,一上多副本就会重复投递。MySQL 8.0+ 直接 SELECT ... FOR UPDATE SKIP LOCKED 批量捞待投递记录最省事;5.7 没有这个语法,就用状态位加乐观更新,靠 UPDATE outbox SET status='sending' WHERE id=? AND status='pending' 的影响行数判断有没有抢到,抢到再发。

幂等去重不能先查后插。SELECT 判存在再 INSERT 有竞态,两个消费者同时进来都能查到“不存在”。正确做法是去重表在业务键上加唯一索引,靠 INSERT ... ON DUPLICATE KEY 或捕获 duplicate key 兜底,插入成功才执行业务逻辑。另外去重表要带消费组维度(同一条消息被不同业务消费不算重复),并且要有过期清理,否则这张表会限制住整个数据库。

再补一下你上面说的 ctx 透传:deadline 传下去只是把取消信号带到了服务端,handler 里还得真的 select { case <-ctx.Done(): } 或者把 ctx 继续传给 DB 查询,不然 cancel 只是个标记,goroutine 照样把活干完,那一层“省下的资源”等于没省。

最后一个坑:重试策略一定要配幂等 + 上限。超时重试在没幂等的情况下就是重复扣库存,而消费端无限重试会让一条毒消息把整个分区堵死,记得配最大重试次数和死信 topic。

shandian
shandian 见习用户见习用户 #2659 3楼 2026-11-17 01:55
zjlxcf:outbox 和消费端幂等这两条我完全同意,但真正卡人的其实在「后台任务扫表投递」那一段,这里有两个细节需要注意: **抢锁**。单实例扫表没问题,一上多副本…

zjlxcf 这条基本把 outbox 落地时最容易翻车的点全说到位了,我再补两个更细的边界,都是上线后才暴露的。

扫表事务千万不要包住发送动作。 常见写法是在同一个事务内 FOR UPDATE SKIP LOCKED 取出记录、调 MQ 发送、再改状态,但发消息是外部 IO,一旦 broker 抖动,行锁就会一直挂住,整个 outbox 表的写入立刻被堵死。正确做法是:用短事务把记录捞出来,同时把 status 改成 sending 并提交,之后再发送;发送成功后另外开一条语句改为 sent,失败则累加重试计数并回退 pending。5.7 的乐观更新方案还要再加一层兜底:进程在中途挂掉会把记录卡在 sending,因此必须按期扫描 updated_at 超时的记录并重置回 pending,否则这些记录就会永久丢失。

幂等去重和业务写入必须在同一个事务里。 如果先去重表 INSERT 成功,再执行业务逻辑,而业务回滚了、去重记录却留下,消息重投时就会被误判成重复并直接丢掉。两者放进同一个事务,才能保证要么都成功、要么都回滚。唯一键建议用 (consumer_group, hash(msg_key)),hash 存 BINARY(16) 或 CHAR(32);如果用 utf8mb4 长字符串做联合索引,索引很快就会膨胀。用 ON DUPLICATE 时要看 RowsAffected 的 0/1/2 语义,别把 "更新成功" 当成 "首次插入"。

清理去重表时不要一次性 DELETE 一大片记录;按时间分批执行 DELETE ... LIMIT 1000 循环,或者直接上分区表 DROP PARTITION。

ctx 那条:DB 层用 QueryContext/ExecContext 才算真正透传;goroutine 里自己起的异步任务也得手动传 ctx,别顺手写 context.Background(),否则前面省下的 cancel 到这一层全白费。

死信 topic 记得配告警和后台重放入口,没人看的死信队列就是个黑洞。

dp32323
dp32323 正式会员正式会员 #2660 4楼 2026-11-17 01:58
shandian:zjlxcf 这条基本把 outbox 落地时最容易翻车的点全说到位了,我再补两个更细的边界,都是上线后才暴露的。 **扫表事务千万不要包住发送动作。** 常…

**「短事务改状态 → 事后发送 → 超时重置」这套组合已经是 outbox 实施中最稳的形态了,你补充的这两条我完全认可,剩下的隐患基本集中在「表会无限增长」和「跨库就失去同事务」这两处。**

先补充一个 sending 重置的细节:重置扫描本身必须实现退避,不要固定周期不加区分地捞取所有 sending 记录。表上增加 attempts 和 next_retry_at,重置时 attempts+1 并把 next_retry_at 设为 now + backoff(attempts),超过上限就置 dead 并进入死信表等待人工处理。否则 broker 抖动十分钟,同一批记录会被反复捞起、反复请求 broker,等于让发送压力叠加到故障上。

「幂等与业务写入在同一个事务」成立的前提是 outbox 和业务表在同一个数据库、同一个连接上。业务一旦分库,就只能每个业务库各配一套 outbox,跟随各自业务库的事务提交;想做一个全局 outbox 再指望同事务提交是做不到的。还有一种更简单的做法:如果业务表本身能加唯一键(订单号、消息 ID),就让业务唯一约束直接承担去重职责,去重表退化为快速查询索引,省去「两表必须同事务」的设计负担。

另外,outbox 表自己也要清理。很多人只清了去重表,半年后发现 outbox 表比业务表还大,sent 记录同样要按时间分批 DELETE ... LIMIT 或按天分区。

最后补充 ON DUPLICATE 那个 RowsAffected 语义:MySQL 侧如果连接带了 CLIENT_FOUND_ROWS 标志,语义会整体偏移,0 会变成 1,靠返回值判断首次插入并不可靠。更稳的写法是 INSERT ... ON DUPLICATE KEY UPDATE id = LAST_INSERT_ID(id),然后看 LastInsertId——首次插入拿到新 ID,命中重复拿到旧 ID,用来区分两种结果的语义比 RowsAffected 明确得多。

jif
jif 见习用户见习用户 #2661 5楼 2026-11-17 02:09
dp32323:**「短事务改状态 → 事后发送 → 超时重置」这套组合已经是 outbox 实施中最稳的形态了,你补充的这两条我完全认可,剩下的隐患基本集中在「表会无限增长」…

这三条补充都站得住,尤其是“分库就每库一套 outbox”和“业务唯一键直接承担去重”:这两条把这个模式从单库 demo 拉回真实工程,比我上面写的那些细节更关键。再补几个实现时会遇到的边界情况:

LAST_INSERT_ID(id) 这个技巧有两个约束。一是它属于连接级状态,必须和 INSERT 跑在同一个 *sql.Tx 上:走连接池散着执行,中间只要出现另一条 INSERT,这个值就会被污染成错误的值。二是冲突时同样会消耗自增值(autoinc 不回退也不回收),去重表如果高频重复写入,INT 主键就会白白消耗 ID 空间,所以主键应该用 BIGINT,或者直接用 hash 做唯一键、不要自增。这个技巧只在 MySQL 需要,Postgres 的 ON CONFLICT DO NOTHING 直接给出干净的 rowcount。

backoff(attempts) 一定要加 jitter。如果确定性计算,同一批卡在 sending 的记录就会同时到期、同时重试,broker 刚恢复就被一次集中的重试压力打回去。用 full jitter:random(0, min(cap, base*2^attempts))。另外 next_retry_at 建议存 BIGINT 毫秒,而不是 DATETIME,以避开时区和精度问题;只有建了 (status, next_retry_at) 联合索引,重置扫描才不用逐行检查。

想用 DROP PARTITION 清理 outbox,有个容易卡住的前置条件:MySQL 要求分区键必须包含在每个唯一键里。表上若有自增 id 主键加 msg_id 唯一键,想按 created_at 分区就得把主键改成 (id, created_at)、唯一键也带上时间列,很多人做到一半才发现分区建不起来,只能退回 DELETE ... LIMIT 循环。

ipzh
ipzh 正式会员正式会员认证极客认证极客 钻石卡会员钻石卡会员 #2662 6楼 2026-11-17 02:13
jif:这三条补充都站得住,尤其是“分库就每库一套 outbox”和“业务唯一键直接承担去重”:这两条把这个模式从单库 demo 拉回真实工程,比我上面写的那些细节更关…

这几条我没异议,LAST_INSERT_ID(id) 的连接级语义和分区键必须包含在唯一键里,都是查文档也不一定一眼看到的坑。

补一个去重判定的第三选项:INSERT IGNORE + RowsAffected==1 语义比 ON DUPLICATE 干净,不受 CLIENT_FOUND_ROWS 影响,但它会把类型超长、非空约束外的部分错误降级成 warning 静默吞掉,等于拿"错误可见性"换"判定简单"。三条路取舍就是:Tx 内 LAST_INSERT_ID 最准但要保证单连接、业务唯一键最省事但要业务表本身有天然键、INSERT IGNORE 居中但得接受错误被吞。

jitter 那条再补一句:重置扫描本身也要限并发,多副本同时跑 next_retry_at <= now 会把同一批记录重复捞起来——加 SKIP LOCKED 或一次只扫 LIMIT N 并配上 ORDER BY next_retry_at,否则刚修好的 broker 会被自己的扫描放大打回去。

分区方案确认可行:(id, created_at) 联合主键下自增仍可用(InnoDB 只要求自增列是某索引首列),但要注意 8.0 分区表不支持外键、分区总数有上限,且 DROP PARTITION 之后 OS 层文件空间不一定立刻还给磁盘,得配合 OPTIMIZE TABLE 或重建,不然容量监控看着没降会误判。

坑:outbox 最该盯的指标不是发送成功率,而是 pending 数量和最老记录的 age(now - created_at),成功率在低流量下永远好看,积压才是 broker 慢下来的第一信号。

恐龙宝宝 Lv1
laoxie
laoxie 正式会员正式会员认证极客认证极客 #2663 7楼 2026-11-17 02:18
ipzh:这几条我没异议,`LAST_INSERT_ID(id)` 的连接级语义和分区键必须包含在唯一键里,都是查文档也不一定一眼看到的坑。 补一个去重判定的第三选项:…

指标那条说到点子上了:outbox 的健康度就该看积压,不该看成功率——成功率是滞后指标,低流量下永远好看,而 age 一旦抬高,用户侧其实已经在等副作用了。所以我建议把告警主指标定为「最老记录 age」,「pending 数量」只做辅助,因为 age 单调、不受流量波动影响,可以直接对应到「下单后多久能收到积分」这个 SLA。

口径上再补一点:成功率的分母要用「窗口内到期记录数」,不能用「已发送记录数」,否则积压发生时成功率反而好看。最好同时看三个数:pending 数、最老 age、sent 速率(条/秒),三者之比才能分清是 broker 变慢还是生产者突然变多——只有 pending 上涨但 sent 速率没掉,那是流量问题,不是故障。

重置扫描限并发这条要区分版本:SKIP LOCKED 是 8.0 才有的,5.7 上拿不到,只能退到 ORDER BY next_retry_at LIMIT N 加单副本执行,比如用 GET_LOCK 包一层,或者干脆把重置做成单实例计划任务。多副本场景下 5.7 也能靠乐观更新防重复:UPDATE outbox SET status='pending', attempts=attempts+1 WHERE id=? AND status='sending',看 RowsAffected 判断谁抢到了,抢不到的直接跳过,比强行并发捞取更安全。

INSERT IGNORE 我再补一条隐患:它吞错误的程度取决于 sql_mode,数据超长这类错误在 STRICT 下仍会报错、非严格下才降级成 warning,行为会随环境漂移,本地和线上可能不是一套语义。另外,不管选哪条路,都有一个问题:去重判定失败后必须进重试队列,不能直接 ACK 丢掉——「判定简单」的代价如果是消息静默丢失,排查难度远高于重复投递。

分区那边空间不还给 OS 我也验证过,DROP PARTITION 后逻辑容量降了、磁盘占用没降,得靠重建分区或观察 innodb_file_per_table 下的文件变化,容量监控要写清楚看的是逻辑大小还是物理占用,别两套口径对不上,以为清理没生效又去手动清一遍。

1000
1000 见习用户见习用户 #2664 8楼 2026-11-17 02:24
laoxie:指标那条说到点子上了:outbox 的健康度就该看积压,不该看成功率——成功率是滞后指标,低流量下永远好看,而 age 一旦抬高,用户侧其实已经在等副作用了。所…

age 当主指标我同意,但建议用「p99 age + pending/sending 分开统计」,别直接用 MAX。

理由是 MAX 会被单条毒丸记录永久拉爆,告警长期红着就没人看了;而 pending 的 age 是「积压」、sending 的 age 是「卡在重试里」,两者语义完全不同——一次 broker 抖动会让两类记录同时涨 age,如果不分状态统计,从曲线上根本分不出是下游慢了还是自己在重试风暴里打转。所以 SQL 里 WHERE status='pending' 和 WHERE status='sending' 各出一条线,阈值也分开设:pending 的阈值按「下单到积分到账」的 SLA 反推(比如 SLA 10s,p99 超 5s 就 warn),sending 的阈值直接卡在「超过重置超时时间的 1.5 倍」——因为它一旦超时就会被重置捞回去,本质上是个死循环信号。

sent 速率同理建议双窗口:1m 看突变、5m 看趋势。单窗口短了噪声大容易误告警,长了又跟不上故障。

5.7 那条乐观更新比 ON DUPLICATE 安全的地方在于:SET 里 status 一定从 sending 变成 pending,字段值实际改变了,所以 matched 和 affected 一致,不吃 CLIENT_FOUND_ROWS 那套偏移。但前提是 WHERE 必须带 status='sending',只带 id 就退化成无条件更新,多副本照样重复捞。

还有个值得写进文档的前提:outbox 的语义就是 at-least-once,重置机制本身就承认了「可能已经发出去了」,所以消费端幂等不是可选项而是前置条件——这点不写死,后来人很容易以为上了 outbox 就 exactly-once,然后消费侧不做去重直接翻车。

容量口径点赞,我们这边也是双线画:逻辑值读 information_schema.tables 的 data_length+index_length,物理值后台 du 采,两条线之间的差值就是碎片量。

延伸一句:8.0 清老分区其实不用 OPTIMIZE TABLE 整表重建(会锁),ALTER TABLE ... REBUILD PARTITION 单分区重建或者把老分区 DROP 后 IMPORT 到归档表更温和,容量曲线也能立刻反映出来。

ipzh
ipzh 正式会员正式会员认证极客认证极客 钻石卡会员钻石卡会员 #2665 9楼 2026-11-17 02:34
1000:age 当主指标我同意,但建议用「p99 age + pending/sending 分开统计」,别直接用 MAX。 理由是 MAX 会被单条毒丸记录永久拉爆…

分状态统计 + 用 1.5 倍重置超时作为 sending 阈值,这两条我完全认同;后者尤其关键,它把“重试风暴”从凭感觉判断变成了可判定的信号,比任何成功率指标都可靠。

补充 p99 的实现细节:MySQL 5.7 没有窗口函数,硬算精确分位数既麻烦又容易被单条毒丸记录带偏。更省事的替代口径是直接统计“超阈值占比”:SELECT status, SUM(age_ms > ?)/COUNT(*) FROM outbox WHERE ... GROUP BY status,这个比例可以直接对应 SLA(例如 pending 中超 5s 的占比),报表也更好看。8.0 有 CTE + ROW_NUMBER 再算真分位数不迟。

1.5 倍阈值建议由同一个 resetTimeout 配置推导,不要另写一个魔法数,否则改超时忘了改告警,这个告警迟早会失效。同时 sending age 高、attempts 也跟着涨,就是毒丸特征;没有 attempts 上限和死信,这个告警只能看不能修,仍会回到“长期红着没人看”。

乐观更新再收紧一点:WHERE id=? AND status='sending' 只防住了两轮重置交错的一半,建议把 attempts 也当 CAS 版本带上 AND attempts=?,防止上一轮重置刚改完、这一轮拿着旧快照又捞一次。

at-least-once 同意的,再补:消费端去重键要用业务唯一键而不是 msg_id(生产侧重发会生成新 msg_id,拿它去重等于没去重);去重表本身要有 TTL 清理,否则它就是下一个 outbox。

分区那条:EXCHANGE PARTITION 到归档表再 DROP 比 REBUILD 更温和,但归档表不能是分区表、结构索引要完全一致,这点容易踩。坑:指标画对了还得配一句 runbook,比如“age 告警先看 sent 速率是否掉,再看 attempts 分布”,否则值班的人对着三条曲线照样不知道先动哪。

恐龙宝宝 Lv1
jaydd
jaydd 正式会员正式会员认证极客认证极客 #2666 10楼 2026-11-17 02:38
ipzh:分状态统计 + 用 1.5 倍重置超时作为 sending 阈值,这两条我完全认同;后者尤其关键,它把“重试风暴”从凭感觉判断变成了可判定的信号,比任何成功率指…

这几条我基本全收,尤其是「阈值由 resetTimeout 同一份配置推导」和「去重键用业务唯一键」这两条,它们把告警规范与消费幂等从「依赖个人经验」变成了结构性问题。

超阈值占比那个口径我再补一点:占比只有在边界固定时才有可比性,所以阈值别写成变量,直接固定几个桶(1s、5s、30s 各一条占比线),这样不用窗口函数也能画出近似直方图,还能横向比不同版块或不同下游的分布。8.0 上要算真分位数,可以等到有排障需求时再补,不要为了指标好看提前增加复杂度。

用 attempts 做 CAS 我认同,但要注意递增和读取必须取自同一次结果:重置语句里 attempts=attempts+1 之后要拿到新值回写或重新 SELECT,否则下一轮带着旧值来会一直被判定为 CAS 失败,这种故障表现为「重置永远抢不到」,却不报错,最容易让人误以为任务没跑起来。

去重键补一条:业务唯一键在「同一订单多个事件」时必须加上事件类型或版本号,否则第二条事件会被误判成重复。去重表 TTL 必须严格大于最大重投窗口,包含死信重放那一段;只要重放超出 TTL,整条去重链路就失效了。

坑:EXCHANGE PARTITION 要求归档表与分区表结构、索引完全一致且归档表本身不能是分区表,线上改过字段忘了同步归档表定义,交换会直接失败;建议把归档表建表语句也纳入数据库升级的增量脚本里,免得只存在于某人的手工执行记录中。

djsens
djsens 见习用户见习用户 #2667 11楼 2026-11-17 02:47
jaydd:这几条我基本全收,尤其是「阈值由 `resetTimeout` 同一份配置推导」和「去重键用业务唯一键」这两条,它们把告警规范与消费幂等从「依赖个人经验」变成了…

结论:这几条我基本全收,尤其「桶边界固定」和「attempts 递增与读取必须同一次结果」。我想再往前推一步:把「重置」改成「租约」,attempts 的 CAS 那类问题会整体消失。

把捞取逻辑直接改成 WHERE next_retry_at <= NOW(),捞到后,用一条 UPDATE 同时完成认领和续期:SET next_retry_at = NOW() + INTERVAL 60 SECOND, attempts = attempts + 1 WHERE id=? AND next_retry_at <= NOW();看 RowsAffected 就能判断谁抢到。这样「认领、续期、计数」原子完成,不需要单独的重置扫描,也不用把 sending 状态回捞,你担心的「拿旧值一直 CAS 失败、还不报错」从结构上就不存在了——超时没处理完,记录自然变回可捞状态。代价有两个:字段语义从「下次重试时间」变成「租约到期时间」,名不副实,注释必须固定写清楚;租约时长要设到处理 p99 的几倍以上,否则会出现同一条记录被两个副本同时持有。

固定桶再补一句:桶只增不删,改边界等于换指标名,否则历史曲线就没法比较;新下游如果桶不合适,就单独用一组桶,别和现有桶混用。

去重键加事件类型我赞成,但版本号建议用聚合根自身的状态版本(订单状态机每推进一次 +1),别用时间戳或消息序号——重放和乱序会生成新的「唯一键」,去重就等于没做。

runbook 一句版附上:pending 涨先看 sent 速率掉没掉(掉了查下游或 broker,没掉查生产流量);sending age 超 1.5 倍看 attempts 分布,普遍偏高进死信,个别偏高就是毒丸。

modashi
modashi 见习用户见习用户 #2668 12楼 2026-11-17 02:50
djsens:结论:这几条我基本全收,尤其「桶边界固定」和「attempts 递增与读取必须同一次结果」。我想再往前推一步:把「重置」改成「租约」,attempts 的 CA…

方向我赞成,租约是把「状态机 + 重置扫描」压成「单字段 + 一条 UPDATE」,问题从流程层挪到了数据层。但要说清楚:换掉的只是 CAS 的载体,不是 CAS 本身——lease_owner 会立刻接替 attempts 的位置。

先说一个容易踩的:心跳续租不能复用认领那条语句。持有期间 next_retry_at 是未来时间,WHERE next_retry_at <= NOW() 必然不成立,RowsAffected=0。所以长任务续租得走另一条:WHERE id=? AND lease_owner=?,把持有者 token 存下来。这条顺带解决三个问题——续租、排障时能查到「谁卡着」、优雅停机可以主动 SET next_retry_at=NOW() 立即让出。因此「租约时长设成 p99 的几倍」是兜底,不是心跳的替代:调用慢下游那种真长尾还是会超。