扩容消费者后,为什么进程内锁失效了?

罗兴波发布于
文章摘要

单进程消费者可以用 asyncio.Lock 协调同标题、同业务键任务,但扩容为多个容器后,每个进程都有独立内存和锁对象。Kafka 只保证一个分区同一时刻归属组内一个消费者,并不能阻止不同分区上的相同业务对象被不同进程并发处理。本文结合统一文章消费者的标题协调实现与扩容方案评审,分析进程内锁的真实边界,以及分区路由、分布式协调和业务幂等各自应该解决什么问题。

评审统一文章消费者的同标题协调方案时,我们需要同时考虑消费积压与副本数。2026年10月28日的方案记录了进程内协调实现和本地回归,当时处于等待部署阶段。下面结合已有实现,推演几种部署选择的边界。

  • 保持一个消费者副本,进程内的并发协调有效,但消费能力可能不够;
  • 将消费者扩容到多个副本,可以分摊 Kafka partition,却会让原来的进程内锁失去全局约束能力;
  • 不扩容,只把背压水位调大,又只能容纳更多等待消息,不能真正增加处理能力。

推演多副本部署时,很容易把这个问题理解成“扩容后锁失效了”。

进程内锁仍然保护当前进程中的任务。如果从单副本扩容到多副本,各进程会拥有独立的内存和锁对象,原来的进程内协调也就无法覆盖其他副本中的任务。

这也是很多消费者从单副本走向多副本时容易踩到的边界。

一、单进程时,进程内锁是怎么工作的

在我们的统一文章消费者中存在一类典型竞争:两篇标题相同或高度相似的文章,可能同时进入不同 Kafka partition。

近重复判断通常需要先查询已有代表文章。如果两篇文章几乎同时开始处理,就可能出现下面的时序:

文章 A 查询代表文章:未命中
文章 B 查询代表文章:未命中

文章 A 调用模型并登记为代表文章
文章 B 调用模型并登记为另一篇代表文章

问题发生在第一篇文章完成分析并登记代表结果以前。第二篇文章查询不到尚未登记的结果,于是也执行了完整分析。这个时序已在近重复检测已经存在,为什么同标题文章仍会重复分析?中详细展开过。

为缩小这个并发窗口,可以在消费者进程中维护一组标题锁:

title_locks: dict[str, asyncio.Lock] = {}

async def process_article(article):
    title_key = normalize_title(article.title)
    lock = title_locks.setdefault(title_key, asyncio.Lock())

    async with lock:
        # 取得锁后重新执行近重复判断
        duplicate = await find_near_duplicate(article)
        if duplicate is not None:
            return await reuse_result(article, duplicate)

        result = await analyze_article(article)
        await register_representative(article, result)
        return result

在一个进程中,所有协程访问的是同一个 title_locks 字典。相同 title_key 会得到同一个 asyncio.Lock,因此同一时刻最多有一个任务进入关键区。

当前实现比这个例子更完整:

  • 锁键由 topic 和清洗后的标题摘要组成;
  • 同一进程拿到的多个 partition 可以共享同一标题协调器;
  • 被同标题阻塞的消息仍留在原 partition 队列;
  • 等待标题执行权时不占用真正的文章处理名额;
  • 当前持有者完成、失败或取消后,再把执行权交给下一组;
  • partition 被 revoke 后,还需要清理旧 generation 对应的预留状态。

但无论内部调度多完整,它仍然有一个明确前提:所有需要互斥的任务必须位于同一个 Python 进程中。

Python 官方文档把 asyncio.Lock 定义为协程任务之间的互斥原语,并明确说明这些同步原语不是线程安全的。它更不具备跨进程共享能力。Python 3.11 asyncio 同步原语

二、scale 从 1 变成 2 后发生了什么

假设原来只有一个消费者进程:

Consumer A
├── title_locks["某标题"]
├── Partition 0
├── Partition 1
└── Partition 2

三个 partition 中的同标题任务都能看到同一把锁。

将消费者扩容为两个副本后,结构变成:

Consumer A                         Consumer B
├── title_locks["某标题"]          ├── title_locks["某标题"]
├── Partition 0                    ├── Partition 1
└── Partition 2                    └── Partition 3

看起来两边都有一把名为“某标题”的锁,但实际上它们是两个完全不同的 Python 对象:

  • 位于不同进程;
  • 使用不同内存地址;
  • 拥有不同 owner 和等待队列;
  • 互相不知道对方是否已经加锁。

于是可能出现:

Consumer A:成功取得本进程的标题锁
Consumer B:也成功取得本进程的标题锁

从两个进程各自的视角看,这都没有违反锁规则。但从业务视角看,两篇同标题文章已经并发执行。

因此,部署副本数从 1 调整到 2,并不是把同一把锁复制成了两份,而是创建了两套互相独立的协调系统。

三、Kafka 为什么没有自动解决这个问题

Kafka 消费组确实提供了一层重要保证:在传统 consumer group 中,同一个 partition 在同一时刻只会分配给组内一个 consumer。

Kafka 官方文档也明确说明,消费组通过在成员之间分配 partition 来扩展处理能力;例如四个 partition、两个消费者时,每个消费者通常会获得其中两个 partition。KafkaConsumer 4.1 API

但这个保证的对象是 partition,不是业务标题、文章指纹或数据库记录。

假设两篇同标题文章分别位于:

文章 A → Partition 0 → Consumer A
文章 B → Partition 1 → Consumer B

Kafka 可以保证 Partition 0 不会同时交给 Consumer B,也可以保证 Partition 1 不会同时交给 Consumer A,但它不知道这两篇文章在业务上需要互斥。

因此需要区分两个问题:

  • Kafka partition ownership:谁负责读取这个 partition;
  • 业务并发控制:哪些消息不能同时修改同一个业务对象。

只有当生产端使用稳定的业务键分区,并确保需要互斥的消息始终进入同一 partition 时,才能利用 Kafka 的 partition 归属和顺序减少跨进程竞争。

但这也有适用条件:

  • 必须有稳定、准确的业务键;
  • 生产端所有入口都必须采用一致的分区策略;
  • 热点业务键可能形成热分区;
  • partition 数量变化或自定义分区器需要重新评估映射;
  • 标题稍有不同、但业务上仍属同一事件时,标题路由也无法覆盖;
  • Kafka 只能约束消息消费,不能天然保证外部数据库写入 exactly-once。

所以,“按 key 进入同一 partition”是一个很有价值的方案,但不能把它描述成适用于所有业务竞争的万能分布式锁。

四、调大背压水位为什么解决不了

另一个容易想到的办法是:既然不能直接扩容,那就提高消费者的队列高低水位,让单进程一次缓存更多消息。

背压主要控制的是:

  • 什么时候暂停从 Kafka 继续拉取;
  • 内存中最多保留多少待处理消息;
  • 队列降低到什么程度后恢复拉取;
  • 消费速度暂时低于生产速度时,进程能缓冲多少数据。

它解决的是“拉取速度和处理速度不匹配”,不是“两个进程是否共享同一把锁”。

提高背压水位以后:

  • 进程可以提前拉取更多消息;
  • Kafka 控制台上的 lag 可能更快转移到应用内队列;
  • 内存占用可能增加;
  • 消息在进程内等待的时间可能变长;
  • 真正的模型、ES、MySQL 或外部接口处理能力并没有增加。

如果仍然是单进程,锁当然继续有效,但吞吐瓶颈是否缓解取决于进程内部还有没有可利用的并发空间。

如果已经扩容为多进程,提高背压值也不会让两个进程的锁互相可见。

因此,背压值可以作为容量和稳定性参数调整,却不能作为跨进程互斥方案。

五、可以怎么处理

面对这类问题,我通常不会一上来就加分布式锁,而是先判断业务真正需要的保证。

方案一:保持单副本,提高进程内部有限并发

如果一个进程仍然能够支撑目标流量,可以保留单副本,然后调整:

  • 全局最大在途数;
  • 单 partition 并发数;
  • 不同 partition 的调度公平性;
  • 队列高低水位;
  • 慢外部调用的并发上限;
  • 热 partition 的优先级。

这种方式的优点是:

  • 进程内标题锁继续有效;
  • 不引入额外网络协调;
  • 锁状态、任务状态和 partition generation 更容易统一;
  • 排查路径相对简单。

缺点也很明确:

  • 纵向扩展有上限;
  • 进程退出会让全部 partition 重新分配;
  • 单进程内存和连接数压力会持续增加;
  • CPU、模型并发或外部服务吞吐达到上限后,再调队列也没有意义。

这适合当前负载尚未超过单进程能力,只是并发参数和调度方式还没有充分利用的场景。

方案二:使用稳定业务键路由到同一 partition

如果互斥对象可以被可靠地表示为一个稳定键,可以在生产端用它作为 Kafka key:

business_key
    ↓
Kafka partitioner
    ↓
同一个 partition
    ↓
同一个消费组成员

这样,同一业务键的消息在传统消费组模型下会由同一个 consumer 实例负责。

它的优势是:

  • 不需要为每条消息额外请求分布式锁服务;
  • 可以利用 Kafka 的 partition 顺序;
  • 进程内协调仍然有效;
  • 业务键之间仍可并行。

代价是:

  • 热点键会形成热 partition;
  • 路由错误会直接破坏保证;
  • 多个上游必须统一分区策略;
  • 不能解决“不同键最后修改同一个资源”的情况;
  • partition 内如果再次开启乱序并发,仍需维护完成前缀和安全 offset。

对于同一机构、同一订单、同一文章主键等稳定对象,这通常是值得优先评估的方案。对于经过语义判断后才能知道是否相同的文章,它就未必足够。

方案三:引入跨进程协调

当同一业务对象可能落入不同 partition,并且确实不允许并发执行时,就需要让多个进程访问同一个协调状态,例如:

  • Redis 租约锁;
  • 数据库行锁;
  • 数据库 advisory lock;
  • 基于唯一索引的抢占记录;
  • 独立协调服务。

以 Redis 为例,锁至少需要考虑:

  • 获取时使用唯一持有者标识;
  • 设置合理的过期时间;
  • 释放时比较持有者标识,不能直接删除;
  • 长任务是否需要续租;
  • 续租失败后旧任务是否应该停止;
  • 锁过期但旧任务仍在运行时怎么办;
  • Redis 故障时选择失败关闭还是降级并发执行。

Redis 官方的分布式锁说明同样强调互斥、安全释放、锁有效期与故障场景之间的关系。Redis 分布式锁

这里最危险的错误是把“拿到了一个带 TTL 的 Redis key”直接等同于“业务上绝不会并发”。

锁是一段有期限的协调权。任务执行时间超过租约、网络分区或进程暂停,都可能让另一个执行者重新取得锁。对不能容忍旧执行者继续写入的场景,还要评估 fencing token、版本号或写入条件校验。

方案四:让最终写入具备幂等性

即使已经使用分区路由或分布式锁,最终状态仍然应该尽量具备幂等能力。

因为重复执行并不只来自并发:

  • 消费者可能在业务完成后、提交 offset 前退出;
  • partition rebalance 可能带来消息重放;
  • 外部调用超时,但服务端实际已经执行成功;
  • Redis 锁可能过期;
  • 人工补偿任务可能再次投递;
  • 上游本身可能重复发送。

常见的最终防线包括:

  • 业务唯一索引;
  • 幂等消息 ID;
  • 状态机条件更新;
  • compare-and-set;
  • 版本号检查;
  • 结果登记前再次查询;
  • 重复写入返回已有结果,而不是重新创建。

分布式锁主要减少并发尝试,幂等约束负责保证即使重复尝试发生,最终也不会生成两份互相冲突的数据。

这两者不能互相替代。

六、我更倾向于分层解决

对于统一文章消费者这类链路,我更倾向于将问题拆成三层。

第一层是 Kafka 路由:

  • 能确定业务键的消息尽量稳定进入同一 partition;
  • 利用 partition 归属减少跨进程竞争;
  • 接受热点键与并行度之间的取舍。

第二层是消费者内部调度:

  • 每个进程继续保留轻量的进程内协调;
  • 同标题、同业务键在本进程内不重复并发;
  • 等锁不占昂贵的模型处理名额;
  • partition revoke 后清理旧 generation 状态;
  • offset 只按安全完成前缀提交。

第三层是最终状态保护:

  • 代表结果登记、聚类归属或任务创建需要幂等约束;
  • 必要时增加跨进程租约,减少昂贵的重复计算;
  • 写入时再次核对状态或版本;
  • 不把分布式锁当作 exactly-once 保证。

这套分层方式允许我们保留进程内锁的低成本优势,同时承认它的作用域,不要求一把锁承担路由、调度、故障恢复和最终一致性的全部责任。

七、扩容前应该先回答哪些问题

消费者从一个副本扩到多个副本以前,我会先回答下面几个问题:

  1. 当前瓶颈是 Kafka 拉取、CPU、模型调用、数据库还是外部服务?
  2. 单进程内部并发是否已经充分利用?
  3. Topic 有多少 partition,新增副本能否真正获得 partition?
  4. 哪些消息之间存在业务互斥关系?
  5. 这些消息是否已经使用稳定业务键分区?
  6. 竞争只会造成重复计算,还是会写出错误状态?
  7. 最终存储是否具备唯一约束或幂等更新能力?
  8. 如果使用分布式锁,租约过期后旧任务如何处理?
  9. rebalance 时旧 worker 是否还能继续写外部系统?
  10. 扩容后应该观察重复调用率、锁等待、热 partition、提交缺口还是最终重复记录?

只有明确这些问题,才能判断真正需要的是:

  • 调大进程内部并发;
  • 优化背压;
  • 增加 partition;
  • 改进消息路由;
  • 增加消费者副本;
  • 引入分布式协调;
  • 或补齐最终写入幂等。

八、最后的结论

进程内锁没有因为消费者扩容而失效。

它始终只保护创建它的那个进程。单副本时,进程边界恰好等于部署边界,所以看起来像一把全局锁;多副本以后,部署边界扩大了,而锁仍然停留在原来的内存范围内。

Kafka 能保证传统消费组中一个 partition 同一时刻只归属一个 consumer,但它不会理解标题、文章指纹或业务实体之间的互斥关系。

调大背压水位可以改变应用缓存多少消息,却不能把两把独立的进程锁变成同一把锁。

真正可靠的扩容方案,需要同时考虑:

  • 消息如何分区;
  • 进程内部如何有限并发;
  • 跨进程是否需要协调;
  • 最终写入是否幂等;
  • rebalance 和重放发生后如何恢复。

锁只是其中一层。消费者能不能安全扩容,最终取决于整条链路是否把协调范围和部署范围对齐。

记录过程,也留下判断。

← 继续阅读其他文章