返回资讯中心
外部精选
软件工程
#开发者实时流

Postgres 队列 LIMIT 10 为何返回 500 条任务

来源标题:When LIMIT 10 Means 500

一个按每次 10 条租用任务的 Postgres 队列实际出现了 500 条任务被同时取走的情况,运维人员发现单个阶段有 460 个任务处于执行中。该队列由 fetcher goroutine 和每副本 10 个 worker 组成、每阶段两个副本,此前已稳定运行数月,仪表盘和告警均未反映异常。

Hacker News 最新ykgoon2026/11/12 · 6 天前30 分钟阅读

以下正文由 AI 翻译自 Hacker News 最新(原文版权归原站所有),可能存在偏差,重要内容请以原文为准。

一个忽略了自身 limit 的队列取件、一个在表沉寂时被缓存的执行计划,以及一个因自身成功而陷入死锁的消费者。

一条分阶段的流水线处理事件;每个阶段有一个消费者,由一个 fetcher goroutine 和每个副本 N = 10 个 worker 组成,每个阶段有两个副本。任务存放在一张 Postgres 表中,任务的阶段是一个列。消费者通过租约来取任务:

UPDATE tasks SET picked_at = now() + $window, attempts = attempts + 1 WHERE id IN ( SELECT id FROM tasks WHERE state = $state AND deferred = 'no' AND attempts <= $max AND (picked_at IS NULL OR picked_at <= now()) FOR UPDATE SKIP LOCKED LIMIT $n) RETURNING *;

UPDATE 之后,消费者为每个任务获取一把 Redis 锁,提交事务,在事件总线上为每个任务发布一条通知,并为每个任务启动一个 goroutine,每 $window/3 续租一次租约和锁,直到任务被释放。处理器把任务推进到下一阶段。如果某个消费者死掉,租约失效,另一个副本会以 attempts + 1 接手该任务。这是一个教科书式的 Postgres 队列,已经运行了几个月。直到它不再正常。

一位运维人员注意到某个阶段有 460 个任务在途。仪表盘一切正常,告警安静无声。就遥测所能反映的情况而言,一切都在按预期工作:

然而,一个积压查询揭示了真相。通过把任务分为等待中(现在符合条件)、已租用(有消费者持有)和已耗尽三组,我观察到了以下情形:

我们看到的情况出乎意料:全部 460 个任务都已被租用,attempt 为 1——而且,任何仪表盘都没有显示的是,它们的租约在彼此相差不到半秒的时间内全部到期。两个副本、每个十个 worker,最多能持有大约二十个任务,而不是 460 个,Redis 也同意这一点:460 个锁键,每个任务一个,TTL 都在刷新周期之内——有什么活着的东西在续租它们全部。

go_goroutines 指标指出了是哪个进程。一个副本有 463 个 goroutine,另一个有 83 个;命名空间里其他所有服务都在 23 到 43 之间(基线)。每个被持有的任务消耗一个刷新 goroutine,所以一个多出 420 个 goroutine 的副本持有大约 420 个没有 worker 在处理的任务。

虽然这不是生产环境,但这些 pod 已经以严格加固的安全姿态运行——没有 shell、没有用户、什么都没有——而且 pprof 没有启用。最后的手段是对行为异常的进程发送 SIGQUIT 并读取其 goroutine dump。代价是该信号也会重启 pod,一切会回到“正常”,直到同样的情形再次发生,但这是当时可用的最好办法。它很说明问题:

第二个副本的 dump 形状相同,有 40 个 refresher。

为完整起见,以下是它们所遵循协议的极度简化版本:

// Worker for { tasksWanted <- struct{}{} // token: "I am idle". Capacity N. This is line // 530: all ten workers were blocked here. t := <-tasksReceived // Wait for a task. Capacity N. handle(t)

// Fetcher for { wanted := takeTokens(tasksWanted) // up to N. tasks := pickup(wanted) // This runs the UPDATE … LIMIT $n // mentioned above. for _, t := range tasks { go refresh(t) } for _, t := range tasks { tasksReceived <- t // This is line 418: the fetcher // blocked here.

fetcher 交付的每个任务都由它取走的一个 token 作为支撑,所以每次取件至多 wanted 个任务时,两个 channel 都不会被填满。然而,如果给 fetcher 一次 440 个任务的取件,这个不变量就被打破了:

该协议留下了一个指纹:第一波 N 个任务加上缓冲区里等待的 N 个,所以恰好 2N = 20 个被处理……然后归于沉寂。日志在两个副本上都恰好显示了这一点:突发之后 20 个启动,之后再无动静。对 channel 逻辑的一个小型模拟在数值上复现了它:第一次取件 440 个,得到 20 个被处理、420 个泄漏的 refresher;一次 60 个,得到 20 个被处理、40 个卡住。这正是两个副本的数字。

这让我们处于这样一个境地:死锁是真实存在的,而且已被充分理解,但它需要一个设计上声称不可能的前置条件:一次取件返回超过 LIMIT 的数量。

锁计数器给出了第一个确凿证据:在两个给定时间戳之间,一个副本获取了 440 把锁,另一个获取了 60 把。两次取件,总共 500 个任务,这与片刻之前插入数据库的那批任务的大小完全吻合。500 个任务的突发之后,每个副本的第一次取件都拿走了它能看到的全部任务。还有一个奇怪之处:第一个任务在插入提交后大约两秒才启动。我稍后会回到这一点。

我的假设,以及它们的结局:

然而,最后那个结论是错的,而它错的方式正是这个故事中有趣的部分。测试本身是可靠的,但它们采样了错误的空间:它们只演练了健康表所产生的计划,而故障需要一种特定的计划。

以下是 EXPLAIN ANALYZE 在该环境的引擎上、在一张处于真实表所处状态的临时表上、在把规划器从其 hash、sort 和 materialise 策略上引开之后所显示的内容:

Update on tasks (actual rows=500.00 loops=1) -> Nested Loop Semi Join (actual rows=500.00 loops=1) -> Seq Scan on tasks (actual rows=502.00 loops=1) -> Subquery Scan on "ANY_subquery" (actual rows=1.04 loops=502) -> Limit (actual rows=1.04 loops=502) -> LockRows (actual rows=1.04 loops=502) -> Index Scan ... on tasks tasks_1

LIMIT 10 却 actual rows=500?子查询是嵌套循环的内侧,运行了 loops=502 次。同一脚本在社区版 Postgres 18.6 上给出了相同的计划、相同的代价数字和相同的 500 行,所以这不可能是 AWS Aurora(应用在其环境中使用的)的缺陷。问题在于执行器对该计划做了什么。

机制在 ExecLockRows 中:当前命令已经更新过的行从加锁尝试中返回为 TM_SelfModified,执行器会跳过它——代码注释引用了万圣节问题。因此,加锁子查询的每次重新执行都会跳过该语句已经

(原文较长,此处译出前 6000 字,完整内容请点「打开原文」。)

正文由 探How 从来源站点 RSS 同步,内容未经改写;遇到排版缺失或需要图片、视频时请以原文为准。

打开原文
去社区讨论 →