暂无图片
暂无图片
暂无图片
暂无图片
暂无图片

我把 autovacuum 开到 4 个并行:墙钟省 45%,内存账翻 2.4 倍

河马coding 2026-10-28
46

10 月 15 日 PG19 RC1 出来那天,我先翻的不是 REPACK,也不是 pg_plan_advice,是 Release Notes 里夹在 General Performance 中间的一行小字:

Allow autovacuum to use parallel autovacuum workers (Daniil Davydov). The maximum number of workers is controlled by server variable autovacuum_max_parallel_workers and per-table storage parameter autovacuum_parallel_workers.

手动 VACUUM (PARALLEL n)
 从 PG13 就有了。可凌晨三点在你生产库上跑的那个后台进程,一直只有一个自己。这条改的是它。

我把 19rc1 的源码编起来,搭了个只有两张表的小集群,前后跑了 18 轮。四个结论,跟我预想的都不太一样:

1. 它真的省时间。autovacuum 实测中位数 0.78 秒掉到 0.43 秒,接近一半。
2. 省的那部分全在索引阶段,堆扫描一毫秒没省。
3. 代价写在另一行日志里:内存账从 0.83MB 变成 2.00MB。
4. 四个旋钮里只有一个是真的总闸,而且默认是关的。

先把账摊开,再讲为什么。

01 实验台:两张形状相反的表

一台 8 核 16GB 的 Mac,PG 19rc1 源码编译,独立集群,端口 5491。为了把 CPU 和内存的账算干净,fsync
、synchronous_commit
 关掉,autovacuum 的 cost delay 归零,maintenance_work_mem
 给 256MB。

两张表都是 40 万行、两轮全列更新,留下 80 万个死元组。区别在形状:

-- A 表:宽行,7 个索引,218MB 堆 + 114MB 索引CREATETABLE wide_bloat (   id bigint PRIMARY KEY,   c1 text, c2 text, c3 text,   c4 int, c5 int, c6 timestamp, c7 uuid, payload text ) WITH (autovacuum_enabled = false); CREATE INDEX idx_wb_c1 ON wide_bloat(c1); -- ... c2 到 c6 同理,一共 6 个二级索引INSERTINTO wide_bloat SELECT g, 'v'||(g%5000), 'c'||(g%300), md5(g::text), g%1000, g%97,        now() - (g||' seconds')::interval, gen_random_uuid(), repeat(md5(g::text),2) FROM generate_series(1,400000) g; UPDATE wide_bloat SET c1='v2_'||(id%5000), c2='c2_'||(id%300), c3=md5((id+1)::text); UPDATE wide_bloat SET c1='v3_'||(id%5000), c2='c3_'||(id%300), c3=md5((id+2)::text);

另一张 thin_bloat
 反过来:行很窄,142MB 堆,但挂了 11 个索引,索引总量 151MB。我想看的是,索引占比更大时,并行会不会更划算。

每轮都重建表、CHECKPOINT、再动手。所有数字取三轮中位数,A 表第一轮 1041ms 是冷缓存,我在表里保留了它,没剔除。

02 18 轮跑完的账本

先看手动 VACUUM
,这是最干净的一组对照:同一张表,只改 PARALLEL
 一个参数。

表
索引数
串行(3 轮)
并行 4(3 轮)
中位变化
leader CPU
wide_bloat
7
457 578 / 1041 ms
323 / 374 / 401 ms
578 → 374 ms,-35%
0.26 → 0.11 s
thin_bloat
11
457 / 509 / 606 ms
332 / 355 / 391 ms
509 → 355 ms,-30%
0.26 → 0.11 s

再看真正的 autovacuum。同一张 wide_bloat
,同一批 80 万死元组,只改 autovacuum_max_parallel_workers
:

全局设置
日志 elapsed
leader CPU
并行 worker
TID 存储
0(默认)
0.76 / 0.79 s
0.29 s
无
0.83 MB
4
0.43 / 0.35 / 0.49 s
0.12 s
4 planned / 4 launched
2.00 MB

中位 0.78 → 0.43 秒,-45%。这比我手动测的 35% 还高一点,因为手动那边我多算了一次 psql 往返。

第三组是前两组都没覆盖的:把 full_page_writes
 打开,让每次改页都额外写整页镜像。

thin_bloat + FPI
轮次
中位
WAL 量
串行
851 / 1146 / 1181 ms
1146 ms
171MB,3.7 万条整页镜像
并行 4
848 / 706 ms
777 ms
128–172MB

同一个并行参数,收益从 30% 掉到 32% 附近——没掉多少,但整组慢了近一倍。这说明并行的收益不随 I/O 量等比放大,它只跟你花在索引阶段多少 CPU 有关。这句话是后面所有结论的根。

03 反直觉一:并行的不是"清理这张表"

很多人第一反应是:4 个 worker 一起扫这张表,应该快 4 倍。

不会。官方文档 24.1.7 写得很直白,并行只发生在两个阶段:

VACUUM can perform index vacuuming and index cleanup phases in parallel using background workers.

也就是 vacuuming indexes
 和 cleaning up indexes
。堆扫描(scanning heap
)和回写堆(vacuuming heap
)始终由 leader 一个人干。你能拿到的上限,是索引阶段那部分时间被摊开,剩下的堆相关时间原样保留。

同一段文档还给了两条硬门槛:

An index can participate in parallel vacuum if and only if the size of the index is more than min_parallel_index_scan_size. Only one worker can be used per index. So parallel workers are launched only when there are at least 2 indexes in the table.

min_parallel_index_scan_size
 默认 64,单位是 8kB 块,也就是 512kB。我拿一张 2 万行的小表验证过一次,7 个索引,PARALLEL 4
,日志里连"launched parallel workers"这一行都没有:

 indexrelname     |  sz ------------------+--------  small_bloat_pkey | 920 kB   ← 唯一达标的  idx_sb_a         | 432 kB  idx_sb_b         | 432 kB  idx_sb_c         | 424 kB   ← 剩下 6 个全在门槛下面

只有 1 个索引够格,凑不出"至少 2 个",于是 0 个 worker。小表上开并行不生效,不是配置写错,是它算完账觉得不值。

04 反直觉二:四个旋钮,只有一个是总闸

我一开始以为有三个开关都能调,实测下来只有一个真正管事。四组配置,同一个 wide_bloat
:

全局 autovacuum_max_parallel_workers
表级 autovacuum_parallel_workers
max_parallel_maintenance_workers
max_parallel_workers
实测结果
0
–
8
8
无并行,0.76 / 0.79 s
4
–
8
8
4 planned / 4 launched
,0.35–0.49 s
0
4
8
8
无并行,0.59 s
4
0
8
8
无并行,0.57 s
4
–
0
8
仍然 4 planned / 4 launched
4
–
8
0
4 planned / 0 launched

三个反直觉的地方,按我踩的顺序说。

第一,SET
 改不动它。
 这不是普通会话参数:

postgres=# SET autovacuum_max_parallel_workers = 4; ERROR:  parameter "autovacuum_max_parallel_workers" cannot be changed now

它是 sighup 级,只能写进 postgresql.conf
,或者 ALTER SYSTEM
 再 pg_reload_conf()
。我一开始直接 SET
,白折腾了两分钟。

第二,表级参数不能"单表开",只能"单表关"。 我原本的想法很美好:全局保持 0,只在几张宽表上写 autovacuum_parallel_workers = 4
,这样谁都不受影响。实测打脸——日志里没有并行,0.59 秒,内存还是 0.83MB。文档那句 "which is further capped by autovacuum_max_parallel_workers" 里的 capped 是硬上限,不是默认值。全局是 0,表级写多少都归零。

反过来就成立:全局 4、这张表写 0,日志里一行并行都没有,0.57 秒。这是个减项,不是加项。

顺带说一句,10 月 16 日 Fujii Masao 专门提交了一次文档修订(c105ab8
),就是来澄清这个参数能在哪设、和表级参数什么关系。说明不止我一个人在这里绕。

第三,max_parallel_maintenance_workers
 管不到 autovacuum。
 我把它设成 0,autovacuum 照样报 4 planned, 4 launched
。原因在文档里:手动 VACUUM
 走 max_parallel_maintenance_workers
 和 PARALLEL
 取小,autovacuum 走表级参数、再被全局 max_parallel_workers
 兜底。两个池子是分开的。

真正能掐断它的是 max_parallel_workers
。设成 0,日志变成 4 planned, 0 launched
——计划里有,一个没起来,然后老老实实单干。要给并行 autovacuum 留额度,得从全局并行池里划,不是从维护操作那一份里划。

05 反直觉三:省下来的时间,从内存里扣

这是我最没想到的一笔账。同一轮 autovacuum,真实日志长这样(PG19 新增了最后两行,正好是这次要看的):

LOG:  automatic vacuum of table "postgres.public.wide_bloat": index scans: 1 	pages: 0 removed, 27907 remain, 27907 scanned (100.00% of total) 	tuples: 400000 removed, 400000 remain, 0 are dead but not yet removable 	index scan needed: 18605 pages from table (66.67% of total) had 800000 dead item identifiers removed 	parallel workers: index vacuum: 4 planned, 4 launched in total 	memory usage: dead item storage 2.00 MB accumulated across 1 reset (limit 256.00 MB each) 	system usage: CPU: user: 0.12 s, system: 0.14 s, elapsed: 0.49 s

注意那行 memory usage
 的结尾:limit 256.00 MB each。each 是"每个参与者"的意思。串行时是 leader 一个人 256MB 上限,开了 4 个 worker 就是 5 份各自的额度,峰值内存的理论上限直接乘 5。

实测的死元组存储从 0.83MB 涨到 2.00MB,2.4 倍。表小的时候这是 1MB 的事,放到一张几 TB 的表上,autovacuum_work_mem
 本来就压得很紧,再乘上 worker 数,这才是要提前算的那笔账,不是 CPU。

这些信息以前看不到。Release Notes 里还有一条容易被忽略:VACUUM (VERBOSE)
 和 autovacuum 日志从 19 起才输出内存用量与并行度(Tatsuya Kawata、Daniil Davydov)。换句话说,这个功能和一个能观测它的仪表盘是同一版进来的。

06 同一条功能,为什么有人测出 4%

10 月 16 日,一位开发者 Alex Georgiev 在 dev.to 上发了 beta4 的实测:同样是 40 万行、6 个索引,串行 1.31 秒,并行 1.25 秒,只快 4%。

我第一次看到这组数字是懵的,因为我的表形状几乎一样,收益差了十倍。把他的数字和我的一起摆开,答案就出来了:


串行墙钟
并行墙钟
leader CPU(串行→并行)
他的(Docker + 真实磁盘)
1.31 s
1.25 s(-4%)
0.57 → 0.40 s(-30%)
我的(fsync=off,全在内存)
0.78 s
0.43 s(-45%)
0.29 → 0.12 s(-59%)

看第二列和第三列的关系:他的 CPU 掉了 30%,墙钟只掉 4%。省下来的 CPU 时间没有变成墙钟时间,因为那些时间他本来就在等 I/O。我的环境里没有磁盘等待,省一个 CPU 毫秒就是一个墙钟毫秒。

所以判断这张表值不值得开并行,有一个比"表有多大"更准的判据:先看串行那次的 leader CPU 占墙钟多少。占比不到一半,说明瓶颈在等 I/O,并行帮不上;占比七成以上,才有得赚。他这个 0.57/1.31≈43%,我这 0.29/0.78≈37%,看着差不多,但他是"CPU 时间之外还有 0.74 秒在等盘",我是"这 0.37 秒的空隙是进程调度和内存拷贝"。环境不同,结论就反过来。

这个功能还很新。翻 10 月的提交记录,一个月内至少五次收尾:10 月 1 日修"等 worker 时不再刷新 cost 参数"(Nikolay Samokhvalov 报的)、10 月 5 日修 worker 忽略 track_cost_delay_timing
 变更、10 月 8 日修并行 vacuum 的 I/O 时间统计只算 leader、10 月 15 日修一个更吓人的——并行 autovacuum 跑着的时候,非超级用户执行 DROP DATABASE ... FORCE
 会报 permission denied to terminate process
,因为并行 worker 在 PGPROC 里挂的是 bootstrap superuser。最后这条是 Bharath Rupireddy 用 AI 辅助审查翻出来的,也只 backpatch 到 19。

上线前留个心眼:19rc1 是 10 月 15 日打的包,这条修复是当天提交的,装之前先确认你手上的二进制里有没有 a39e53a
。

07 三步判断,别急着开

想在自己的库上试,按这个顺序走,别一上来说"开到 8"。

-- 第一步:现在谁在清理,卡在哪个阶段(19 新增 mode / started_by 两列)SELECT pid, relid::regclass AS tbl, phase,        indexes_processed || '/' || indexes_total AS idx,        dead_tuple_bytes, num_dead_item_ids, mode, started_by FROM pg_stat_progress_vacuum;

phase
 卡在 scanning heap
 的,加 worker 没用;在 vacuuming indexes
 上磨的,才有得谈。

-- 第二步:这张表有几个索引够得上并行门槛(默认 512kB)SELECT count(*) AS eligible_indexes FROM pg_index i WHERE i.indrelid = 'wide_bloat'::regclass   AND pg_relation_size(i.indexrelid) > current_setting('min_parallel_index_scan_size')::int * 8192;

小于 2 就直接放弃,别改配置了。

-- 第三步:三个闸门和当前池子SELECT name, setting, unit FROM pg_settings WHERE name IN ('autovacuum_max_parallel_workers','max_parallel_workers',                'max_worker_processes','min_parallel_index_scan_size');

autovacuum_max_parallel_workers
 默认 0,要先在配置文件或 ALTER SYSTEM
 里打开;max_parallel_workers
 要留出余量,它同时也供给并行查询。

-- 想给个别表关掉(全局开着时这个方向是有效的)ALTERTABLE big_log SET (autovacuum_parallel_workers = 0);

四句话总结我这 18 轮:

  • 全局开关 autovacuum_max_parallel_workers
     是总闸,默认 0,SET
     改不动。
  • 表级 autovacuum_parallel_workers
     只能往下压,压不上去。
  • 真正的兜底是 max_parallel_workers
    ,不是 max_parallel_maintenance_workers
    。
  • 收益看索引阶段占比,代价看 memory usage
     那行的 each
    。
08 我没测到的

五条,照实说:

1. 单机 macOS、fsync=off
、数据全在 page cache,绝对值不能外推到你的云主机。收益的方向可以信,倍数不行。
2. 两张合成表,都是 40 万行,没有真实业务表那种分布倾斜和长事务。
3. 每组 2 到 3 轮,中位数能说明方向,给不出精确倍数。max_parallel_maintenance_workers=0
 那轮跑了 1.69 秒,明显偏离其他并行轮次,我按噪声处理,没让它进中位数。
4. FPI 组的并行只跑了两轮,第三轮被我自己另一个实验打断,所以那行是两轮的数字。
5. DROP DATABASE FORCE
 那个 bug 我只读了提交记录,没复现;也没测 io_uring
 与 worker
 两种 io_method
 在这个场景下的差别。

文章转载自河马coding,如果涉嫌侵权,请发送邮件至:contact@modb.pro进行举报,并提供相关证据,一经查实,墨天轮将立刻删除相关内容。

评论