Параллельные транзакции под нагрузкой грозят потерянными обновлениями и нарушением инвариантов, а репликация и очереди добавляют задержки и повторную обработку. Статья разбирает уровни изоляции (с учётом различий PostgreSQL и MySQL/InnoDB), блокировки, идемпотентность, паттерн Saga и надёжную публикацию событий. Для каждого механизма показана реализация в Laravel: маршрутизация чтений, lockForUpdate(), afterCommit() и компенсации.
При высокой нагрузке несколько транзакций одновременно читают и изменяют общие данные. Это может приводить к потерянным обновлениям, нарушению бизнес-правил и взаимным блокировкам. С появлением реплик, очередей и отдельных сервисов добавляются задержка репликации, повторная обработка сообщений и сложности с согласованием распределённых операций.
TL;DR
- Параллельные транзакции могут приводить к потерянным обновлениям и нарушению бизнес-логики.
- Уровни изоляции защищают от разных аномалий; гарантии PostgreSQL и MySQL/InnoDB различаются.
- Serializable обеспечивает последовательный результат внутри базы, но может требовать повтора транзакции.
- Атомарные обновления, короткие транзакции и единый порядок блокировок снижают риск конфликтов и дедлоков.
- Реплики могут отставать: критичные к актуальности чтения направляйте на основной узел.
- Идемпотентность требует атомарной защиты от повторов; одной проверки состояния задачи недостаточно.
afterCommit()предотвращает запуск задачи до коммита, но для надёжной публикации может понадобиться transactional outbox.- Saga согласует локальные транзакции разных сервисов через сохранение состояния и компенсации, но не даёт общей ACID-изоляции.
- Laravel предоставляет инструменты для маршрутизации чтений, блокировок, повторов транзакций и отложенной отправки задач.
Конкурентный доступ внутри базы данных
Аномалии параллельных транзакций
- Грязное чтение — транзакция видит изменения, которые другая транзакция ещё не зафиксировала. Если последняя откатится, первая будет работать с недействительными данными.
- Неповторяющееся чтение — повторное чтение одной строки в той же транзакции возвращает другое значение после чужого коммита.
- Фантомное чтение — повторный запрос по тому же условию возвращает другой набор строк из-за изменений, зафиксированных параллельной транзакцией.
- Потерянное обновление — две операции вычисляют новое значение на основе одного старого, и результат одной перезаписывает другую.
- Write skew — две транзакции читают общее состояние, затем изменяют разные строки и совместно нарушают бизнес-ограничение. Например, два дежурных врача видят, что второй остаётся на смене, и оба уходят.
Потерянные обновления опасны при работе с балансами и остатками. Write skew возникает там, где ограничение относится сразу к нескольким строкам, а не к одной.
Уровни изоляции
Стандарт SQL определяет четыре уровня изоляции. Таблица показывает минимальные гарантии для классических аномалий; конкретная СУБД может обеспечивать более строгие гарантии.
| Уровень | Грязное чтение | Неповторяющееся чтение | Фантомное чтение |
| Read Uncommitted | Возможно | Возможно | Возможно |
| Read Committed | Нет | Возможно | Возможно |
| Repeatable Read | Нет | Нет | Возможно |
| Serializable | Нет | Нет | Нет |
Read Committed — уровень по умолчанию в PostgreSQL. Обычный SELECT видит снимок данных на начало запроса, поэтому два чтения в одной транзакции могут вернуть разные результаты.
Repeatable Read обеспечивает повторяемость чтений, но его реализация зависит от СУБД. В PostgreSQL уровень реализован через Snapshot Isolation: последовательные чтения используют один снимок, фантомы не появляются, но write skew возможен. При конфликтующем обновлении PostgreSQL может откатить транзакцию с ошибкой сериализации — приложение должно повторить её целиком. В InnoDB обычные чтения используют снимок, а блокирующие чтения и запись имеют другую семантику. Поэтому не стоит считать реализации Repeatable Read взаимозаменяемыми.
Serializable гарантирует, что успешно завершённые транзакции эквивалентны некоторому последовательному порядку выполнения. В PostgreSQL для этого используется Serializable Snapshot Isolation: СУБД отслеживает конфликты и при необходимости завершает транзакцию с SQLSTATE 40001. Приложение должно повторить её целиком. При высокой конкуренции повторы снижают пропускную способность, но выбор уровня зависит от инвариантов и результатов измерений.
Уровень изоляции сам по себе не заменяет проверку конкретного сценария. Например, защита от потерянного обновления зависит от СУБД и способа записи: атомарного UPDATE, блокирующего чтения или операции «прочитать — изменить — сохранить». Гарантии Serializable также требуют, чтобы все операции, участвующие в защите инварианта, соблюдали согласованную стратегию.
Блокировки и повторные попытки
Когда несколько транзакций изменяют одну строку, используют атомарные обновления или блокирующее чтение. SELECT ... FOR UPDATE блокирует выбранные строки до завершения транзакции; конкурирующие операции записи и блокирующего чтения ждут освобождения блокировки. FOR SHARE применяют, когда нужно защитить прочитанные строки от изменения, но он не заменяет эксклюзивную блокировку перед изменением данных.
Блокировки могут привести к дедлоку: транзакция A держит первую строку и ждёт вторую, а транзакция B — наоборот. СУБД прерывает одну из транзакций. Для PostgreSQL код дедлока — 40P01; для MySQL/InnoDB — код ошибки 1213, обычно с SQLSTATE 40001.
Чтобы уменьшить число конфликтов:
- захватывайте ресурсы во всех операциях в одном порядке;
- держите транзакции короткими и не вызывайте внутри них внешние API;
- по возможности заменяйте схему «прочитать — изменить — записать» атомарным
UPDATEс проверкой условия; - для очередей на таблице рассмотрите
SKIP LOCKED: воркер пропустит занятые строки, но получит неполное представление о наборе данных.
Повторяйте прерванную транзакцию целиком, ограничивайте число попыток и при необходимости добавляйте задержку с разбросом. Повторяемый код не должен без защиты выполнять необратимые внешние действия.
Согласованность между компонентами системы
Реплики: задержка чтения
Read/Write Splitting направляет запись на основной узел, а часть чтений — на реплики. Это разгружает основной узел, но требует учитывать ресурсы реплик и нагрузку, которую создаёт сама репликация.
Реплика может отставать: пользователь уже сохранил данные, но следующее чтение возвращает старую версию. Для операций, которым нужна гарантия чтения собственной записи, используйте основной узел или другой механизм контроля актуальности. Чтения, допускающие задержку, можно оставлять на репликах.
Повторная доставка: идемпотентность
Клиент может повторить HTTP-запрос после тайм-аута, а очередь — доставить задачу повторно после сбоя. Идемпотентная операция при повторе с тем же ключом не создаёт новый бизнес-эффект.
Для HTTP-запроса клиент передаёт Idempotency-Key. Сервер атомарно резервирует ключ с помощью уникального ограничения, сохраняет состояние обработки и итоговый ответ. Повтор с тем же ключом возвращает сохранённый результат; пока первая операция выполняется, сервер должен явно обработать состояние «в работе». Повторное использование ключа с другим содержимым запроса следует отклонять.
Для задач очереди одной проверки состояния перед обработкой недостаточно: два воркера могут пройти её одновременно, а процесс может упасть после внешнего действия, но до сохранения результата. Для операций в одной базе используйте транзакцию, блокировку или условное обновление и уникальные ограничения. Для внешнего API передавайте стабильный ключ идемпотентности, если провайдер его поддерживает, и предусмотрите сверку неопределённых результатов.
Несколько сервисов: Saga
Оформление заказа может включать резервирование товара, оплату и создание доставки. Если эти действия выполняются в разных сервисах, локальная транзакция одной базы не делает весь процесс атомарным.
Saga разбивает процесс на локальные транзакции. При неудаче последующего шага система выполняет компенсации для уже завершённых действий — например, освобождает резерв или инициирует возврат платежа. Компенсация не стирает историю и сама может завершиться ошибкой, поэтому ей нужны повторы и обработка исключительных ситуаций.
Есть два способа координации:
- Хореография — сервисы реагируют на события и запускают следующие шаги. Подходит для простых процессов, но общую логику сложнее отслеживать по мере роста числа участников.
- Оркестрация — отдельный компонент хранит состояние процесса и управляет шагами и компенсациями. Поток действий виден в одном месте, но появляется дополнительный компонент.
Сага не обеспечивает изоляцию всего процесса: промежуточные состояния видны другим операциям. Поэтому сохраняйте состояние каждого шага, делайте обработчики и компенсации идемпотентными и защищайте инварианты, например статусом PENDING, запрещающим несовместимые действия. Пользователю показывайте, что операция ещё обрабатывается.
Serializable на каждой локальной базе не создаёт общей распределённой транзакции и не заменяет координацию саги. Уровень изоляции каждой операции выбирают отдельно, исходя из локальных инвариантов и нагрузки.
Надёжная публикация после транзакции
Отправка сообщения до коммита опасна: потребитель может начать работу до появления данных или после отката транзакции. Отложенная отправка после коммита устраняет эту гонку, но не гарантирует доставку: процесс может завершиться между коммитом и отправкой.
Если сообщение нельзя потерять, применяйте transactional outbox: сохраняйте бизнес-изменение и запись об исходящем событии в одной транзакции, а отдельный обработчик публикует событие и повторяет попытку при сбое. Потребитель всё равно должен быть идемпотентным: публикация может повториться.
Реализация в Laravel
Маршрутизация чтений на реплики
В config/database.php задайте отдельные узлы для чтения и записи:
'mysql' => [
'driver' => 'mysql',
'read' => [
'host' => ['192.168.1.10', '192.168.1.11'],
],
'write' => [
'host' => ['192.168.1.5'],
],
'sticky' => true,
// Остальные параметры соединения.
],
Laravel направляет обычные операции чтения на read-соединение, а запись — на write-соединение. Есть исключения: например, чтения в транзакции и блокирующие запросы используют write-соединение.
Параметр sticky направляет последующие чтения на основной узел после записи в рамках текущего цикла работы. Он не гарантирует актуальность в следующем HTTP-запросе. Если конкретному запросу нужны актуальные данные, явно используйте write-соединение:
$user = User::onWriteConnection()->findOrFail($id);
В долгоживущем queue-воркере состояние sticky может сохраниться между задачами. Начиная с Laravel 13.36, можно включить его сброс между задачами:
// app/Providers/AppServiceProvider.php
use Illuminate\Queue\Worker;
public function boot(): void
{
Worker::$flushStickyConnections = true;
}
Сброс выключен по умолчанию. После его включения следующая задача снова может читать с реплики и увидеть устаревшие данные. Если ей нужна запись предыдущей задачи, читайте с основного узла: порядок выполнения в chain или batch сам по себе не устраняет задержку репликации.
Блокировки и повторы транзакций
lockForUpdate() блокирует выбранные строки для изменения, sharedLock() — для разделяемого чтения. Блокирующее чтение и последующая запись должны выполняться в одной транзакции.
Рекомендуется firstOrFail(), чтобы сразу прервать перевод, если один из счетов не найден. Метод выбросит ModelNotFoundException, и транзакция откатится. first() вместо этого вернул бы null: его пришлось бы явно проверить и при отсутствии счёта выбросить исключение, чтобы не обращаться к несуществующей модели и прервать операцию.
Пример перевода между двумя счетами с единым порядком блокировок:
use Illuminate\Support\Facades\DB;
DB::transaction(function () use ($fromId, $toId, $amount) {
if ($fromId === $toId || $amount <= 0) {
throw new InvalidArgumentException('Некорректные параметры перевода');
}
$ids = [$fromId, $toId];
sort($ids);
// Все операции со счетами должны соблюдать тот же порядок.
$accounts = [];
foreach ($ids as $id) {
$accounts[$id] = Account::whereKey($id)->lockForUpdate()->firstOrFail();
}
$from = $accounts[$fromId];
$to = $accounts[$toId];
if ($from->balance < $amount) {
throw new DomainException('Недостаточно средств');
}
$from->decrement('balance', $amount);
$to->increment('balance', $amount);
}, 5);
В примере предполагается, что сумма и баланс представлены в целых минимальных денежных единицах, а идентификаторы приведены к одному типу. Второй аргумент задаёт максимальное число попыток транзакции при обнаруженных Laravel ошибках конкурентного доступа. Проверяйте поддерживаемые ошибки для вашей версии фреймворка и драйвера. Встроенные повторы выполняются без настраиваемого backoff; при необходимости его добавляют снаружи, повторяя всю транзакцию и ограничивая число попыток.
Идемпотентность запросов и задач
Для HTTP API храните ключ, идентификатор клиента, хеш параметров, состояние и ответ в таблице с уникальным ограничением. Резервирование ключа и изменение данных должны быть согласованы транзакцией. Заранее определите поведение для параллельного запроса с тем же ключом и для незавершённой операции после сбоя.
ShouldBeUnique ограничивает постановку одинаковых задач в очередь с помощью блокировки кеша, но не гарантирует, что бизнес-операция выполнится ровно один раз. После освобождения блокировки задача может быть поставлена повторно; кроме того, это ограничение не применяется к задачам внутри batch.
Для операций только в одной базе можно защитить проверку и обработку блокировкой строки:
public function handle(OrderService $service): void
{
DB::transaction(function () use ($service) {
$order = Order::whereKey($this->orderId)
->lockForUpdate()
->firstOrFail();
if ($order->isProcessed()) {
return;
}
// Только изменения в этой базе; отметка также сохраняется до коммита.
$service->processInDatabase($order);
$order->markAsProcessed();
});
}
Методы сервиса и модели здесь условные: они должны сохранять изменения через то же соединение. Для внешних платежей, писем и других побочных эффектов одной блокировки строки недостаточно — используйте идемпотентность внешнего провайдера и надёжную публикацию через outbox.
Отправка задач после коммита
Если задача зависит от данных текущей транзакции, отложите её постановку до коммита:
dispatch(new ProcessOrderJob($orderId))->afterCommit();
Другие варианты — интерфейс ShouldQueueAfterCommit для класса задачи или настройка after_commit для соединения очереди. При откате отложенная задача не будет отправлена. При этом afterCommit() не заменяет outbox, если требуется гарантия публикации после сбоя процесса.
Saga в приложении
Реализация саги должна хранить состояние процесса и шагов, обеспечивать повторный запуск и явно задавать компенсации. Например, пакет splitstack/laravel-conveyor предоставляет контракты компенсации для действий и последовательностей. Перед выбором пакета проверьте его совместимость с вашей версией Laravel, способ хранения состояния, поведение при сбоях и поддержку повторов: не всякая библиотека компенсаций предоставляет устойчивый распределённый оркестратор.
Выбор защитного механизма
| Задача | Основной механизм | Инструменты Laravel |
| Защитить инвариант в одной базе | Ограничение БД, атомарное обновление, блокировка или подходящий уровень изоляции | `DB::transaction()`, `lockForUpdate()` |
| Снизить риск дедлоков | Единый порядок блокировок, короткие транзакции, ограниченный retry | `DB::transaction($callback, $attempts)` |
| Прочитать актуальные данные после записи | Направить критичное чтение на основной узел | `sticky`, `onWriteConnection()` |
| Безопасно обработать повтор | Ключ идемпотентности, уникальное ограничение и атомарное изменение состояния | Транзакции, ограничения БД, `ShouldBeUnique` как дополнительная защита |
| Не запускать задачу до коммита | Отложенная отправка | `afterCommit()`, `ShouldQueueAfterCommit` |
| Не потерять событие после коммита | Transactional outbox и идемпотентный потребитель | Таблица outbox и обработчик очереди |
| Согласовать операции в разных сервисах | Saga, состояние шагов и компенсации | Оркестратор или библиотека компенсаций |
Выбор начинается с инварианта: что именно не должно нарушиться и в какой границе — одной строки, одной базы или нескольких сервисов. После этого можно подобрать уровень изоляции и дополнительные механизмы, а затем проверить их под ожидаемой конкуренцией и сценариями сбоев.