Двухфазный коммит (2PC): prepare и commit, блокировка координатора, 3PC и XA

Как работает двухфазный коммит: фазы prepare и commit, почему 2PC блокируется при падении координатора, чем не спасает 3PC, XA в Postgres и MySQL и почему в микросервисах берут сагу и outbox.

13 мин чтениясистемный дизайн · распределённые системы · базы данных · python

Коротко

ВопросОтвет
Какую задачу решаетАтомарный коммит поверх нескольких ресурсов: либо все участники применили изменения, либо ни один
Как устроенФаза 1 — prepare: участники голосуют «да/нет» и обещают выполнить решение. Фаза 2 — координатор рассылает его
Главный недостатокБлокирующий протокол: если координатор упал после prepare, участники ждут его, держа блокировки
ЦенаДва раунда сообщений, принудительные записи в журнал на каждом узле, доступность = произведение доступностей
Где живётВнутри распределённых БД (Spanner, Citus), XA между базами и очередями в монолитах на Java
Что берут в микросервисахСагу и Transactional Outbox: локальные транзакции и повторная доставка

На собеседовании 2PC спрашивают не ради того, чтобы вы его внедрили, а чтобы проверить: понимаете ли вы, почему он блокируется и чем за это платите.

Задача: атомарность поверх двух баз

Заказ хранится в одной базе, остатки на складе — в другой. Нужно создать заказ и списать товар так, чтобы не получилось «заказ есть, товар не списан» или наоборот.

Внутри одной базы это решает обычная транзакция: BEGIN ... COMMIT, журнал упреждающей записи и атомарный флаг коммита. Поверх двух баз так нельзя. Если закоммитить сначала первую, а вторая откажет (нарушен CHECK (qty >= 0), упал узел, истёк таймаут), первую уже не откатить: коммит необратим.

Значит, нужен шаг, на котором каждый участник ещё ничего не зафиксировал, но уже гарантировал, что сможет зафиксировать. Это и есть идея двухфазного коммита: разделить «готов» и «сделал».

Как работает 2PC

Есть координатор (transaction manager) и участники (resource managers — базы, брокеры). Клиент выполняет изменения в каждом участнике в рамках одной глобальной транзакции, а затем просит координатора её закоммитить.

Фаза 1: prepare (голосование)

  1. Координатор шлёт всем участникам PREPARE tx.
  2. Участник проверяет, может ли он закоммитить: ограничения, конфликты, место на диске.
  3. Если может — пишет в свой журнал запись prepared со всеми изменениями, сбрасывает её на диск и только потом отвечает «да». Блокировки на изменённые строки остаются.
  4. Если не может — откатывается и отвечает «нет».

Ответив «да», участник теряет право решать сам. Он не может ни закоммитить, ни откатиться, пока не услышит решение координатора. Даже если перезагрузится: запись prepared в журнале переживает рестарт.

Фаза 2: commit или abort (решение)

  1. Если все ответили «да», координатор пишет в свой журнал commit tx и сбрасывает на диск. Это точка невозврата: с этого момента транзакция закоммичена, даже если ни один участник ещё об этом не знает.
  2. Если хоть один сказал «нет» или не ответил за таймаут — решение abort.
  3. Координатор рассылает решение. Участники применяют его, снимают блокировки и подтверждают (ack).
  4. Получив все ack, координатор может забыть транзакцию.
Координатор              Заказы                 Склад
    | ---- PREPARE ------> |                       |
    | ---- PREPARE --------------------------->    |
    |                  log prepared, fsync    log prepared, fsync
    | <------- YES ------- |                       |
    | <------- YES ----------------------------    |
 log commit, fsync   <-- точка невозврата
    | ---- COMMIT -------> |                       |
    | ---- COMMIT ---------------------------->    |
    | <------- ACK ------- | <------- ACK -------- |

Правила, на которых всё держится

  • Участник пишет prepared на диск до ответа «да». Иначе после рестарта он не вспомнит обещание.
  • Координатор пишет решение на диск до рассылки commit. Иначе после рестарта он может разослать другое решение.
  • Участник, проголосовавший «нет» или ещё не голосовавший, может откатиться сам.
  • Участник, проголосовавший «да», ждёт решения. Сколько угодно долго.

Последнее правило и есть главная проблема 2PC.

Модель на Python

Соберём протокол в игрушечном виде. «Диск» — это список log, он переживает падение. Блокировки — множество ключей, которые нельзя трогать другим транзакциям.

class Crash(Exception): """Узел упал в этой точке.""" class Participant: def __init__(self, name, will_vote_yes=True): self.name = name self.will_vote_yes = will_vote_yes self.log = [] # «диск»: переживает падение self.locked = set() # строки под блокировкой self.data = {} def prepare(self, tx, writes): if not self.will_vote_yes: self.log.append(('abort', tx)) return False self.locked |= set(writes) # держим до решения self.log.append(('prepared', tx, writes)) # fsync до ответа «да» return True def commit(self, tx): _, _, writes = next(r for r in self.log if r[:2] == ('prepared', tx)) self.data.update(writes) self.locked -= set(writes) self.log.append(('commit', tx)) def abort(self, tx): for r in self.log: if r[:2] == ('prepared', tx): self.locked -= set(r[2]) self.log.append(('abort', tx)) def state(self, tx): states = [r[0] for r in self.log if r[1] == tx] return states[-1] if states else 'unknown' class Coordinator: def __init__(self, participants): self.participants = participants self.log = [] def run(self, tx, writes, crash_at=None): votes = [] for p in self.participants: votes.append(p.prepare(tx, writes[p.name])) if crash_at == 'after_prepare': raise Crash decision = 'commit' if all(votes) else 'abort' self.log.append((decision, tx)) # точка невозврата if crash_at == 'after_decision': raise Crash self.send(tx, decision) return decision def send(self, tx, decision): for p in self.participants: if p.state(tx) == 'prepared': getattr(p, decision)(tx) def recover(self, tx): decisions = [r[0] for r in self.log if r[1] == tx] decision = decisions[-1] if decisions else 'abort' # presumed abort self.send(tx, decision) return decision

В реальном протоколе голосование идёт параллельно и с таймаутами, но для понимания хватит последовательного цикла. Прогоним сценарии:

def make(yes=(True, True)): orders = Participant('orders', yes[0]) stock = Participant('stock', yes[1]) return Coordinator([orders, stock]), orders, stock W = {'orders': {'order:42': 'NEW'}, 'stock': {'sku:7': 9}} # 1. Все согласны c, orders, stock = make() print(c.run('tx1', W), orders.data, stock.data) # commit {'order:42': 'NEW'} {'sku:7': 9} # 2. Склад отказал — откатываются все, блокировки сняты c, orders, stock = make(yes=(True, False)) print(c.run('tx2', W), orders.data, orders.locked) # abort {} set() # 3. Координатор упал после prepare c, orders, stock = make() try: c.run('tx3', W, crash_at='after_prepare') except Crash: print(orders.state('tx3'), orders.locked, stock.state('tx3'), stock.locked) # prepared {'order:42'} prepared {'sku:7'} print(c.recover('tx3'), orders.locked) # abort set() # 4. Координатор упал после записи решения c, orders, stock = make() try: c.run('tx4', W, crash_at='after_decision') except Crash: print(orders.state('tx4'), stock.state('tx4')) # prepared prepared print(c.recover('tx4'), orders.data, stock.data) # commit {'order:42': 'NEW'} {'sku:7': 9}

Сценарии 3 и 4 снаружи выглядят одинаково: оба участника в prepared, оба держат блокировки. Но в одном случае правильный исход — abort, в другом — commit. Различить их может только журнал координатора. Пока координатор лежит, участники не знают, что делать.

Обратите внимание на presumed abort в recover: если в журнале координатора нет решения, значит, он упал до точки невозврата, и транзакцию безопасно откатить. Это стандартная оптимизация: abort не нужно писать на диск принудительно, его можно «предположить».

Блокировка при падении координатора

Участник в состоянии prepared называется in doubt (в неопределённости). Он не может:

  • закоммитить сам — вдруг кто-то другой проголосовал «нет» и координатор решил abort;
  • откатиться сам — вдруг координатор уже записал commit и другие участники закоммитили.

Любое самостоятельное решение может нарушить атомарность. Поэтому участник ждёт, а строки под его блокировками недоступны остальным транзакциям. Склад не может продать sku:7, пока координатор не поднимется.

Можно спросить соседей

Участник в неопределённости может опросить других участников (cooperative termination protocol):

def resolve_in_doubt(tx, peers): """Участник в состоянии prepared опрашивает соседей.""" for p in peers: s = p.state(tx) if s in ('commit', 'abort'): return s # кто-то знает исход — делаем так же if s == 'unknown': p.abort(tx) # сосед ещё не голосовал: пусть откажется return 'abort' # без его «да» commit невозможен return 'blocked' # все prepared — ждём координатора

Это помогает, если кто-то уже получил решение или ещё не успел проголосовать. Но в самом неприятном случае — все проголосовали «да», а координатор упал до рассылки — опрос возвращает blocked:

orders, stock = Participant('orders'), Participant('stock') c = Coordinator([orders, stock]) try: c.run('tx3', W, crash_at='after_prepare') except Crash: pass print(resolve_in_doubt('tx3', [stock])) # blocked

Это не недоработка реализации, а свойство протокола: при отказе координатора 2PC блокируется, и никакой хитростью на стороне участников этого не исправить.

Что делают на практике

  • Координатор поднимают быстро и хранят его журнал надёжно. Восстановление по журналу дорабатывает все незавершённые транзакции.
  • Реплицируют сам координатор через консенсус. Так устроены Google Spanner (2PC поверх Paxos-групп) и Paxos Commit Грея и Лэмпорта (2006). Решение пишется не на один диск, а в реплицированный журнал, и падение одного узла не останавливает протокол. О консенсусе — в статье про Raft.
  • Эвристические решения. Администратор вручную коммитит или откатывает зависшую транзакцию. В XA это называется heuristic commit/rollback, и это осознанное нарушение атомарности: потом возможен heuristic mixed — часть участников закоммитила, часть откатила.

3PC: попытка убрать блокировку

Трёхфазный коммит (Dale Skeen, начало 1980-х) добавляет промежуточную фазу между голосованием и коммитом:

  1. CanCommit — голосование, как prepare в 2PC.
  2. PreCommit — координатор сообщает всем: «все согласились, готовьтесь». Участники подтверждают.
  3. DoCommit — финальный коммит.

Смысл в том, что ни один участник не коммитит, пока все не узнали о решении. Поэтому при падении координатора выжившие могут договориться сами: если хоть кто-то в precommit, значит, все голосовали «да», и можно коммитить; если никто — можно откатиться. Плюс таймауты: участник в precommit по таймауту коммитит.

Свойство2PC3PC
Раундов до коммита23
Блокируется при отказе узлаДаНет, если сеть синхронна и узлы падают чисто
Безопасен при разделении сетиДа (но блокируется)Нет: две половины могут принять разные решения
Используется в продакшенеПовсеместноПочти нигде

Подвох в предположениях. 3PC неблокирующий, только если задержки сообщений ограничены и упавший узел нельзя спутать с медленным. В реальной сети это не так: при разделении половина с precommit по таймауту закоммитит, а половина без него откатится. 2PC в такой ситуации просто подождёт и останется корректным. Медленный, но честный протокол обычно лучше быстрого, который иногда врёт, поэтому на практике вместо 3PC реплицируют координатора консенсусом.

XA: 2PC как стандарт

XA — спецификация X/Open (начало 1990-х) для распределённых транзакций: интерфейс между менеджером транзакций и менеджерами ресурсов. Функции xa_start, xa_end, xa_prepare, xa_commit, xa_rollback, xa_recover — это ровно фазы 2PC. В Java поверх XA построен JTA: Atomikos, Narayana, менеджеры транзакций в серверах приложений.

Postgres

Postgres умеет быть участником 2PC, но не координатором — координировать должен внешний менеджер транзакций:

-- по умолчанию max_prepared_transactions = 0, и PREPARE TRANSACTION выключен BEGIN; UPDATE stock SET qty = qty - 1 WHERE sku = 'sku-7'; PREPARE TRANSACTION 'order-42'; -- фаза 1: изменения на диске, блокировки держатся -- транзакция пережила отключение клиента и даже рестарт сервера SELECT gid, prepared FROM pg_prepared_xacts; COMMIT PREPARED 'order-42'; -- фаза 2 -- или ROLLBACK PREPARED 'order-42';

После PREPARE TRANSACTION сессия свободна, но строки остаются заблокированными: другой UPDATE stock ... WHERE sku = 'sku-7' будет ждать, пока кто-то не выполнит COMMIT PREPARED или ROLLBACK PREPARED. Забытая подготовленная транзакция держит блокировки и мешает VACUUM чистить старые версии строк. Поэтому мониторинг pg_prepared_xacts на возраст записей — обязательная часть эксплуатации.

MySQL

XA START 'order-42'; UPDATE stock SET qty = qty - 1 WHERE sku = 'sku-7'; XA END 'order-42'; XA PREPARE 'order-42'; XA COMMIT 'order-42'; -- или XA ROLLBACK 'order-42' XA RECOVER; -- список подготовленных, но не завершённых

XA RECOVER — то, что вызывает менеджер транзакций после рестарта, чтобы найти in-doubt транзакции и довести их до конца.

Где 2PC работает хорошо

  • Внутри одной распределённой базы. Spanner, CockroachDB и Citus коммитят транзакции, затрагивающие несколько шардов, вариантами 2PC. Узлы в одном дата-центре, сеть быстрая, координатор реплицирован, всё под контролем одной команды.
  • Kafka-транзакции внутри устроены похоже: координатор транзакций пишет решение в свой журнал, затем расставляет маркеры коммита в партициях. Но это протокол внутри Kafka, в XA она не участвует.
  • Монолит с двумя ресурсами, например Oracle и IBM MQ через JTA. Классический банковский энтерпрайз.

Почему в микросервисах выбирают сагу и outbox

Доступность перемножается

Транзакция проходит, только если доступны все участники и координатор. Если каждый доступен на 99,9%, то при двух участниках получится 99,8%, при пяти — 99,5%, при десяти — 99,0%. А 99,0% — это уже больше трёх с половиной суток простоя в год вместо девяти часов.

Блокировки на время самого медленного

Строки заблокированы от prepare до получения решения: минимум два сетевых раунда плюс принудительные записи в журнал на каждом узле. Латентность транзакции равна латентности худшего участника, а под нагрузкой блокировки выстраивают очереди.

Связность сервисов

2PC требует, чтобы каждый сервис отдавал наружу свои транзакции и подчинялся чужому координатору. Это противоречит самой идее микросервиса: своя база, свой релизный цикл, никто не держит твои блокировки.

Не все умеют prepare

Большинство брокеров и NoSQL-хранилищ в XA не участвуют. Внешний платёжный шлюз, сервис доставки, письмо клиенту — у них нет состояния «готов, но не сделал». Если хотя бы один шаг не поддерживает prepare, 2PC неприменим целиком.

Что вместо

  • Saga — цепочка локальных транзакций, каждая коммитится сразу. Если шаг упал, выполненные шаги отменяются компенсациями. Цена: нет изоляции, промежуточные состояния видны, компенсации нужно проектировать.
  • Transactional Outbox — событие пишется в таблицу той же базы в той же транзакции, что и данные. Отдельный релей доставляет его в брокер. Вместо распределённой транзакции — локальная плюс at-least-once доставка.
  • Идемпотентность на стороне получателя: раз доставка повторная, обработка дубля не должна ничего ломать.

Логика сдвигается с «все или никто прямо сейчас» на «все в итоге придут к согласованному состоянию». Для большинства бизнес-процессов это приемлемо: пользователю не важно, списали товар через 5 мс или через 500.

Критерий2PC / XASaga + outbox
АтомарностьСтрогаяВ конечном счёте, через компенсации
ИзоляцияЕсть (блокировки)Нет, промежуточные состояния видны
ДоступностьПроизведение доступностей участниковШаги независимы, сбой одного не стопорит остальных
БлокировкиНа время двух раундов и дольшеТолько локальные, короткие
Требования к участникамПоддержка prepare (XA)Локальная транзакция и идемпотентность
СложностьВ инфраструктуреВ бизнес-логике: компенсации, статусы

Как рассказывать на собеседовании

Если в задаче на системный дизайн появляется «списать деньги и создать заказ атомарно», хороший ответ звучит примерно так:

  1. Назвать проблему: две независимые системы, общей транзакции нет.
  2. Упомянуть 2PC: prepare, commit, точка невозврата в журнале координатора.
  3. Сразу назвать цену: блокировка при падении координатора, доступность падает с числом участников, внешние сервисы не умеют prepare.
  4. Предложить сагу с outbox и идемпотентными шагами и объяснить, какие компенсации нужны.
  5. Сказать, где 2PC всё-таки уместен: внутри распределённой базы с реплицированным координатором.

Вопросы, которые спросят дальше

  • Что будет, если участник упал после «да»? После рестарта он прочитает prepared из журнала, восстановит блокировки и спросит координатора о решении.
  • Что будет, если координатор упал до записи решения? После рестарта решения в журнале нет — presumed abort, рассылаем abort.
  • Почему 3PC не используют? Неблокирующим он становится только в синхронной сети. При разделении сети теряет согласованность, а это хуже, чем ожидание.
  • Чем 2PC отличается от консенсуса? Консенсусу (Raft, Paxos) хватает большинства, а 2PC требует согласия всех: любой участник может наложить вето. Это разные задачи, и их комбинируют: 2PC между шардами, консенсус внутри каждого.
  • Какой уровень изоляции у распределённой транзакции? Зависит от участников; 2PC отвечает только за атомарность. Про уровни изоляции — в отдельной статье.

Частые ошибки

  • Путать 2PC с двумя последовательными коммитами. Ключевое — фаза prepare, после которой участник ещё не закоммитил, но уже не может отказаться.
  • Отвечать «да» до записи на диск. Участник перезагрузится и забудет, что обещал.
  • Рассылать commit до записи решения. Координатор после рестарта не узнает, что уже решил.
  • Считать, что таймаут решает проблему. Таймаут у участника до голосования — да, можно откатиться. После голосования «да» откат по таймауту ломает атомарность.
  • Говорить, что 3PC «исправляет» 2PC. Только в модели без разделений сети.
  • Предлагать XA между микросервисами, брокером и внешним API. Брокер и внешний API почти наверняка не поддерживают prepare, и протокол развалится на первом же шаге.
  • Забывать про подготовленные транзакции в Postgres. Зависшая запись в pg_prepared_xacts держит блокировки и не даёт VACUUM работать.

Потренироваться в спокойной обстановке

Все задачи