pg_advisory_lock — перше, що хочеться взяти, коли запуск за розкладом накладається сам на себе. За Supabase, PgBouncer чи серверлес-пулом він тихо не захищає нічого. Що насправді гарантують advisory-локи, три способи їх мовчазного провалу, лок із TTL для баз, доступних лише по HTTP, і умовне захоплення, після якого подвійна робота стає неможливою.
- Опубліковано
- Читання
- 9 хв
- Автор
- Yaroslav Tsarenko

У лозі було написано, що запуск почався о 14:00. І ще раз написано, що запуск почався о 14:00. Два рядки, та сама хвилина, різні id процесів — і десь там одна людина отримала від мене той самий лист двічі.
Рішення здавалося очевидним. У Postgres є advisory-локи: бери лок на початку задачі, знімай у кінці, готово. Саме це радять у кожній гілці про крон, який накладається сам на себе, — і в багатьох конфігураціях ця порада тихо хибна. Не «не оптимальна». А «функція повертає true, лок не робить нічого, а ви вважаєте себе захищеним».
Нижче — що advisory-локи справді обіцяють, три способи, якими вони провалюються мовчки, що робити, коли база говорить лише по HTTP, і єдиний патерн, після якого подвійна робота стає неможливою, а не малоймовірною.
Що таке advisory-лок насправді
Усе, що Postgres блокує зазвичай, — це річ: рядок, таблиця, індекс. Advisory-лок — це число. Ви обираєте 64-бітний ключ (або два 32-бітних), просите його, і Postgres віддає його рівно одному охочому за раз. Оце і вся фіча.
Чого він не робить — не менш важливо:
- Нічого не блокує. Жоден рядок не стає незаписуваним. Жодна таблиця — нечитаною.
- Нікого не зобов'язує. Код, який ключа не просить, працює далі. Лок — це домовленість між процесами, що погодились ним користуватись.
- Нічого не памʼятає. Ніде не записано, чому ключ узяли і хто саме, якщо ви не записали це самі.
Це ключ від переговорної на гачку біля дверей. Узяти ключ означає, що його не візьме ніхто інший. Це не заважає зайти крізь інші двері.
Рівнів два, і саме різниця між ними породжує більшість проблем.
-- рівень сесії: живе, доки не знімете або доки не закриється сесія
select pg_advisory_lock(42); -- чекає, можливо вічно
select pg_try_advisory_lock(42); -- true або false, негайно
select pg_advisory_unlock(42);
-- рівень транзакції: звільняється на commit чи rollback, зняти вручну не можна
select pg_advisory_xact_lock(42);
select pg_try_advisory_xact_lock(42);Сесійні локи переживають commit і rollback. Ще вони стакаються: попросили тричі — знімайте тричі, інакше ключ лишиться на гачку. Транзакційні зникають щойно транзакція завершилась, хай там як вона завершилась. Усі їх видно в pg_locks за locktype = 'advisory' — це варто знати о третій ночі.
Провал перший: пулер зʼїдає вашу сесію
Ось патерн, який виглядає правильним і не захищає нічого:
await sql`select pg_advisory_lock(42)`;
await doTheWork();
await sql`select pg_advisory_unlock(42)`;Три запити, три походи в базу — і ніде не сказано, що вони мають піти одним зʼєднанням. За пулом зʼєднань зазвичай і не йдуть.
- PgBouncer у режимі transaction видає серверне зʼєднання на кожну транзакцію. Лок іде на один бекенд, зняття — на інший, де знімати нічого. Перше зʼєднання повертається в пул із ключем 42 на руках, і наступний його орендар успадковує лок, якого не просив.
- Supabase через PostgREST — гірше, зате чесніше. Кожен виклик — це HTTP-запит. Сесії, яку можна втримати між двома з них, тут немає за задумом.
select pg_advisory_lock(42)відпрацює успішно і звільниться ще до наступного рядка вашого JavaScript. - Серверлес-функції множать проблему на кількість інстансів, яку платформа вирішила підняти.
Про ту саму пастку з іншого боку я писав у оптимізації запитів PostgreSQL у Node.js: у режимі transaction ламається сесійний стан загалом. SET без LOCAL, LISTEN, сесійні advisory-локи. Усі вони припускають, що сесія ваша, а вся робота пулера в тому, що вона не ваша.
Правило коротке: advisory-лок рівня сесії справжній лише на зʼєднанні, яке ви тримаєте самі — від взяття до зняття. Прямий рядок підключення, окремий воркер, довгоживучий процес. Якщо не можете показати пальцем на це зʼєднання — лока у вас немає.
Провал другий: чекати вічно — не стратегія
pg_advisory_lock блокує. Без таймауту й без обмеження на кількість охочих у черзі. На задачі, яка стартує щодесять хвилин і подеколи триває одинадцять, ви отримаєте не один пропущений запуск, а чергу процесів, кожен з яких тримає зʼєднання і готовий чекати, доки пул не закінчиться.
Задача за розкладом майже ніколи не хоче чекати. Вона хоче зрозуміти, що запізнилась, і піти:
const [{ ok }] = await sql`select pg_try_advisory_xact_lock(42) as ok`;
if (!ok) return { skipped: "лок тримає інший запуск" };pg_try_advisory_xact_lock — те, що я беру за замовчуванням. Він відповідає одразу, а лок зникає щойно завершиться транзакція: успішно, з помилкою або разом із процесом, убитим на півдорозі. Нічому протікати, і немає виклику зняття, який можна забути в finally, якого ви так і не написали. Якщо чекати таки треба — спершу задайте lock_timeout, щоб у чекання був кінець.
Провал третій: лок ніколи й не був гарантією
Оце головний урок, і навчив мене йому саме дубльований лист.
Припустимо, лок працює бездоганно. Один запуск, жодних накладань. Тепер процес помирає на півдорозі: деплой, OOM, платформа гасить інстанс. Транзакційний лок звільняється миттєво й цілком коректно — а наступний запуск бере лист, який уже віддано поштовому серверу, але не позначено як відправлений. Нічого не наклалося. Лист усе одно пішов двічі.
Лок узгоджує. Він не памʼятає. Роботу робить одноразовою запис про роботу, а не лок навколо неї.
Що робити, коли база говорить лише по HTTP
Мій власний рушій холодної розсилки працює як одна задача за розкладом, раз на годину: збір, обробка, аудит, пошта, відправка, звіт — кожен крок у своєму таймбоксі, щоб повільний крок не зʼїв ті, що за ним. Дані живуть у Supabase, кожен виклик — HTTP-запит, тож шлях з advisory-локом закритий ще до старту.
Тому лок тут — рядок із власником і терміном дії:
type Lock = { owner: string; at: string; until: string };
const owner = `${process.env.RENDER_SERVICE_NAME ?? "local"}-${process.pid}-${rand()}`;
const held = await getSetting<Lock | false>("cycle_lock", false);
if (held && Date.parse(held.until) > Date.now()) return { skipped: "locked" };
await setSetting("cycle_lock", { owner, at: iso(now), until: iso(now + TTL) });
await sleep(400);
// два запуски, що стартували разом, обидва записали: перемагає останній, другий відступає
const now = await getSetting<Lock | false>("cycle_lock", false);
if (!now || now.owner !== owner) return { skipped: "програв гонку" };Виживати цьому дають три властивості. TTL (двадцять хвилин, помітно більше за дванадцятихвилинний бюджет) означає, що впалий запуск не заклинить задачу назавжди. Рядок власника робить зняття безпечним: запуск чистить лок, лише якщо той досі його, тож повільний і вже протермінований запуск не зітре лок новішого. А повторне читання після короткої паузи перетворює «ми обидва записали» на «один із нас помічає це і виходить».
Тепер чесна частина, бо саме тут себе й обманюють. Читання, потім запис, потім ще одне читання — це не взаємне виключення. Це гонка з вужчим вікном. Два запуски можуть потрапити в ті самі 400 мілісекунд і обидва вирішити, що ключ їхній. Рядок із TTL тут для того, щоб не робити роботу двічі й не слати мені два однакові звіти в Telegram. Не він утримує лист від повторної відправки.
Якщо хочеться рядка-лока без гонки, це має бути один запит, і переможця визначає база:
insert into job_locks (key, owner, until)
values ('cycle', $1, now() + interval '20 minutes')
on conflict (key) do update
set owner = excluded.owner, until = excluded.until
where job_locks.until < now()
returning owner;Один похід у базу. Уся суть — в where на do update: рядок перехоплюється, лише якщо оренда попереднього власника вже спливла. Порівняйте повернений owner зі своїм — не збігся, отже ключ у когось іншого. Це працює через PostgREST, через будь-який пулер і з будь-якої кількості регіонів, бо атомарність живе в Postgres, а не у вашому потоці виконання.
Патерн, який справді робить роботу одноразовою
Хоч що узгоджує запуски, коректність дає умовна зміна стану. Не читайте рядок, щоб потім на нього подіяти. Захопіть його — і хай кількість повернених рядків скаже, чи робота ваша:
update messages
set status = 'sending', claimed_at = now()
where id = $1
and status = 'approved'
returning id;Нуль рядків — отже, його захопив інший воркер, або людина скасувала, або він уже пішов. Один рядок — отже, він ваш і більше нічий, бо status = 'approved' для решти вже хибне. Та сама форма для черги, коли береться кілька одразу:
update messages set status = 'sending'
where id in (
select id from messages
where status = 'approved' and scheduled_at <= now()
order by scheduled_at
limit 5
for update skip locked
)
returning *;FOR UPDATE SKIP LOCKED — саме те, що дає цьому масштабуватись: паралельні воркери переступають через рядки, які вже захоплюють, замість ставати за ними в чергу.
І зробіть зворотний запис доказовим. Зберігайте id листа від поштового сервісу на рядку після успішної відправки, а унікальний індекс на бізнес-ключі — скажімо, отримувач плюс крок послідовності — перетворить подвійну відправку на помилку бази, яку побачите ви, а не на лист, який побачить потенційний клієнт. Це та сама дисципліна ідемпотентності, яку я детально розбирав у гайді про черги задач у Node.js: доставка «щонайменше раз» плюс ідемпотентний обробник у сумі дають ефект «рівно раз».
Сесійний лок
- pg_advisory_lockрівень сесії, за замовчуванням чекає вічно
- Вмирає за пулеромPostgREST, PgBouncer transaction, серверлес
Транзакційний лок
- pg_try_advisory_xact_lockодразу повертає true або false
- Звільняється на commitнема чому протекти й нема що знімати
Рядок із TTL
- Рядок-лок із TTLпрацює по HTTP, спливає сам
- Читання і запис гонятьсяменше дублювання, не виключення
Захоплення
- Умовне захопленняUPDATE … WHERE status = попередній
- Атомарне за означеннямодин рядок у відповідь, один працівник
Як два шари працюють разом
Коли захоплення на місці, лок міняє роль. Він більше не несе навантаження — він оптимізація, яка не дає двом запускам зробити ті самі дванадцять хвилин роботи і надіслати мені два однакові звіти. Якщо він іноді не спрацює, я втрачу трохи процесорного часу. Якщо не спрацює захоплення — хтось отримає лист двічі. Розуміти, що з них що, — це й є більша частина майстерності.
Тому рушій складає їх шарами й тримає ще кілька правил, які до локів не мають жодного стосунку:
- нічого не йде поза вікном — лише будні, з полудня до вечора в робочі години отримувача;
- ковзний ліміт за 24 години, а не за календарну добу, бо календарна доба обнуляється опівночі й цілком легально дозволяє запуску о 23:59 і запуску о 00:01 подвоїтись;
- запобіжник за поверненнями і скаргами, який ставить усе на паузу, коли частка повернень перевищує поріг, причому пороги підібрані так, щоб одне повернення під час прогріву не спиняло чергу;
- відправка бере лише листи, які затвердила людина, тож найгірше, що може зробити баг, — надіслати вже написане й прочитане.
Кожне з них — менший радіус ураження, якщо попереднє не спрацювало. Оце і є справжній принцип проєктування тут: не «знайти правильний лок», а «припустити, що кожен шар впаде, і спитати, що зловить наступний».
Те саме мислення працює далеко за межами пошти. Магазин Parandis Bud синхронізує залишки зі складською системою за розкладом, і синхронізація, що відпрацювала двічі, — це не косметична проблема, а ціни й залишки, які розходяться зі складом саме тоді, коли покупець оформлює замовлення.
Короткий список рішень
| Ситуація | Що брати |
|---|---|
| Пряме зʼєднання, робота вміщається в одну транзакцію | pg_try_advisory_xact_lock |
| Пряме зʼєднання, робота ширша за транзакцію | сесійний лок на зʼєднанні, яке тримаєте самі, зняття у finally |
| PgBouncer transaction, PostgREST, серверлес | рядок-лок, захоплений одним умовним insert … on conflict … where |
| Кілька воркерів тягнуть із черги | for update skip locked плюс захоплення статусу |
| Усе, що торкається грошей, пошти чи іншої системи | умовне захоплення й унікальний ключ, незалежно від лока |
І пʼятихвилинна перевірка задачі, яка у вас уже працює:
- Лок береться і знімається на одному зʼєднанні? Якщо не можете довести — це не лок.
- Запізнілий запуск пропускає, а не чекає?
try-варіанти абоlock_timeout. - Якщо процес убили на півдорозі, лок спливе сам?
- У самої роботи є умовне захоплення, щоб другий запуск не знайшов, що робити?
- Чи є унікальний ключ, який перетворює дубль на помилку, яку ви побачите?
Три й більше непевних відповідей означають, що задача не захищена — їй просто щастило. Моїй щастило кілька тижнів, а потім перестало.
Якщо коротко
- Advisory-лок — це число, яке Postgres віддає одному охочому за раз. Він не блокує дані й не зобовʼязує код, що його не просить.
- Локам рівня сесії потрібне зʼєднання, яке ви тримаєте від взяття до зняття. За режимом transaction у PgBouncer, за PostgREST чи серверлес-пулом такого зʼєднання немає, і лок тихо не захищає нічого.
- Беріть
pg_try_advisory_xact_lock: він відповідає одразу і звільняється в кінці транзакції, хай там як вона завершилась. - Коли база доступна лише по HTTP, рядок-лок працює — але захоплюйте його одним умовним запитом, а не читанням із наступним записом, інакше ви лише звузили вікно гонки.
- Локи рятують від зайвої роботи. Умовні захоплення й унікальні ключі рятують від неправильної. Гарантія — тільки друге.
Якщо у вас є задача за розкладом, щодо якої ви не до кінця впевнені, — така, що відправляє, списує гроші чи синхронізує, — залюбки гляну. Зазвичай вистачає одного погляду на запит захоплення, щоб зрозуміти, чи може вона відпрацювати двічі.
Було корисно?
– вподобань · – переглядів
Часті запитання
Що таке advisory-лок у Postgres?
Іменований лок, який застосунок бере за номером, а не за рядком чи таблицею. Postgres віддає його одному охочому за раз і не вкладає в нього жодного сенсу: нічого в базі не блокується, і код, який цього ключа не просить, спокійно працює далі. Лок існує лише для того, щоб два процеси домовились, хто робить роботу.
Чому pg_advisory_lock не працює з Supabase чи PgBouncer?
Advisory-локи рівня сесії живуть на одному з'єднанні. PostgREST, PgBouncer у режимі transaction і більшість серверлес-пулів дають окрему сесію на кожен запит чи транзакцію, тож лок береться на одному з'єднанні, а зняття потрапляє на інше. Лок або зникає одразу, або залишається на з'єднанні в пулі, і його тримає наступний, геть сторонній запит.
Чим pg_advisory_lock відрізняється від pg_advisory_xact_lock?
Сесійний тримається, доки ви не викличете pg_advisory_unlock або не закриється сесія, і переживає commit та rollback. Транзакційний звільняється сам у кінці транзакції, і зняти його вручну не можна. Якщо робота вміщається в одну транзакцію, xact-варіант майже завжди безпечніший.
Як не дати завданню за розкладом відпрацювати двічі?
Двома шарами. Лок, щоб не робити роботу двічі: pg_try_advisory_xact_lock на прямому з'єднанні або рядок-лок із TTL, якщо до бази ви ходите лише по HTTP. І умовне захоплення для коректності: оновлюєте рядок у стан «зайнято» лише там, де він досі в попередньому стані, і працюєте тільки якщо оновлення повернуло рядок.
Чи рядок-лок у таблиці не гірший за advisory-лок?
Гірший. Між читанням і записом рядка-лока є вікно гонки, тож два запуски можуть обидва вирішити, що ключ їхній. Це спосіб не дублювати роботу, а не взаємне виключення. Або закривайте гонку одним умовним запитом, або вважайте лок оптимізацією, а справжню гарантію кладіть у захоплення.