Двухфазный коммит (2PC): prepare и commit, блокировка координатора, 3PC и XA
Как работает двухфазный коммит: фазы prepare и commit, почему 2PC блокируется при падении координатора, чем не спасает 3PC, XA в Postgres и MySQL и почему в микросервисах берут сагу и outbox.
Коротко
| Вопрос | Ответ |
|---|---|
| Какую задачу решает | Атомарный коммит поверх нескольких ресурсов: либо все участники применили изменения, либо ни один |
| Как устроен | Фаза 1 — prepare: участники голосуют «да/нет» и обещают выполнить решение. Фаза 2 — координатор рассылает его |
| Главный недостаток | Блокирующий протокол: если координатор упал после prepare, участники ждут его, держа блокировки |
| Цена | Два раунда сообщений, принудительные записи в журнал на каждом узле, доступность = произведение доступностей |
| Где живёт | Внутри распределённых БД (Spanner, Citus), XA между базами и очередями в монолитах на Java |
| Что берут в микросервисах | Сагу и Transactional Outbox: локальные транзакции и повторная доставка |
На собеседовании 2PC спрашивают не ради того, чтобы вы его внедрили, а чтобы проверить: понимаете ли вы, почему он блокируется и чем за это платите.
Задача: атомарность поверх двух баз
Заказ хранится в одной базе, остатки на складе — в другой. Нужно создать заказ и списать товар так, чтобы не получилось «заказ есть, товар не списан» или наоборот.
Внутри одной базы это решает обычная транзакция: BEGIN ... COMMIT, журнал упреждающей записи и атомарный флаг коммита. Поверх двух баз так нельзя. Если закоммитить сначала первую, а вторая откажет (нарушен CHECK (qty >= 0), упал узел, истёк таймаут), первую уже не откатить: коммит необратим.
Значит, нужен шаг, на котором каждый участник ещё ничего не зафиксировал, но уже гарантировал, что сможет зафиксировать. Это и есть идея двухфазного коммита: разделить «готов» и «сделал».
Как работает 2PC
Есть координатор (transaction manager) и участники (resource managers — базы, брокеры). Клиент выполняет изменения в каждом участнике в рамках одной глобальной транзакции, а затем просит координатора её закоммитить.
Фаза 1: prepare (голосование)
- Координатор шлёт всем участникам
PREPARE tx. - Участник проверяет, может ли он закоммитить: ограничения, конфликты, место на диске.
- Если может — пишет в свой журнал запись
preparedсо всеми изменениями, сбрасывает её на диск и только потом отвечает «да». Блокировки на изменённые строки остаются. - Если не может — откатывается и отвечает «нет».
Ответив «да», участник теряет право решать сам. Он не может ни закоммитить, ни откатиться, пока не услышит решение координатора. Даже если перезагрузится: запись prepared в журнале переживает рестарт.
Фаза 2: commit или abort (решение)
- Если все ответили «да», координатор пишет в свой журнал
commit txи сбрасывает на диск. Это точка невозврата: с этого момента транзакция закоммичена, даже если ни один участник ещё об этом не знает. - Если хоть один сказал «нет» или не ответил за таймаут — решение
abort. - Координатор рассылает решение. Участники применяют его, снимают блокировки и подтверждают (ack).
- Получив все 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-х) добавляет промежуточную фазу между голосованием и коммитом:
- CanCommit — голосование, как prepare в 2PC.
- PreCommit — координатор сообщает всем: «все согласились, готовьтесь». Участники подтверждают.
- DoCommit — финальный коммит.
Смысл в том, что ни один участник не коммитит, пока все не узнали о решении. Поэтому при падении координатора выжившие могут договориться сами: если хоть кто-то в precommit, значит, все голосовали «да», и можно коммитить; если никто — можно откатиться. Плюс таймауты: участник в precommit по таймауту коммитит.
| Свойство | 2PC | 3PC |
|---|---|---|
| Раундов до коммита | 2 | 3 |
| Блокируется при отказе узла | Да | Нет, если сеть синхронна и узлы падают чисто |
| Безопасен при разделении сети | Да (но блокируется) | Нет: две половины могут принять разные решения |
| Используется в продакшене | Повсеместно | Почти нигде |
Подвох в предположениях. 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 / XA | Saga + outbox |
|---|---|---|
| Атомарность | Строгая | В конечном счёте, через компенсации |
| Изоляция | Есть (блокировки) | Нет, промежуточные состояния видны |
| Доступность | Произведение доступностей участников | Шаги независимы, сбой одного не стопорит остальных |
| Блокировки | На время двух раундов и дольше | Только локальные, короткие |
| Требования к участникам | Поддержка prepare (XA) | Локальная транзакция и идемпотентность |
| Сложность | В инфраструктуре | В бизнес-логике: компенсации, статусы |
Как рассказывать на собеседовании
Если в задаче на системный дизайн появляется «списать деньги и создать заказ атомарно», хороший ответ звучит примерно так:
- Назвать проблему: две независимые системы, общей транзакции нет.
- Упомянуть 2PC: prepare, commit, точка невозврата в журнале координатора.
- Сразу назвать цену: блокировка при падении координатора, доступность падает с числом участников, внешние сервисы не умеют prepare.
- Предложить сагу с outbox и идемпотентными шагами и объяснить, какие компенсации нужны.
- Сказать, где 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 работать.