AI时代下的项目维护

如今,一个聪明的 AI 模型,其编码水平在我看来,已经超过了包括我在内的大部分程序员。我想从一个真正用 AI 干活的人的角度,聊聊 AI 现在到底有多强。

这次,我想分享一个在开发自己的开源项目 Cache-cat 时遇到的问题。整个过程使用的是 GPT 6 Astra ultra 模型,而这个看起来很小的任务,让我同时看到了 AI 的聪明,以及它在工程决策上的问题。

image.png

一条看起来很简单的命令

我正在为 Cache-cat 实现基于 Raft 的 Redis 协议支持,需要适配 SPOP 命令,也就是从集合中随机弹出一个成员。这里讨论的是底层使用哈希表存储的情况。[1]

我让 AI 直接去适配这个命令。一开始并没有多想,和大部分开发者一样,觉得这件事没什么难度。但实际上,要让这条命令在 Raft 状态机中正确执行,并没有那么简单。

Raft 负责让多个节点对日志及其顺序达成一致,状态机则需要按照相同的顺序,执行这些已经提交的操作,并得到相同的结果。[2]

比如,两台机器上的初始值都是 0,各自应用同一条已经提交的 +1 日志,最后的值就都应该是 1。

这要求各个节点参与状态转移的状态是一致的,执行操作的方式也必须是确定的。

那么,两个存着相同成员的 HashMap,就能满足这个要求吗?

如果两边使用相同的哈希种子,相同的实现,所有插入、修改和扩容过程也都保持一致,那么它们的内部排列有可能保持一致。但 Raft 中还有快照:当一个节点落后太多时,可以直接安装快照,恢复到某个已经提交的状态,而不必从头重放全部日志。[2]

问题就出在这里。

以链式哈希表为例,我们插入了 A 和 B,两个元素发生哈希冲突,被放进同一个桶里。生成快照时,可能只是逐条保存成员,记录这个集合里有 A 和 B,却没有保存桶内的链表顺序。

恢复之后,两边的逻辑内容相同,内部排列却可能不同。如果随机选择依赖遍历顺序,即使使用同一个随机数,也可能选出不同的元素。

对比项节点 A节点 B(从快照恢复)
集合内容A、BA、B
某个桶的链表顺序A → BB → A
按遍历顺序选择第 0 个成员AB
弹出后的剩余成员BA

这里并不是说,Raft 要求各节点的内存布局完全相同。真正的问题是:当内部排列参与了随机选择,它就成了影响状态转移的一部分。 只保证集合里有哪些成员相同,已经不够了。

Redis 是怎么处理的?

Redis 的主从复制,可以先在主节点上确定弹出哪个成员,再把确定性的删除操作传播给从节点。

例如,不带 count 的 SPOP,在 Redis 源码中会被改写成删除指定成员的 SREM 操作,用于复制和 AOF。这样,从节点就不需要重新做一次随机选择。[3]

这里需要区分一下:Raft 也可以采用类似思路,由 Leader 先确定要删除的成员,再将“删除这个成员”的操作写入日志,并在提交后应用。Raft 要求的是日志中的状态机操作可以确定性地执行,并没有要求日志必须原样保存客户端命令。

而我这里采用的方式,是把 SPOP 这样的命令交给状态机执行,让各节点根据相同的日志输入,自己算出相同的选择。

方式如何处理随机选择
Redis 的这条复制路径主节点先选中成员,再传播删除指定成员的操作
Cache-cat 这里的实现方式各节点执行相同命令,用相同输入算出相同的选择

因此,在这个实现选择下,随机操作本身就必须变得可复现。

AI 自己发现并解决了问题

让我惊讶的是,AI 自己发现了这个问题,并直接用排序解决了它。

既然哈希表的遍历顺序不可靠,那就先把成员按照确定的规则排序。这样,无论节点之前经历过什么样的快照恢复,只要集合内容相同,排序之后的视图就是一致的。

整个过程没有我的额外干涉。

但是,排序之后,随机数又从哪里来呢?如果每个节点都调用自己的随机数生成器,最后还是会选出不同的成员。

我之前分享过,项目中的每条日志都会携带一个时间戳,作为逻辑时钟,让 Leader 和 Follower 实现确定性的过期处理。

AI 居然注意到了这套已有机制,并直接利用日志里的逻辑时钟,按照相同的算法生成可复现的伪随机数。

这样一来,既不需要为了这个命令在提交日志前额外生成并记录随机数,也不需要增加新的日志字段。它复用了项目里已经存在的信息,做了一次几乎“免费”的优化。

至此,在没有额外提示的情况下,AI 完成了几件事:

  1. 发现随机命令在 Raft 状态机中的一致性问题。
  2. 发现快照恢复后,哈希表内部排列可能不同。
  3. 通过排序,让各节点得到一致的候选视图。
  4. 复用已有逻辑时钟,让随机选择也保持一致。

用 Raft 适配 Redis 协议,再结合项目里已有的逻辑时钟,至少不是一个简单的、孤立的代码补全任务。我不知道训练集中有没有相似案例,但它确实把这些约束联系起来了。

看起来,一切都是那么合理。

显然,事情还没有结束

如果数据规模很小,排序当然可以接受。但如果集合里的数据已经超过 1 GB,成员数量又很多,而且需要频繁执行 SPOP,这个消耗就很难接受了。

即便只弹出一个元素,也要先对整个集合排序,把这一步的时间复杂度抬到了 O(n log n)。如果还需要先收集所有成员或成员引用,也会引入 O(n) 的临时空间。这里的 n,指的是集合中的成员数量。

更让我在意的是,AI 为了完成这个命令,引入了这么明显的性能取舍,却没有主动向我报告。

如果把我看作架构师,把 AI 看作干活的小弟,那么这个小弟在这件事上是不称职的。遇到这样的开销,理论上应该先把问题和代价讲清楚,再讨论接下来该怎么做。

这正是我在使用 AI 时担心的问题:遇到一个有坑的小任务,它找到了一个局部可行的解,快速完成了功能,却没有把这个决定放回整个系统里评估。

这种现象也让我想到强化学习中的 Reward hacking(奖励黑客)。

简单来说,强化学习会用奖励信号引导模型的行为。但奖励只是对真实目标的近似。如果评价主要关注“功能是否完成”“测试是否通过”,而性能预算、架构约束没有被充分纳入,模型就可能倾向于交付一个眼前能工作的答案。奖励指标和真实目标之间的偏差,是 Reward hacking 相关研究关注的问题。4

一个经典例子是赛艇游戏:人类希望 AI 尽快完成比赛,但训练奖励来自沿途目标的得分。结果 AI 学会了在一小片区域反复绕圈刷分,而不是跑完全程。它提高了分数,却偏离了人类真正想要的结果。[4]

当然,仅凭这次排序方案,不能断定模型发生了 Reward hacking,更不能直接判断它的训练原因。这里更明确的问题是:它完成了功能,却没有充分评估和沟通代价。

那么,如果站在架构师的角度,这个问题还可以怎么解决?

换一种 HashMap 的存储方式

以 Redis 的 dict 所采用的链式哈希结构为例,可以把寻址过程简化成下面这样。实际实现还有其他细节,这里只看桶和冲突链。[6]

flowchart TD
    H["hash(key) & mask"] --> B["buckets[3]:ptr = 0xA000"]
    B --> A["地址 0xA000:key = A,next = 0xD000"]
    A --> D["地址 0xD000:key = B,next = NULL"]

一个数组存放哈希桶,每个桶指向一条链表,链表中的节点再存放元素。节点分别分配,内存位置可以相距很远。

但我们也可以换一种组织方式:不再让链表节点通过独立分配的地址连接,而是把条目统一放进一个可以扩缩容的连续数组里。每次插入新元素,都放到数组末尾。

桶里存放的也不再是节点指针,而是数组下标;条目中的 next,同样改成下标。

数组位置keyvaluenext
entries[0]B…EMPTY
entries[1]C…EMPTY
entries[2]A…0
flowchart TD
    H["hash(key) & mask"] --> B["buckets[3]:head = 2"]
    B --> E2
    subgraph Entries["entries 连续数组"]
        E0["entries[0]:B,next = EMPTY"]
        E1["entries[1]:C,next = EMPTY"]
        E2["entries[2]:A,next = 0"]
    end
    E2 --> E0

这个桶的访问顺序就是 entries[2] → entries[0] → 结束。

访问一个元素时,整体过程仍然和普通链式哈希表类似,只是沿着冲突链前进时,从指针寻址变成了数组下标寻址。

删除元素怎么办?

假设数组里有 A、B、C、D,分布在两个桶中。现在要删除 C。

位置或结构删除前删除后
entries[0]AA
entries[1]BB
entries[2]CD
entries[3]D已移除
桶 X0(A) → 2(C) → 结束0(A) → 结束
桶 Y3(D) → 1(B) → 结束2(D) → 1(B) → 结束

先把 C 从所在桶的冲突链里摘掉,再把数组末尾的 D 移到 C 留下的位置,最后缩短数组。这样,数组中间就不会留下空洞。

当然,D 的下标从 3 变成了 2,对应的桶索引也需要修复。

这里可以使用 D 已缓存的哈希值计算桶位置,不需要重新对 key 做哈希。如果 D 是桶头,就修改桶的 head;如果 D 在冲突链中间,就遍历对应的链,找到前驱,修改它的 next。

在哈希分布正常的情况下,这些桶内操作具有预期常数时间的开销,不需要为了弹出一个成员而排序整个集合。

把确定性保存在数组里

可以想象,只要所有节点执行相同的插入和删除操作,采用相同的追加、交换和删除规则,这个数组的逻辑顺序就能保持一致。

生成快照时,我们保存的是这个有序数组,而不是一组没有顺序的条目。恢复时也必须保留数组顺序,再据此重建哈希索引。

这样,无论各节点上层的哈希桶如何排布,底层数组中“第几个位置是什么元素”都是确定的。使用相同的伪随机算法和日志输入,就可以对相同下标进行采样,选中相同的成员。

这个方法保留了链式哈希表的基本查找路径,同时避免了每次随机选择前的全量排序。它也有自己的代价,比如缓存哈希值、维护索引和数组容量都需要空间,扩容还会产生搬移成本。但连续存放条目,也可能减少碎片,并带来更好的局部性。至于实际的内存和性能收益,还要看条目布局和工作负载。

那么,从全局来看,这个改动值得吗?

我的答案是值得。因为 Redis 协议里不只有 SPOP,还有 SRANDMEMBER、HRANDFIELD 等随机命令,都可以从这样的结构中受益。

为了一个命令在每次执行时排序,和为了多种随机操作调整底层结构,是两个不同层面的决定。后者的改动范围更大,但在我这个项目里,我认为它更值得做。

最后的反转

我相信,大家在开发时也经常遇到类似的问题:把一个看起来简单、实际上有坑的小任务交给 AI,它通过各种办法完成了功能,得到了一个局部可行的解。但站在整个系统的角度看,这个决定可能有很大的问题。

提示词或许能约束一部分行为,但我仍然希望,AI 在遇到明显的性能和架构取舍时,能主动把影响讲清楚。即使把任务交给一个经验不多的初级程序员,我也会期待他先和同事评估一下影响范围。

那么,可能有人要问:你自己又是怎么想出这个有意思的 HashMap 结构的?

哦,当然也是让 AI 帮我想的。

如果你在 Vibe Coding 中也遇到过类似的趣事,欢迎在评论区分享。

参考资料

  1. Redis:SPOP 命令文档。说明命令操作的是集合,以及随机弹出成员的语义。
  2. Diego Ongaro、John Ousterhout:In Search of an Understandable Consensus Algorithm(扩展版)。第 2 节介绍复制状态机,第 7 节介绍快照与日志压缩。
  3. Redis 源码:src/t_set.c。可搜索 spopCommand、rewriteClientCommandVector 和 shared.srem,查看随机弹出后传播确定性删除操作的实现。
  4. OpenAI:Faulty reward functions in the wild。介绍奖励设计与真实目标不一致时,智能体可能出现的行为,包括赛艇游戏中绕圈刷分的例子。
  5. Anthropic:Sycophancy to subterfuge: Investigating reward tampering in language models。介绍语言模型中的 specification gaming,以及相关实验的条件和限制。
  6. Redis 源码:src/dict.c。可查看 dictEntry、桶索引以及冲突链的实现。
Last modification:November 17, 2026
如果觉得我的文章对你有用,请随意赞赏