Два запроса бронируют последнее свободное место. Два воркера уменьшают один и тот же остаток товара. Два администратора обновляют один и тот же заказ.
Каждая операция сама по себе может работать корректно, но при одновременном выполнении приводить к неверному результату. В приложениях на Symfony с Doctrine решение требует координации доступа к базе данных и уверенности в том, что ORM работает именно с тем состоянием, которое было фактически заблокировано.
В этой статье в качестве примера рассматривается бронирование мест, однако тот же подход применим к складским остаткам, балансам и защищённым переходам между статусами.
Контекст: PostgreSQL на уровне
READ COMMITTED. Примеры кода упрощены; ссылки ведут на конкретные реализации в репозитории.
Вот состояние гонки, которое будет разбираться в следующих разделах:
Ожидание блокировки строки не повторяет выполненную ранее проверку доступности на уровне приложения.
Главное правило звучит так:
Защищайте всё бизнес-решение целиком: считывайте актуальное состояние в рамках выбранного механизма конкурентности, проверяйте инвариант и фиксируйте соответствующие изменения вместе.
Для разных операций требуются разные механизмы. Прежде чем подробно рассматривать пессимистические блокировки, полезно взглянуть на общую схему принятия решений:
| Задача | Типичный механизм |
|---|---|
| Считать актуальное состояние, проверить несколько условий, затем изменить | Пессимистическая блокировка с SELECT ... FOR UPDATE
|
| Выполнить простой защищённый переход состояния | Условный UPDATE
|
| Обработать редактирование, растянутое на несколько HTTP-запросов | Оптимистическая блокировка |
| Предотвратить параллельное создание одной и той же логической записи |
Ограничение UNIQUE или первичный ключ с ON CONFLICT
|
В остальной части статьи объясняется, почему эти механизмы решают разные проблемы конкурентности и что именно Doctrine добавляет поверх стандартного поведения PostgreSQL.
Почему одной транзакции недостаточно
Рассмотрим типичную операцию вида «чтение–проверка–запись»:
$seat = $seatRepository->find($seatId);
if (!$seat->isAvailable()) {
throw new SeatNotAvailableException($seatId);
}
$seat->holdFor($reservationId);
$entityManager->flush();
Оба запроса могут прочитать AVAILABLE до того, как любой из них запишет свои изменения:
| Шаг | Запрос A | Запрос B |
|---|---|---|
| 1 | Считывает AVAILABLE | Считывает AVAILABLE |
| 2 | Проверка доступности проходит | Проверка доступности проходит |
| 3 | Обновляет владельца на A | Ждёт обновления той же строки |
| 4 | Коммитит транзакцию | Обновляет владельца на B и коммитит транзакцию |
Оборачивание этого кода в транзакцию делает каждую операцию атомарной, но не мешает обеим проверкам доступности завершиться успешно.
PostgreSQL сериализует операции записи. Однако обновление с условием только по WHERE id = :id всё равно может перезаписать предыдущего владельца: его условие остаётся истинным и после ожидания. Приложение приняло бизнес-решение на основе устаревшего состояния. Это соответствует стандартному поведению READ COMMITTED в PostgreSQL.
Ключевое правило: защищайте проверку доступности вместе с операцией записи.
Пессимистическая блокировка: защита всего решения целиком
Для коротких операций, которые считывают сущность, проверяют её состояние и обновляют её, Doctrine предоставляет LockMode::PESSIMISTIC_WRITE .
В PostgreSQL блокирующий запрос использует SELECT ... FOR UPDATE . Конкурирующая транзакция, запрашивающая ту же блокировку, ждёт, пока текущий владелец не выполнит коммит или откат.
Сервис: определение границ транзакции
Транзакция должна охватывать весь юзкейс целиком. Упрощённый метод сервиса выглядит следующим образом:
public function reserve(
string $showId,
string $seatId,
string $reservationId,
): void {
$this->entityManager->wrapInTransaction(function () use (
$showId, $seatId, $reservationId,
): void {
$seat = $this->seatRepository->findForUpdate($showId, $seatId);
if ($seat === null || !$seat->isAvailable()) {
throw new SeatNotAvailableException($seatId);
}
$seat->holdFor($reservationId);
});
}
wrapInTransaction() выполняет flush перед коммитом. Транзакция уже должна быть активна на момент выполнения блокирующего запроса; просто добавить блокировку к обычному вызову репозитория вне транзакции недостаточно.
Контроллер лишь вызывает сервис и маппит результат в HTTP. Это позволяет переиспользовать те же границы транзакции в HTTP, CLI и хэндлерах Messenger.
Внешние HTTP-вызовы и прочие медленные операции держите за пределами блокируемой секции.
Репозиторий: захват блокировки
Метод репозитория содержит блокирующий запрос:
use Doctrine\DBAL\LockMode;
use Doctrine\ORM\Query;
public function findForUpdate(string $showId, string $seatId): ?Seat
{
return $this->createQueryBuilder('s')
->andWhere('s.id = :seatId')
->andWhere('IDENTITY(s.show) = :showId')
->setParameter('seatId', $seatId)
->setParameter('showId', $showId)
->getQuery()
->setLockMode(LockMode::PESSIMISTIC_WRITE)
->setHint(Query::HINT_REFRESH, true)
->getOneOrNullResult();
}
Когда запрос A фиксирует бронь, запрос B захватывает блокировку и проверяет уже забронированное состояние. Если же запрос A откатится, B сможет занять всё ещё доступное место.
Примеры кода: блокирующий запрос и границы транзакции в сервисе.
Doctrine всё ещё может содержать устаревшую сущность
Вышеприведённый запрос включает Query::HINT_REFRESH не просто так.
Doctrine использует identity map: внутри одного EntityManager идентификатор сущности обычно соответствует одному и тому же объекту PHP. Если этот объект был загружен ранее, выполнение другого запроса, как правило, не перезаписывает значения его полей данными, вернувшимися из базы.
Рассмотрим такую последовательность:
- Текущий EntityManager загружает место со статусом
AVAILABLE. - Другая транзакция меняет его на
HELDи делает коммит. - Текущий EntityManager выполняет блокирующий запрос для этого места.
База данных возвращает актуальную заблокированную строку, однако Doctrine может сохранить ранее управляемый объект:
PostgreSQL row: HELD
PHP object: AVAILABLE
Блокировка защищает строку в базе данных, но проверка доступности всё ещё может использовать устаревшее состояние объекта.
HINT_REFRESH заставляет Doctrine обновить уже управляемую сущность данными из результата запроса. Это описано в документации по query hints в Doctrine.
Обновляйте до изменения: refresh может перезаписать незафиксированные изменения (unflushed changes). Если сущность загружается впервые, никакого более раннего управляемого состояния для перезаписи просто нет.
Поэтому блокирующий запрос с обновлением следует рассматривать как границу захвата для агрегата: сначала захватите блокировку и загрузите актуальное состояние, и только потом вносите изменения. Избегайте вызова таких запросов после модификации той же управляемой сущности, если только вы намеренно не хотите сбросить эти незафиксированные изменения.
Захват блокировки → гидрация актуального состояния → валидация → изменение → коммит.
Блокировка после ранее выполненной проверки доступности оставляет возможность для состояния гонки.
Несколько строк: согласованный порядок блокировки
Когда для одной операции требуется несколько строк, захватывайте пессимистические блокировки в строго согласованном порядке. Разный порядок захвата может привести к взаимной блокировке (deadlock):
Transaction A: locks seat 1, waits for seat 2
Transaction B: locks seat 2, waits for seat 1
Каждый конкурирующий путь в коде должен следовать одному и тому же порядку. Сортировка идентификаторов в PHP помогает только в том случае, если репозиторий действительно захватывает блокировки в этой последовательности; порядок значений внутри SQL-конструкции IN (...) этого не гарантирует.
Согласованный порядок снижает вероятность дедлоков для данного набора ресурсов, но не исключает дедлоки на уровне транзакций, затрагивающие другие ресурсы.
Пример кода: упорядоченный захват блокировок.
Ограничивайте время ожидания блокировки запросом
Задайте lock_timeout в рамках допустимого времени ответа операции и примените его с помощью SET LOCAL внутри транзакции.
Таймаут блокировки означает, что операция не смогла получить блокировку вовремя; он не говорит о том, что место недоступно.
Этот таймаут также распространяется на блокировки, неявно получаемые операторами UPDATE и INSERT , включая альтернативные стратегии, описанные ниже.
Выбор стратегии конкурентности для операции
Пессимистическая блокировка удобна, когда короткой транзакции требуется проверить текущие сущности перед их изменением. Но это не единственный вариант.
Условный UPDATE: простые переходы состояния
Для простого перехода состояния перенесите предусловие прямо в запрос на запись:
UPDATE seats
SET state = 'HELD',
held_by_reservation_id = :reservationId
WHERE id = :seatId
AND state = 'AVAILABLE';
Работая с Doctrine DBAL, проверяйте количество затронутых строк. Одна изменённая строка означает, что переход прошёл успешно; ноль — что место не найдено или недоступно.
Для операции с несколькими строками сравните это количество с числом уникальных запрошенных ID и откатите частичные изменения перед коммитом.
Условные обновления всё равно захватывают блокировки и могут ждать. Кроме того, прямой SQL работает в обход управляемого состояния Doctrine, поэтому избегайте принятия дальнейших решений на основе сущностей, которые успели устареть.
Оптимистическая блокировка: редактирование между несколькими HTTP-запросами
Оптимистическая блокировка — отличный выбор, когда конфликты происходят редко, особенно при сценариях редактирования, завязанных на взаимодействие с пользователем.
При наличии поля #[ORM\Version] Doctrine сверяет версию сущности с базой данных во время обновления при вызове flush и выбрасывает OptimisticLockException в случае несовпадения.
В этом случае приложению требуется явная обработка конфликта или политика повторных попыток (retry). Не держите транзакцию базы данных открытой, пока пользователь заполняет форму.
См. раздел поддержки блокировок в Doctrine.
Для редактирования, растянутого на несколько HTTP-запросов, сохраняйте версию, изначально показанную пользователю, и проверяйте эту ожидаемую версию при обработке отправленной формы, например:
$entityManager->lock(
$entity,
LockMode::OPTIMISTIC,
$expectedVersion,
);
Загрузка последней версии сущности при отправке формы и расчёт только на проверку при flush всё ещё может привести к перезаписи изменений, сделанных кем-то, пока форма была открыта.
См. важные замечания по реализации оптимистической блокировки в Doctrine.
Параллельный INSERT: пусть всё решает уникальный ключ
Что делать, если строка ещё не существует?
На уровне READ COMMITTED запрос SELECT ... FOR UPDATE , не нашедший строки, не резервирует этот ключ. Два запроса могут успешно пройти проверку на существование записи и попытаться выполнить вставку.
Определите признак уникальности записи с помощью ограничения UNIQUE или PRIMARY KEY, а затем обработайте ожидаемый дубликат через ON CONFLICT :
INSERT INTO inbox_messages (
consumer_name,
message_id,
message_type,
processed_at
)
VALUES (
:consumerName,
:messageId,
:messageType,
:processedAt
)
ON CONFLICT (consumer_name, message_id) DO NOTHING;
В данном случае первичным ключом является (consumer_name, message_id) .
Используя executeStatement() из DBAL, проверьте количество затронутых строк:
- 1: текущая транзакция зафиксировала право на обработку (claim) и может обрабатывать сообщение.
- 0: claim уже существует; обработку дубликата следует пропустить.
Если другая транзакция выполняет вставку с тем же ключом, PostgreSQL может подождать её завершения. Если она закоммитится, ожидающая вставка пропустит дубликат; если откатится — ожидающая вставка сможет завершиться успешно.
Одна транзакция: фиксируйте claim и изменения базы данных в хэндлере вместе, используя одно и то же соединение. В противном случае закоммиченный claim со сбойной последующей обработкой приведёт к тому, что ретраи будут пропускать незавершённую работу.
DO NOTHING обрабатывает этот ожидаемый конфликт без возникновения ошибки нарушения уникальности.
Используйте DO UPDATE , когда желаемым поведением является обновление существующей записи.
Ни один из вариантов автоматически не проверяет, несут ли дублирующие запросы одну и ту же полезную нагрузку.
См. документацию PostgreSQL по ON CONFLICT.
Пример кода: метод InboxMessageStore::claim() возвращает флаг успешности вставки; middleware вызывает хэндлер только при успешном захвате claim.
Обработка конкуренции и сбоев транзакций
Не каждый конфликт нужно повторять через retry. Уже забронированное место — это корректный бизнес-результат; таймаут блокировки или дедлок — временный инфраструктурный сбой.
В случае временных сбоев повторяйте всю транзакцию целиком, а не только упавший запрос. После отката начните с чистого экземпляра EntityManager в Doctrine и загрузите актуальное состояние заново.
Ограничивайте число попыток повтора в рамках бюджета времени запроса. Немедленные повторные запросы подряд могут усилить конкуренцию (contention), поэтому используйте небольшой лимит ретраев с нарастающей задержкой (backoff) и мониторьте ожидания блокировок, дедлоки и исчерпанные попытки.
Главный вывод
Транзакции, блокировки строк, версионирование полей и ограничения уникальности решают разные задачи в рамках проблемы конкурентного доступа.
Главное — не выбрать самый мощный механизм. Главное — выбрать механизм, защищающий инвариант именно в той точке, где принимается бизнес-решение.
Защищайте всё бизнес-решение целиком: считывайте актуальное состояние в рамках выбранного механизма конкурентности, проверяйте инвариант и фиксируйте соответствующие изменения вместе.

Комментарии (0)
Пока нет комментариев — будьте первым.