Два запроса бронируют последнее свободное место. Два воркера уменьшают один и тот же остаток товара. Два администратора обновляют один и тот же заказ.

Каждая операция сама по себе может работать корректно, но при одновременном выполнении приводить к неверному результату. В приложениях на Symfony с Doctrine решение требует координации доступа к базе данных и уверенности в том, что ORM работает именно с тем состоянием, которое было фактически заблокировано.

В этой статье в качестве примера рассматривается бронирование мест, однако тот же подход применим к складским остаткам, балансам и защищённым переходам между статусами.

 Контекст: PostgreSQL на уровне  READ COMMITTED . Примеры кода упрощены; ссылки ведут на конкретные реализации в репозитории.

Вот состояние гонки, которое будет разбираться в следующих разделах:

mrlfXs45fKb3b9SrZ2qpcYlQjHOzatlcPvnxpQOM.webp

Ожидание блокировки строки не повторяет выполненную ранее проверку доступности на уровне приложения.

Главное правило звучит так:

 Защищайте всё бизнес-решение целиком: считывайте актуальное состояние в рамках выбранного механизма конкурентности, проверяйте инвариант и фиксируйте соответствующие изменения вместе.

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

Задача Типичный механизм
Считать актуальное состояние, проверить несколько условий, затем изменить Пессимистическая блокировка с  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. Если этот объект был загружен ранее, выполнение другого запроса, как правило, не перезаписывает значения его полей данными, вернувшимися из базы.

Рассмотрим такую последовательность:

  1. Текущий EntityManager загружает место со статусом  AVAILABLE .
  2. Другая транзакция меняет его на  HELD  и делает коммит.
  3. Текущий 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) и мониторьте ожидания блокировок, дедлоки и исчерпанные попытки.


Главный вывод

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

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

 Защищайте всё бизнес-решение целиком: считывайте актуальное состояние в рамках выбранного механизма конкурентности, проверяйте инвариант и фиксируйте соответствующие изменения вместе.