夜雨聆风学习资料网

ARTICLE · 1367604

文档说 64 个对象,我锁到 5301 张表才报错:PG 锁表的容量账

文档说 64 个对象,我锁到 5301 张表才报错:PG 锁表的容量账

2006 年 8 月,PostgreSQL 8.2 的文档里写着一句话:The default, 64, has historically proven sufficient.

翻译过来就是:64 这个值,历史上够用了。

这句话在文档里躺了二十年。8.2 到 9.x 到 12 到 18,max_locks_per_transaction 的默认值一次没动。直到 11 月 12 日——19 RC2 和 18.7、17.12、16.16、15.20、14.25 一起发出来的那天——它第一次变成 128。

改这一行的人是 Heikki Linnakangas,发布说明里的原话很短:Change default of max_locks_per_transaction from 64 to 128。后面跟了一句很怪的话:锁大小分配方式已经改变,所以为了达到和以前版本相同的容量,现在实际上必须把设置值翻倍。

这句话可以读成两种意思。一种是好心:默认值翻倍,你什么都不做也不吃亏。另一种是警告:如果你在 18 上手工把值调成了 256,搬到 19 上还是写 256,容量会掉一半。

到底是哪一种?我把 18.3 的源码翻出来,又搭了个集群一条条量。结论比两种读法都复杂一点。

01 先看这次到底改了什么

这次是季度小版本 + 19 的第二个候选版,官方说修了 52 个安全漏洞(postgresql.org 2026-11-12 发布公告)。同一天,14.25 成为 PostgreSQL 14 的最后一个版本,14 分支正式停止修复。19 的 GA 定在 11 月 19 日。

跟锁有关的两处改动都在"不兼容变更"清单里:

改动
18 及以前
19
影响面
max_locks_per_transaction
 默认值
64
128
所有升级到 19 的集群,尤其是显式写过这个值的
log_lock_waits
 默认值
off
on
日志量、日志告警规则

第一条是 Heikki 改的,第二条是 Laurenz Albe 改的,发布说明里都只有一行字:Enable server variable log_lock_waits by default。

一行字的改动,落到运维身上往往不是一行字的事。下面先解决第一个。

02 回到 2006 年:这个参数在数什么

8.2 的文档对它的描述,比现在这一版更直白:

The shared lock table is created to track locks on max_locks_per_transaction * (max_connections + max_prepared_transactions) objects (e.g. tables); hence, no more than this many distinct objects can be locked at any one time.

共享锁表按 max_locks_per_transaction ×(max_connections + max_prepared_transactions) 个对象来建,所以同一时刻最多只能锁这么多不同的对象。

按这个公式,我实验集群里 64 × 10 = 640,一条事务锁到第 641 个表就该挂。

我没挂。锁到第 5301 个表才挂。

差在哪?把 18.3 的 src/backend/storage/lmgr/lock.c 打开,第一处就不一样:

#define NLOCKENTS() \     mul_size(max_locks_per_xact, add_size(MaxBackends, max_prepared_xacts))

公式里乘的不是 max_connections,是 MaxBackends。MaxBackends 除了连接数,还要加上 autovacuum worker、后台 worker、walsender 这些常驻进程。文档里的公式是 2006 年写的,代码早就不是那个写法了。

第二处更有意思,就在同一个文件往下几十行:

max_table_size = NLOCKENTS(); init_table_size = max_table_size / 2;

初始只预分配一半。而 ShmemInitHash 建这张表时没有带 HASH_FIXED_SIZE 标志,也就是说——这张哈希表是可以继续长的,元素不够就再向共享内存要一块。真要到要不到的那一步,报的不是"锁太多了",而是:

ERROR:  out of shared memory HINT:  You might need to increase "max_locks_per_transaction".

所以这个参数从来不是"每个事务 64 个对象"的硬闸。它只决定锁表一开始占多大、以及共享内存里给它留多少余量。你真正撞上的墙是共享内存,不是那个 64。

再补一块考古。同一张锁表里,"快路径"是 2012 年的东西——9.2 的发布说明写着:Allow uncontended locks to be managed using a new fast-path lock mechanism(Robert Haas)。没冲突的弱锁先塞进每个后端自己的快路径槽位,不进共享锁表,省掉一次哈希查找和 LWLock。冲突了或者槽位满了,才降级去争那把分区锁。

快路径有多少个槽位?我量了:max_locks_per_transaction=64 时是 68 个,改成 128 时是 132 个。也就是说 18 里快路径槽位跟着这个参数走(大约是值 +4),而不是老版本写死的 16 个。这条我找不到官方文档的明确表述,纯粹是 pg_locks 里 fastpath 那一列数出来的,先按实测记着。

03 实验台与四个数

环境:本机 macOS,PostgreSQL 18.3(Homebrew),独立集群端口 5495,max_connections=10、max_prepared_transactions=0、shared_buffers=128MB、fsync=off、autovacuum=off、max_locks_per_transaction=64。

max_connections 我故意压到 10,目的是让锁表小到能在几分钟内被塞满。你在生产上看到的具体数字会不一样,下面所有绝对值都只在"这台机器、这套参数"下成立。

数一:单事务能锁多少张表。

BEGIN; -- 依次 SELECT 每一张表,锁一直持有到 COMMITSELECT count(*) FROM t1; SELECT count(*) FROM t2; -- ...COMMIT;

结果:5301 张成功,第 5302 张报 out of shared memory。此时 pg_locks 里这个后端的行数是 5301,其中 68 个走快路径,5233 个在共享锁表里。

数二:一条 SELECT 在分区表上要几个锁。

建一张 2000 分区的表,每个分区带主键和一条二级索引,然后只看其中 1000 个分区:

SELECT count(*) FROM partp WHERE k < 100000; -- 执行期间从另一个会话数SELECT count(*) FILTER (WHERE fastpath) AS fp,        count(*) FILTER (WHERENOT fastpath) AS main FROM pg_locks WHERE pid = <上面的 pid>;

fp=68, main=2944, total=3012。每个被扫到的分区 3 个锁:分区表本身、主键索引、二级索引。1000 个分区就是 3000 个,剩下 12 个是数据库、虚拟事务 ID 这类固定项。

数三:把这条 SELECT 的限制踩穿。

同一个集群,同一张表,不带裁剪条件:

SELECT count(*) FROM partp;
ERROR:  out of shared memory HINT:  You might need to increase "max_locks_per_transaction".

2000 个分区需要大约 6000 个锁,超过当时能拿到的余量。逐步二分:1000 个分区(3012 个锁)能过,1200 个分区(3612 个锁)就挂。注意这个门槛比"数一"里的 5301 低了一大截——同样的参数,走分区扫描这条路,能用的余量更少。这个差异我没能从源码推出一个干净的解释(怀疑和锁表内部分区、以及 LOCK 与 PROCLOCK 两张表各自增长有关),所以下面所有数字我都标清楚是哪个场景量的,不给你一个"64 等于能锁多少"的通用结论。

数四:最惨的一种撞墙方式。

很多人建分区是在一个 DO 块里循环建的。一个 DO 块就是一个事务,锁全部持有到结束:

DO $$ BEGIN   FOR i IN 0..1999 LOOP     EXECUTE format('CREATETABLE part_%s PARTITION OF part FOR VALUES FROM (%s) TO (%s)', i, i*100, (i+1)*100);     EXECUTE format('CREATEINDEX part_%s_payload_idx ON part_%s(payload)', i, i);   END LOOP; END$$;
ERROR:  out of shared memory CONTEXT:  SQL statement "CREATETABLE part_1308 PARTITION OF part ..."

建到第 1308 个分区时挂掉,然后整个 DO 块回滚,一个分区都不剩。1308 × 4 ≈ 5232,和数一的 5301 对得上——建一个分区要 4 个锁(分区表、它的索引,加上别的两项)。

迁移脚本写成这样,在大表上是灾难:跑了几分钟,报一个跟分区毫无关系的锁表错误,然后什么都不留。

04 把 64 改成 128,同一批脚本再跑一遍

改参数要重启(max_locks_per_transaction 是 postmaster 级),改完做同一组实验:

场景
mlpt=64
mlpt=128
单事务逐表加锁
5301 个成功,5302 报错
6000 个全过(没继续加压)
1000 分区扫描
3012 个锁,通过
通过
2000 分区全扫描
报错
6012 个锁,通过(fp 132 / main 5880)
DO 块建 2000 分区
第 1308 个报错,全部回滚
2000 个建完
DO 块建 3000 分区
—
第 2342 个报错,全部回滚
快路径槽位
68
132

翻上去 1.79 倍,不是 2 倍。三个原因叠在一起:初始预分配是 NLOCKENTS/2、MaxBackends 没变、哈希表继续从共享内存里长。所以官方那句"设置值要翻倍才能保持同样容量"我信一半——它是一个安全的经验值,不是一条等式。

这里还有个更省事的答案:2000 分区那条 SELECT,本来就不该全扫。带上分区键条件,锁从 6012 个降到 7 个左右,64 都够用。

-- 让规划器在计划阶段就把分区裁掉SELECT count(*) FROM partp WHERE k = 5000;

裁剪不生效的典型写法是把分区键包进函数或做隐式类型转换,比如 WHERE date_trunc('day', k) = ...。这种情况先看 EXPLAIN 里有没有 Subplans Removed,别急着调参数。

05 另一半:11 天后你的日志会变多吗

log_lock_waits 从 19 开始默认 on。它只在等待超过 deadlock_timeout(默认 1s)时才写日志,写法是这样的:

LOG:  process 10434 still waiting for AccessShareLock on relation 16411 of database 5 after 1000.876 ms at character 22 DETAIL:  Process holding the lock: 10431. Wait queue: 10434. STATEMENT:  select count(*) from t10; LOG:  process 10434 acquired AccessShareLock on relation 16411 of database 5 after 2987.819 ms at character 22 STATEMENT:  select count(*) from t10;

一次超过 1 秒的等待 = 5 行、约 548 字节(本机实测,连续 20 次等待,日志增加 10,960 字节)。语句本身被打了两遍,DETAIL 里给了持锁进程和等待队列,排障时这两行比什么都值钱。

那短等待呢?我用 pgbench 在 50 行的热表上跑 6 个并发连接,10 秒:

pgbench -n -c 6 -j 3 -T 10 -f hot.sql postgres

log_lock_waits=off 是 80,913 tps,on 是 74,504 tps,日志增加 0 字节。相差的 8% 在这个量级上属于噪声,两个数字我都留在这儿,不假装它是"零开销"。

结论分两种情况:

  • 锁等待大多是毫秒级(OLTP 热点行争用、短事务互相踩一下):默认开几乎不产生日志,不用管。
  • 有长事务、有 DDL 抢锁、有 idle in transaction 挂着连接:一次 ALTER TABLE 卡 30 秒,所有排队的会话各写 5 行,几十个连接就是几十条。这类日志有意义,但也会冲掉你原来的日志告警阈值——升级前先看一眼自己的日志量基线。
06 升 19 之前,做这三件事
  • 1. 数一下自己现在的锁。 峰值时抓一次:
SELECT pid, count(*) AS locks,        count(*) FILTER (WHERENOT fastpath) AS in_shared_table FROM pg_locks GROUP BY pid ORDER BY 2 DESC LIMIT 10;

分区表多的库,重点看单条语句的锁数,而不是单条事务。

  • 2. 别指望默认值翻倍替你解决容量。 18 上手工写过 max_locks_per_transaction = 256 的,19 上继续写 256 等于容量回到 18 的 128;要保住原有容量,按官方说法乘 2。改之前先算共享内存:这个参数按 NLOCKENTS 预留空间,调大是实打实吃内存的,shared_buffers 之外的那部分会跟着涨。备库必须 ≥ 主库,主备一起改,先改备库。
  • 3. 把"一条语句碰几千个分区"这件事从工作流里拿掉。 那句 2000 分区的 SELECT,加了裁剪只要 7 个锁;那个 DO 块,改成每个分区一次提交(psql 脚本里不要包 BEGIN),1308 这个上限就完全不相关了。参数是兜底,不是方案。
07 我没测到的
  • 19 RC2 没在本机编译出来(源码包下载一直断),19 上 max_locks_per_transaction 的实际容量我没有实测数据。表里 128 那一列是 18.3 改参数得到的,不能直接当 19 的行为。19 GA 是 11 月 19 日,装完值得用同一套脚本再跑一遍。
  • 5301 和 3612 这两个门槛为什么差这么多,我只有猜测,没有证据。源码里锁表是 dynahash 分区结构,HASH_ENTER_NULL 失败时报 out of shared memory,但具体是哪一张子表先满,我没打点。
  • 快路径槽位 = 参数 +4 这个关系是从两个数据点(68、132)看出来的,不是读代码读出来的。
  • 笔记本单机、fsync=off、shared_buffers=128MB,所有绝对值都不可外推到你的生产环境。倍数和顺序关系可以参考,绝对数字不行。

资料来源

  • postgresql.org 发布公告《PostgreSQL 18.7, 17.12, 16.16, 15.20, 14.25, and 19 RC 2 Released!》2026-11-12
  • PostgreSQL 19 发布说明(docs/19/release-19.html):不兼容变更清单、max_locks_per_transaction 默认值改动、log_lock_waits 默认开启
  • PostgreSQL 19 文档 19.12 Lock Management(docs/19/runtime-config-locks.html)
  • PostgreSQL 8.2 文档 runtime-config-locks("The default, 64, has historically proven sufficient" 原文)
  • PostgreSQL 9.2 发布说明(fast-path lock mechanism,Robert Haas)
  • PostgreSQL 18.3 源码 src/backend/storage/lmgr/lock.c(NLOCKENTS()、init_table_size = max_table_size / 2、PROCLOCK 表按 2 倍估算)、src/backend/utils/hash/dynahash.c(element_alloc 扩容路径)、src/backend/storage/ipc/shmem.c(ShmemInitHash 不带 HASH_FIXED_SIZE)
  • 本机 PG 18.3 实测,集群端口 5495,实验脚本与日志存于 output/pglab_1115/

回首页,搜索你想要的文档

在首页搜索框输入关键词,快速定位资料

文库首页搜索指引 立即搜索

相关学习资料