К содержимому
Войти

Java Road Map

🔒 Транзакции и уровни изоляции

Транзакция собирает несколько запросов в одно целое: либо применились все, либо ни один. Уровень изоляции решает другой вопрос: что транзакция видит, пока рядом работают другие. Из-за него деньги пропадают со счёта без единой ошибки в логах, а два дежурных врача одновременно уходят домой. На собеседовании мидла это один из самых частых вопросов по базам: назвать аномалии, четыре уровня и объяснить, что из этого реально делает Postgres. Все примеры ниже запущены на PostgreSQL 16 в двух параллельных сессиях

🧠 ACID по буквам

БукваЧто гарантируетКак Postgres это делает
Atomicity, атомарностьтранзакция применяется целиком или никакпри rollback или падении изменения не становятся видимыми
Consistency, согласованностьпосле коммита данные удовлетворяют ограничениямprimary key, foreign key, check, unique проверяются при записи или на коммите
Isolation, изоляцияпараллельные транзакции не мешают друг другуснимки данных (MVCC) и блокировки, степень задаёт уровень изоляции
Durability, долговечностьзакоммиченное не теряется при сбоеперед ответом на commit запись попадает в журнал WAL на диске

Три буквы из четырёх работают сами, и думать о них приходится редко. Изоляция настраивается, и почти все интересные баги живут в ней. Полная изоляция стоит дорого: базе пришлось бы выполнять транзакции по очереди. Поэтому стандарт SQL описывает четыре уровня, и каждый следующий запрещает больше аномалий

🧠 Аномалии

Аномалия — ситуация, когда результат параллельных транзакций не совпадает ни с одним порядком их выполнения по очереди. Дальше пять, которые спрашивают чаще всего

Грязное чтение. Транзакция видит изменения другой, ещё не закоммиченной. Та откатывается, а первая уже приняла решение по данным, которых никогда не было. В Postgres невозможно ни на каком уровне

Неповторяемое чтение. Одна и та же строка, прочитанная дважды в одной транзакции, вернула разные значения, потому что между чтениями кто-то закоммитил update. В Read Committed это обычное дело:

-- сессия A                                    -- сессия B
begin;
select balance from accounts where id = 1;   -- 100
                                               update accounts set balance = 50 where id = 1;
select balance from accounts where id = 1;   -- 50
commit;

Фантомное чтение. То же, но с набором строк: count(*) where user_id = 1 вернул 2, а через секунду 3, потому что другая транзакция вставила заказ. Строки, которых не было, появились как фантомы

Потерянное обновление. Две транзакции читают одно значение, считают новое в приложении и пишут. Вторая запись затирает первую:

-- обе сессии
begin;
select balance from accounts where id = 1;   -- обе видят 100
-- A пишет 100 - 30, B пишет 100 - 20
update accounts set balance = 70 where id = 1;   -- A, commit
update accounts set balance = 80 where id = 1;   -- B ждёт A, потом пишет, commit

В Read Committed итог 80, хотя должно быть 50. Списание на 30 исчезло, ошибок нет. Код «прочитай, посчитай, запиши» есть в любом сервисе, так что аномалия вполне житейская

Write skew, косая запись. Две транзакции читают одно и то же, проверяют условие и меняют разные строки. Каждая по отдельности права, вместе они нарушают правило. Пример из жизни: в больнице на смене должен остаться хотя бы один дежурный. Алиса и Боб одновременно проверяют, сколько дежурных, оба видят двоих и оба снимают себя с дежурства. Строки разные, конфликта записи нет, а дежурных ноль

🧠 Четыре уровня и что делает Postgres

УровеньГрязное чтениеНеповторяемоеФантомыПотерянное обновлениеWrite skew
Read Uncommittedв Postgres нетестьестьестьесть
Read Committedнетестьестьестьесть
Repeatable Readнетнетв Postgres нетнет, ошибкаесть
Serializableнетнетнетнет, ошибканет, ошибка

Первые три колонки — из стандарта SQL. Потерянное обновление и write skew в стандарте не названы, но про них спрашивают не реже. «Нет, ошибка» значит, что база не даст аномалии случиться и откатит одну из транзакций

Как это устроено внутри:

  • Read Uncommitted в Postgres работает как Read Committed. Документация прямо говорит, что внутри реализованы только три уровня
  • Read Committed — уровень по умолчанию. Каждый запрос берёт свежий снимок данных на момент своего старта. Поэтому два одинаковых select в одной транзакции видят разное
  • Repeatable Read берёт снимок один раз на всю транзакцию, и не на begin, а на первом запросе после него. Postgres здесь строже стандарта: фантомов тоже нет, потому что вставки после снимка просто не видны. Это называют snapshot isolation
  • Serializable — тот же снимок плюс отслеживание зависимостей чтения и записи между транзакциями (Serializable Snapshot Isolation, SSI). Postgres запоминает, какие данные транзакция прочитала, и когда чтения и записи соседей складываются в порядок, невозможный при выполнении по очереди, одна из транзакций откатывается

Уровень задают на транзакцию до первого запроса в ней:

begin isolation level repeatable read;
-- или для всех транзакций сессии
set default_transaction_isolation = 'serializable';

У MySQL с InnoDB по умолчанию Repeatable Read, у Postgres Read Committed. И одинаковое название не значит одинаковое поведение: по тестам Hermitage Repeatable Read в InnoDB пропускает потерянное обновление, а в Postgres нет

🛠️ Как это выглядит в Postgres

Read Committed перепроверяет условие

Когда update в Read Committed натыкается на строку, которую меняет другая незакоммиченная транзакция, он ждёт. После коммита соседа Postgres берёт новую версию строки и заново проверяет where. Поэтому условие в самом update защищает от гонки:

-- обе сессии одновременно, на счёте 100
update accounts set balance = balance - 80
where id = 1 and balance >= 80;
-- A: UPDATE 1
-- B: ждёт коммита A, перепроверяет balance >= 80 на значении 20, UPDATE 0

На счёте 20, в минус не ушли. Отсюда первый способ лечить потерянное обновление без смены уровня: считать в SQL, а не в приложении. set balance = balance - 30 и set balance = balance - 20 из двух сессий дали ровно 50

Второй способ — заблокировать строку при чтении через select ... for update. Тогда вторая транзакция ждёт на своём select, пока первая не закоммитит, и читает уже 70. В тесте итог тоже 50. Блокировки строк подробно разобраны на странице «MVCC и блокировки»

Repeatable Read откатывает при конфликте записи

Тот же сценарий «прочитай, посчитай, запиши» в Repeatable Read:

-- B пытается обновить строку, которую A изменила и закоммитила после снимка B
ERROR:  could not serialize access due to concurrent update

Транзакция B откатилась, на счёте 70. Деньги не потеряны, но операцию B надо повторить с начала. А write skew с дежурными на этом уровне проходит: обе транзакции закоммитились, дежурных ноль. Они писали в разные строки, конфликта записи не было

Serializable ловит write skew

begin isolation level serializable;
select count(*) from doctors where on_call;   -- обе видят 2
update doctors set on_call = false where name = 'bob';   -- у Алисы 'alice'
-- у второй транзакции:
ERROR:  could not serialize access due to read/write dependencies among transactions
HINT:  The transaction might succeed if retried.

Алиса ушла, Боб остался. Повтор транзакции Боба увидит одного дежурного и уходить не станет

Повтор транзакции

На Repeatable Read и Serializable ошибки сериализации случаются в штатной работе, и приложение обязано их обрабатывать. У них код SQLSTATE 40001, и по нему приложение понимает, что надо повторить. Повторять нужно всю транзакцию с первого запроса, а не последний update: прочитанные данные устарели

for попытка in 1..3:
    begin isolation level serializable
    прочитать, проверить, записать
    commit → успех, выйти
    ошибка 40001 → rollback, пауза со случайным разбросом, следующая попытка
    другая ошибка → rollback, вернуть ошибку

На Repeatable Read читающие транзакции конфликтов не получают. На Serializable откатиться может и читающая, поэтому для длинного отчёта есть read only deferrable: транзакция один раз подождёт безопасного снимка и дальше работает без накладных расходов SSI и без риска отката

⚖️ Какой уровень выбрать

УровеньКогда братьЧем платишь
Read Committedбольшинство веб-запросов, атомарные update с условиемгонки «прочитай, потом запиши» надо закрывать руками
Repeatable Readотчёт или выгрузка, которым нужен согласованный срез; защита от потерянного обновленияошибки 40001 и повторы
Serializableсложные инварианты по нескольким строкам: лимиты, бронирования, дежурствабольше повторов под нагрузкой, память на отслеживание чтений

На практике сервис живёт на Read Committed, а опасные места закрывает точечно: атомарный update с условием, for update, уникальный индекс или Serializable для одной конкретной операции. Уникальный индекс часто проще всего: двойная бронь одного места на одну дату просто упадёт на unique

⚠️ Где ошибаются

Думают, что транзакция защищает от гонок. begin ... commit даёт атомарность, но на Read Committed не мешает другим транзакциям менять прочитанное. Списание через select, расчёт в коде и update теряет деньги внутри транзакции так же, как без неё

Поднимают уровень и не пишут повтор. Переключить serializable легко, но без обработки 40001 пользователь просто получит 500 там, где раньше получал неверные данные. Повтор обязателен

Повторяют только последний запрос. После ошибки сериализации транзакция уже откачена, и всё, что из неё прочитано, устарело. Повторяют целиком, начиная с begin

Переносят знания с MySQL. Repeatable Read в Postgres и в InnoDB устроен по-разному: в InnoDB обычный select читает снимок, а select for update и update видят свежие данные и ставят gap-блокировки. Ответ на собеседовании стоит начинать с того, о какой базе речь

Держат транзакцию открытой во время сетевого вызова. Транзакция, которая ждёт ответа платёжного шлюза, держит блокировки строк и старый снимок. Внешние вызовы выносят за пределы транзакции

🎯 Вопросы с собеседований

Расшифруй ACID

Атомарность: транзакция применяется целиком или не применяется. Согласованность: после коммита соблюдены все ограничения схемы. Изоляция: параллельные транзакции не видят промежуточных состояний друг друга в той мере, которую задаёт уровень изоляции. Долговечность: закоммиченное переживёт падение сервера, в Postgres за это отвечает журнал WAL

Какие уровни изоляции есть и какой стоит по умолчанию в Postgres?

По стандарту четыре: Read Uncommitted, Read Committed, Repeatable Read, Serializable. В Postgres по умолчанию Read Committed, а Read Uncommitted ведёт себя как Read Committed, так что реально уровней три. Read Committed берёт новый снимок на каждый запрос, Repeatable Read один снимок на всю транзакцию, Serializable добавляет к снимку отслеживание зависимостей и гарантирует результат, как при выполнении по очереди

Чем неповторяемое чтение отличается от фантомного?

Неповторяемое чтение — одна и та же строка при повторном чтении изменилась или исчезла, потому что другая транзакция закоммитила update или delete. Фантомное — запрос с условием вернул другой набор строк, потому что кто-то вставил подходящие. В Postgres оба исчезают на Repeatable Read, хотя по стандарту фантомы там допустимы

Что такое потерянное обновление и как от него защититься?

Две транзакции читают значение, считают новое в приложении и пишут, вторая затирает первую. Защита: считать в самом update (balance = balance - 30), блокировать строку через select for update, сравнивать версию строки при записи (оптимистичная блокировка) или перейти на Repeatable Read, где Postgres откатит вторую транзакцию с ошибкой сериализации

Что такое write skew и на каком уровне Postgres от него защищает?

Две транзакции читают общие данные, каждая проверяет условие и меняет свою строку. По отдельности обе корректны, вместе нарушают инвариант: например, с дежурства уходят оба врача. Конфликта записи нет, поэтому Repeatable Read это пропускает. Из уровней защищает только Serializable. Без смены уровня помогает явная блокировка строк, на которых держится проверка, через select for update

Как Postgres реализует Serializable и почему там нужны повторы?

Через Serializable Snapshot Isolation: транзакции работают со снимками, а Postgres запоминает, что каждая прочитала, предикатными блокировками. Эти блокировки никого не останавливают, они только фиксируют зависимости. Когда зависимости складываются так, что результат может не совпасть ни с одним последовательным порядком, одна транзакция откатывается с SQLSTATE 40001. Postgres перестраховывается и иногда откатывает транзакцию, которая на деле была безопасной, поэтому приложение должно уметь повторить её целиком

Когда в Repeatable Read берётся снимок?

На первом запросе внутри транзакции, а не на begin. Если между begin и первым select другая транзакция закоммитила изменение, оно будет видно. Уровень при этом надо задать до первого запроса, потом его не поменять

Зачем тогда Read Committed, если он пропускает столько аномалий?

Он не откатывает транзакции из-за конфликтов, поэтому приложению не нужны повторы, и под нагрузкой он предсказуем. Большинство запросов веб-сервиса — одиночные чтения и атомарные записи, им хватает. Опасные места закрывают точечно: условием в update, блокировкой строки, уникальным индексом или Serializable для конкретной операции

📚 Что почитать

  • Transaction Isolation — глава документации Postgres про уровни, с примером write skew и текстами ошибок
  • SSI в вики Postgres — разбор сценариев, которые ловит Serializable и пропускает Repeatable Read
  • Hermitage — таблица, какие аномалии реально пропускает каждый уровень в Postgres, MySQL, Oracle и других базах
  • InnoDB Transaction Isolation Levels — как те же уровни устроены в MySQL, чтобы не путать на собеседовании