为什么我把 Python 消费者逐步迁到独立的 Go 项目

罗兴波发布于 更新于
文章摘要

从手动关键词匹配引发的 ES 高负载出发,记录选择独立 Go 消费者的四个理由,并结合 Java、C++、Rust 等候选的取舍,以及上线后的进程资源和匹配阶段耗时观察,说明这次渐进迁移的决策与验证。

我把部分 Python 消费者逐步迁入独立的 Go 项目,主要考虑进程内共享规则、多核计算、常驻资源消耗和后续维护成本。

这次重构的起点,是原有系统已经暴露出的性能问题。

手动关键词功能最初按机构逐步开放。随着覆盖范围扩大,Elasticsearch(下文简称 ES)的检索负载明显升高,接口响应与消费进度受到影响。与此同时,我也观察到原有 Python 消费者的常驻内存开销偏高。

排查关键词匹配链路后,我准备调整算法,将逐条请求 ES 的规则匹配,改为消费者本地的内存计算。

新的处理方式需要消费者直接承担文本扫描、关键词匹配和规则判断。同一机构的规则会被大量文章反复使用,我希望在共享规则的同时,利用多核处理这些计算。

结合当前 Python 项目的运行方式、依赖和内存占用,我最终选择了 Go,并建立了独立的 Go 消费者项目。

决策的先后关系很明确。先发现旧系统的问题,再评估本地匹配算法的运行需求,随后选择 Go,最后实施改造并观察运行结果。

一、共享一份规则,并行处理多篇文章

一批机构规则加载后,会被反复用于不同文章。文章之间可以独立处理,使用的规则大部分相同。

我希望让一份规则保存在进程内,多个工作任务读取这份规则,并行处理不同文章。

在当时使用的常规 CPython 3.11 中,受 GIL 限制,多个线程通常只能轮流执行 Python 计算代码。针对纯 Python 的 CPU 计算,多进程是一条常见路线。释放 GIL 的原生扩展则有自己的运行条件,需要具体分析。Python 线程说明

独立启动多个进程时,每个进程通常会加载自己的解释器、业务模块和规则对象。规则更新后,各个进程还需要获取新版本。进程数量增加,常驻状态、连接和版本管理成本也可能随之增加。

通过共享内存、进程间通信或专门的数据布局,可以进一步改善这些问题。对于包含规则对象、自动机、倒排关系和动态更新状态的数据,这些方案还需要额外设计和维护。

Go 可以在同一个进程内,让多个 goroutine 读取规则快照,并利用多个 CPU 核心处理不同文章。

后续落地的实现中,机构规则以快照形式保存。处理任务取得一个已经发布的版本,规则更新时先构建并校验新快照,再替换当前引用。在途任务继续持有自己的快照,后续任务读取新版本。

这个方式比较符合我的需求。规则的构建和发布集中管理,文章处理任务复用已经准备好的结构。

共享范围仍然是单个进程。部署多个 Go 副本时,每个副本都有自己的规则和运行状态,副本数量依然会影响总体内存。进程内共享也需要保证规则发布后的只读约定和并发安全。

二、同一条消费链路中,计算与 I/O 都需要安排好

消费者除了文本匹配,还要等待 Kafka、数据库、ES 和其他远端服务。

Python 的 asyncio 很适合组织异步 I/O。任务等待网络响应时,通过 await 让出执行机会,事件循环便可以继续处理其他任务。

持续执行同步计算则会占用事件循环线程。某个协程进入文本扫描或规则计算后,如果长时间没有让出执行机会,同一循环中的其他任务就需要等待。同步阻塞接口也会产生类似影响。asyncio 开发说明

原项目已经做过异步化和背压治理。评估把匹配工作从 ES 转移到消费者时,我还需要考虑新增计算应该放在哪里,以及它会怎样影响其他任务。

Go 让我能够用比较直接的方式组织这条链路。任务等待网络时可以挂起,可独立执行的计算可以由多个 goroutine 并行处理。Go 并发说明

实际实现仍然需要控制工作任务数量、队列长度和下游并发。可用 CPU、连接池容量、ES 写入能力等因素,都会限制整个消费者的处理速度。

对我来说,采用 Go 后,计算和 I/O 可以在一套较直接的并发模型中配合,资源上限也更容易集中管理。

三、每天重复执行的操作,值得关注单次成本

一次文本遍历、一次规则判断、一次对象转换,单独看可能都很小。

文章消费持续运行,同类操作每天可能重复几百万次。单次执行成本和临时对象分配,累积后就会影响 CPU 与内存。

因此,评估本地匹配方案时,我也希望降低这些重复工作的开销。

实际效率由算法、数据结构、库和数据访问方式共同决定。并行处理更多文章,可以提高整体吞吐。减少单篇文章的计算工作量,则会降低每个任务的成本。这两个方向需要分别观察。

同时,整条链路还包含网络等待和结果写入。计算部分优化之后,下一阶段的主要耗时可能转移到 I/O。

我选择 Go,是希望为这些持续执行的本地计算提供合适的运行方式。算法调整带来的收益,则在后续实现中单独验证。

四、独立项目让我重新整理消费者的依赖

原 Python 项目同时包含 API、消费者和大量公共业务模块。

共享代码在早期很方便。随着功能增加,一个公共模块可能继续导入另一个服务,再间接带入消费者用不到的库。如果初始化也发生在导入阶段,启动消费者就会承担额外的加载成本。

我关心的是消费者实际经过的导入链,以及启动后创建和保留了哪些对象。依赖清单、模块加载和运行时对象,是几个需要分别检查的位置。

原项目已经做过部分懒加载优化,公共模块之间的依赖关系仍需要持续维护。

拆成独立项目,给了我一次重新整理边界的机会。

  • 保留消费任务实际需要的客户端。
  • 按消费者用途加载配置和规则。
  • 明确迁移哪些业务逻辑。
  • 确定哪些能力继续由原服务提供。
  • 独立管理构建、发布和资源配置。

这部分收益来自项目边界的调整。独立 Python 项目同样可以裁剪依赖。我最终采用 Go,还结合了前面的共享规则、多核计算和混合负载需求。

五、为什么最终选择 Go

当时,我主要权衡了 Java、C++ 和 Rust。它们都有能力实现这类消费者,我更关注各自落到当前项目后,需要承担哪些成本。

Java 的并发能力满足需求,我更在意常驻资源

Java 可以通过多线程并行执行计算,并共享同一个堆中的规则对象。使用不可变快照和原子引用发布新版本,也可以组织相近的规则更新方式。

它的后端生态和客户端选择很丰富。计算任务可以采用受控线程池,大量等待型任务还可以评估虚拟线程。虚拟线程主要面向大量阻塞等待的场景,长时间 CPU 计算仍需考虑核心数量和调度资源。Java 虚拟线程说明

我当时对 Java 的主要顾虑,是消费者的常驻内存和启动开销。

服务器上需要部署多个机构的消费者。单个实例的运行成本,会随实例数量累积。对这种长期运行的服务,常驻内存持续影响服务器容量,启动时间则主要影响部署、重启和故障恢复。

我当时的目标,是控制多个消费者叠加后的资源占用,并让部署和维护保持简单。

评估 Java 时,还需要结合实际采用的框架、客户端、线程数量和 JVM 配置。轻量消费者可以直接调用 SDK。堆、类元数据、代码缓存、线程栈和客户端缓冲区,都可能进入最终的进程资源成本。

Java 也有 GraalVM Native Image 等原生构建路线,可以改善启动和资源占用,同时需要核对反射、资源访问及原生依赖等兼容性。GraalVM Native Image

在这次迁移中,我更希望尽快获得一个运行轻便、依赖集中、便于持续调整的消费者,因此倾向于 Go。这里记录的是当时的选择权重。Java 的同负载实现和资源对照,仍需要专门测量。

C++ 提供更细的控制,也需要相应的工程投入

C++ 可以用多线程共享规则,在数据布局、内存分配和热点算法上做细致优化。如果已有成熟的原生算法库,也有直接复用的机会。

现代 C++ 的 RAII、智能指针和容器能够帮助管理资源。共享规则快照也可以通过明确的所有权和生命周期安排实现。C++ Core Guidelines

对当前项目,我需要同时处理 Kafka 消费、数据库访问、ES 写入、规则更新和失败恢复。采用 C++ 后,还要把对象生命周期、并发访问、原生依赖、构建链接和故障排查一起维护好。

我认为这会增加当前项目的实现与审查成本。

当时消费链路中仍有大量 I/O,CPU 优化的紧迫程度有限。我更希望先完成算法调整与业务迁移,让结果一致性和故障恢复稳定下来,再根据实际运行情况决定是否继续深入优化。

Rust 的能力很合适,复杂度需要结合项目衡量

Rust 也能够满足共享规则和多核计算的需求。

例如,通过 Arc<RuleSet>,多个任务可以持有同一份规则快照。克隆 Arc 会增加共享引用计数,规则本体可以保持一份。线程安全约束仍需要由底层类型和同步方式满足。Rust Arc 文档

它还提供所有权和类型层面的约束,有助于在编译阶段发现一部分内存与并发问题。对于重视资源控制的系统,这些能力很有价值。

落到这条消费链路,我还需要设计所有权怎样穿过消息处理、规则快照和后台任务,以及网络等待与计算任务怎样组合。

使用 Tokio 时,长时间计算通常需要安排到受限的计算执行资源中。可以采用专门的计算线程池,也可以使用适当限流的 spawn_blocking 等方式。Tokio 计算任务说明

这些方案都可行。对我当前的项目来说,我更愿意接受 Go 的运行时和 GC 成本,换取较直接的并发组织,以及我认为更合适的日常修改负担。

C++ 和 Rust 都有进一步控制内存、优化热点的空间。具体速度差异,需要结合相同算法、数据和实现测量。当前阶段,我给工程投入和持续维护较高的权重。

其他候选当时考虑得较少

Node.js、Ruby、PHP、C# 当时没有进入我的深入评估范围。

整理这次经历时,也可以补充它们在这个场景下的运行方式。

Node.js 适合组织网络 I/O,CPU 工作可以交给 worker threads。对于当前这类复杂规则结构,需要进一步衡量 worker 池、规则复制、消息传递和共享内存布局的成本。Node.js Worker threads

Ruby 的 Ractor 提供并行执行能力,对象共享具有相应约束。若采用这条路线,需要检查规则结构的共享方式和客户端兼容性。Ruby Ractor

PHP 可以通过 CLI 构建常驻任务,也有 parallel 等扩展提供并行执行能力。具体方案需要选择运行模式,安排各执行环境的初始化和规则状态。PHP CLI、PHP parallel Runtime

C#/.NET 能够组合异步 I/O、多线程计算和进程内规则共享,Native AOT 也提供了改善启动与内存的部署路线。从技术能力上看,它同样是合理候选。C# 异步编程、.NET Native AOT

这部分属于本次整理时补充的分析。当时我已经决定推进 Go,接下来更需要把时间投入算法实现、结果一致性和故障恢复验证。

六、选择 Go 后,我仍然需要管理它的运行成本

Go 有 GC,内存分配和对象存活时间会影响回收成本。规则快照更新时,新旧版本也可能在一段时间内同时存活。

因此,规则规模、更新频率、在途任务和临时对象,仍然需要观测与控制。Go GC 指南

并发处理同样需要边界。任务数、队列、连接池、超时和取消要相互配合,避免积压不断转化为内存占用。

构建方面,当前项目采用的 confluent-kafka-go 依赖 cgo 和 librdkafka,需要核对目标平台、链接方式和运行环境。客户端选择会直接影响部署成本。Confluent Go 客户端构建说明

我接受这些成本,因为它们与当前希望实现的消费者结构比较匹配。后续仍要通过运行数据确认,资源配置是否合适。

七、上线后的资源与匹配耗时观察

进程 RSS 的下降

后续迁移中,我观察到手动关键词消费者的单进程 RSS 明显下降,也通过自己开发的性能分析平台查看服务资源变化。

这组消费者内存观察采用单进程 RSS 口径。具体占用会随规则规模、并发数量和消息积压变化,比较前后结果时需要结合各自运行条件。

这组结果发生在迁移之后。语言运行时、实际加载的模块、缓存结构和业务实现同时发生了变化,因此它反映的是这次整体重构后的运行情况。

匹配阶段日志主要显示为 0ms

我也观察了手动关键词消费者的分阶段耗时日志,其中 match_cost_ms 主要显示为 0。

这个字段通过 time.Since() 统计匹配阶段的累计经过时间,再按整毫秒输出。显示为 0 的记录,对应的累计匹配耗时低于 1ms。规则版本变化触发重新匹配时,同一条消息的多次匹配耗时也会累加。

这是日志样例观察,平均值和分位数尚未统计,具体观察窗口和样本量仍待补充。指标的测量口径是匹配阶段经过时间。

整条消息另有 total_duration_ms,结果写入还有成员关系、专题状态更新等分阶段计时。它们可以帮助判断处理时间具体花在什么位置。

在当前规则规模和观察到的负载下,Go 实现的本地匹配已经较快。这个结果也让我更有依据地安排后续优化,将计算、网络访问和结果写入分别观察。

这些都是上线后获得的反馈,用来继续检验之前的选型与实现。

八、AI 辅助让我更容易推进逐步迁移

重写需要重新实现业务,还要核对规则结果、消息字段、失败处理、消费位点和停机行为。旧代码中一些不起眼的分支,可能承载着真实的业务约定。

对我来说,AI 辅助降低了梳理代码、改写基础实现、查阅客户端 API 和补充测试的成本,让一次范围明确的消费者迁移更容易推进。

验证则需要围绕实际业务逐项完成。

  • 相同输入是否得到预期结果。
  • 重复消息是否安全。
  • 规则更新期间是否保持结果一致。
  • 失败后能否恢复。
  • 停机和重平衡时,消费进度是否正确。
  • 实际 CPU、内存和积压是否符合目标。

因此,我采用逐步迁移的方式。现阶段 Go 项目已经包含手动关键词匹配、热榜相关性分发与处理、专题聚类等消费者实现,统一文章消费者的完整迁移仍处于规划阶段。

后续是否继续迁移,会结合实际资源消耗、处理能力、维护成本和故障恢复表现决定。

技术选型确定后,我首先改造了手动关键词消费者,将实时匹配从逐条查询 ES,调整为基于内存规则的本地计算。旧方案的查询次数如何被放大,以及 AC 自动机、倒排关系和布尔表达式怎样配合,放在下一篇展开。《从逐条查询 ES 到本地匹配:手动关键词消费者的算法优化》

记录过程,也留下判断。

← 继续阅读其他文章