Все заметки
Программирование

Гонка и select_for_update: два запроса покупают последний билет

Два запроса одновременно читают остаток и продают последний билет дважды. Атомарный UPDATE с F(), select_for_update, nowait, skip_locked, deadlock'и и оптимистическая блокировка через version — с разбором того, что происходит внутри PostgreSQL.

Представьте продажу билетов. Остался последний билет на концерт, и два человека нажимают «Купить» с разницей в несколько миллисекунд. Два воркера Gunicorn берут запросы, оба читают из базы stock = 1, оба решают «хватает», оба записывают stock = 0 и оба создают заказ. База довольна, в логах чисто, а наутро у вас два покупателя на одно место.

Это lost update (потерянное обновление): одна запись молча затирает другую, потому что обе опирались на одно и то же устаревшее чтение. В этой статье разберём именно этот баг: почему очевидный код ломается, как на самом деле работают построчные блокировки PostgreSQL, что делают выражения F() и select_for_update() (с nowait, skip_locked и of), откуда берутся deadlock'и и когда оптимистическая блокировка через колонку version подходит лучше.

Исходные данные: товар и остаток

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

from django.conf import settings
from django.db import models
from django.db.models import Q


class Product(models.Model):
    name = models.CharField(max_length=200)
    price = models.BigIntegerField()  # in tiyin
    stock = models.IntegerField(default=0)
    version = models.PositiveIntegerField(default=0)

    class Meta:
        constraints = [
            models.CheckConstraint(
                condition=Q(stock__gte=0),
                name="product_stock_non_negative",
            ),
        ]


class Order(models.Model):
    product = models.ForeignKey(Product, on_delete=models.PROTECT)
    user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.PROTECT)
    quantity = models.PositiveIntegerField()
    created_at = models.DateTimeField(auto_now_add=True)

CheckConstraint — последний рубеж: что бы ни натворило приложение, PostgreSQL отклонит stock < 0 с IntegrityError. Но от продажи двум людям, когда остаток дважды переходит из 1 в 0, он не спасёт, так что правильная логика в приложении всё равно нужна.

Почему наивная версия ломается

Такой код поначалу появляется почти в каждом проекте:

class OutOfStock(Exception):
    pass


def buy(product_id: int, qty: int, user) -> Order:
    product = Product.objects.get(pk=product_id)
    if product.stock < qty:
        raise OutOfStock
    product.stock -= qty
    product.save()
    return Order.objects.create(product=product, user=user, quantity=qty)

Запустим два параллельных запроса для товара с stock = 1:

Время Запрос A Запрос B
t1 SELECT ... WHERE id = 42 → stock = 1
t2 SELECT ... WHERE id = 42 → stock = 1
t3 UPDATE ... SET stock = 0
t4 UPDATE ... SET stock = 0
t5 создаёт заказ создаёт заказ

Проверка product.stock < qty и запись product.save() — два отдельных шага, а решение принимается в Python на копии данных, которая уже могла устареть. Между t1 и t3 ничто не мешает другому процессу прочитать ту же строку.

Обернуть функцию в transaction.atomic не поможет. На уровне изоляции по умолчанию в PostgreSQL, READ COMMITTED, обычный SELECT не берёт блокировку строки, так что обе транзакции спокойно читают одно и то же значение. Транзакция даёт «всё или ничего», а не «никто больше не трогает эту строку». Есть и вторая ловушка: save() без update_fields записывает все колонки и заодно может затереть изменение цены, которое параллельно сделал администратор.

Механизм: как работают блокировки строк в PostgreSQL

Чтобы это исправить, нужно понять, что делает PostgreSQL, когда двум транзакциям нужна одна и та же строка.

  1. Каждый UPDATE, DELETE и SELECT ... FOR UPDATE берёт блокировку уровня строки на затронутые строки. Блокировка записывается в саму строку (в заголовок кортежа), а не в отдельную таблицу, поэтому блокировка миллионов строк не съедает память.
  2. Блокировки строк держатся до конца транзакции — COMMIT или ROLLBACK. Отпустить раньше нельзя.
  3. Если транзакция B пытается заблокировать строку, уже заблокированную A, B ждёт. Причём ждёт она не саму строку, а ID транзакции A — поэтому в сообщениях о deadlock'е пишут «waits for ShareLock on transaction 9811».
  4. Когда A делает commit, B просыпается. В READ COMMITTED B не использует для этой строки свой старый снимок: она берёт последнюю зафиксированную версию строки и заново проверяет на ней условие WHERE. Если строка больше не подходит, B её пропускает.

Пункт 4 — ключ к самому простому решению. Обычный SELECT во всём этом не участвует: читатели не блокируют писателей, писатели не блокируют читателей. Для пропускной способности это прекрасно, и именно поэтому наивный код сломан.

Уровни блокировок строк в PostgreSQL, от сильного к слабому: FOR UPDATE, FOR NO KEY UPDATE, FOR SHARE, FOR KEY SHARE. Обычный UPDATE, не меняющий ключевые колонки, берёт FOR NO KEY UPDATE. К этому мы ещё вернёмся.

Решение 1: атомарный UPDATE с F()

Если «проверить и изменить» можно выразить одним SQL-запросом, пусть это сделает база:

from django.db import transaction
from django.db.models import F


@transaction.atomic
def buy(product_id: int, qty: int, user) -> Order:
    updated = (
        Product.objects
        .filter(pk=product_id, stock__gte=qty)
        .update(stock=F("stock") - qty)
    )
    if updated == 0:
        raise OutOfStock
    return Order.objects.create(product_id=product_id, user=user, quantity=qty)

Django превращает это в один запрос:

UPDATE "shop_product"
   SET "stock" = ("shop_product"."stock" - 1)
 WHERE "shop_product"."id" = 42
   AND "shop_product"."stock" >= 1;

Проиграем гонку заново. A выполняет UPDATE, блокирует строку 42 и ставит stock = 0. B выполняет тот же UPDATE, натыкается на блокировку A и ждёт. A делает commit. B просыпается, берёт новую версию строки (stock = 0), заново проверяет stock >= 1 — ложь — и обновляет ноль строк. update() возвращает 0, мы бросаем OutOfStock. Никакого чтения в Python, никакого окна.

Если решение помещается в WHERE, явная блокировка не нужна: собственная блокировка строки у UPDATE плюс повторная проверка в READ COMMITTED делают всю работу.

Это самый дешёвый корректный вариант: один round trip, блокировка держится совсем недолго. transaction.atomic всё равно нужен, чтобы списание остатка и создание заказа зафиксировались или откатились вместе.

Небольшая ловушка при использовании F() на экземпляре, а не на queryset:

product = Product.objects.get(pk=42)
product.stock = F("stock") - 1
product.save(update_fields=["stock"])

print(product.stock)  # Django 5.x: CombinedExpression, not a number
product.refresh_from_db(fields=["stock"])
print(product.stock)  # the real value from the database

В Django 5.x после save() в атрибуте остаётся выражение. Если сохранить экземпляр ещё раз, выражение применится повторно, и остаток уменьшится дважды. На какой бы версии вы ни были, refresh_from_db() после такого сохранения делает намерение явным.

Решение 2: select_for_update, когда логика не влезает в один UPDATE

Реальные правила редко состоят из одного условия. Допустим, один пользователь может купить не больше двух билетов на событие. Теперь нужно прочитать остаток, посчитать прошлые заказы пользователя и только потом писать. Здесь нужен select_for_update():

from django.db import transaction
from django.db.models import Sum
from django.db.models.functions import Coalesce

MAX_PER_USER = 2


class LimitExceeded(Exception):
    pass


@transaction.atomic
def buy(product_id: int, qty: int, user) -> Order:
    product = Product.objects.select_for_update().get(pk=product_id)

    if product.stock < qty:
        raise OutOfStock

    bought = Order.objects.filter(product=product, user=user).aggregate(
        total=Coalesce(Sum("quantity"), 0)
    )["total"]
    if bought + qty > MAX_PER_USER:
        raise LimitExceeded

    product.stock -= qty
    product.save(update_fields=["stock"])
    return Order.objects.create(product=product, user=user, quantity=qty)

SQL, который Django отправляет для первой строки:

SELECT "shop_product"."id", "shop_product"."name", ...
  FROM "shop_product"
 WHERE "shop_product"."id" = 42
 LIMIT 21
   FOR UPDATE;

(LIMIT 21 — так get() замечает «вернулось больше одного объекта».) Теперь блокировку берёт само чтение. Запрос B блокируется на этом SELECT, пока A не сделает commit, и затем читает свежую строку с уже уменьшенным остатком. Все покупки товара 42 выстраиваются в очередь через эту одну строку, и это же делает безопасной проверку лимита на пользователя: пока мы держим блокировку, никакой другой заказ на этот товар не создастся.

Важные детали:

  • select_for_update() должен выполняться внутри транзакции. Вне atomic в режиме autocommit Django бросит TransactionManagementError. Queryset'ы ленивые, поэтому важно, где запрос выполняется, а не где он собран.
  • Блокировка живёт до конца самого внешнего блока atomic, а не внутреннего. Вложенный atomic создаёт savepoint и блокировки не отпускает.
  • Используйте save(update_fields=[...]), чтобы писать только то, что изменили.

nowait: ошибка вместо ожидания

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

from django.db import OperationalError, transaction
from psycopg import errors as pg_errors


class Busy(Exception):
    pass


def buy_or_busy(product_id: int, qty: int, user) -> Order:
    try:
        with transaction.atomic():
            product = Product.objects.select_for_update(nowait=True).get(
                pk=product_id
            )
            if product.stock < qty:
                raise OutOfStock
            product.stock -= qty
            product.save(update_fields=["stock"])
            return Order.objects.create(product=product, user=user, quantity=qty)
    except OperationalError as exc:
        if isinstance(exc.__cause__, pg_errors.LockNotAvailable):
            raise Busy from exc
        raise

С nowait=True PostgreSQL добавляет FOR UPDATE NOWAIT и, если строка заблокирована, бросает ошибку с SQLSTATE 55P03 (lock_not_available). Django заворачивает её в OperationalError, а исходное исключение psycopg лежит в __cause__. Проверять причину лучше, чем ловить любую DatabaseError и делать вид, что все они значат «занято». Пример написан под psycopg 3; в psycopg2 класс называется psycopg2.errors.LockNotAvailable.

skip_locked: дай любую свободную строку

Для бронирования, где подходит любое свободное место в зале, ждать заблокированное место нет смысла — берём следующее:

from django.conf import settings
from django.db import models, transaction


class Seat(models.Model):
    event = models.ForeignKey("Event", on_delete=models.CASCADE)
    row = models.PositiveSmallIntegerField()
    number = models.PositiveSmallIntegerField()
    holder = models.ForeignKey(
        settings.AUTH_USER_MODEL,
        null=True,
        blank=True,
        on_delete=models.SET_NULL,
    )


@transaction.atomic
def take_any_seat(event_id: int, user) -> Seat | None:
    seat = (
        Seat.objects.select_for_update(skip_locked=True)
        .filter(event_id=event_id, holder__isnull=True)
        .order_by("row", "number")
        .first()
    )
    if seat is None:
        return None
    seat.holder = user
    seat.save(update_fields=["holder"])
    return seat
SELECT ... FROM "shop_seat"
 WHERE "shop_seat"."event_id" = 7
   AND "shop_seat"."holder_id" IS NULL
 ORDER BY "shop_seat"."row" ASC, "shop_seat"."number" ASC
 LIMIT 1
   FOR UPDATE SKIP LOCKED;

Двадцать параллельных запросов получают двадцать разных мест, не дожидаясь друг друга. На этом же паттерне строятся простые очереди задач поверх PostgreSQL.

Подвох: None здесь не значит «всё распродано». Он значит «нет свободного места, которое прямо сейчас не заблокировано». Если по нему показывать «Билетов нет», можно соврать пользователю, пока другие транзакции вот-вот откатятся. Для честного «распродано» сделайте отдельный обычный подсчёт.

nowait и skip_locked взаимоисключающие: если передать оба, будет ValueError.

Deadlock: когда две блокировки ждут друг друга

Блокировки приносят новый вид отказа. Перевод между кошельками:

from django.conf import settings
from django.db import models, transaction


class Wallet(models.Model):
    owner = models.OneToOneField(settings.AUTH_USER_MODEL, on_delete=models.PROTECT)
    balance = models.BigIntegerField()  # in tiyin


class InsufficientFunds(Exception):
    pass


@transaction.atomic
def transfer(from_id: int, to_id: int, amount: int) -> None:
    src = Wallet.objects.select_for_update().get(pk=from_id)
    dst = Wallet.objects.select_for_update().get(pk=to_id)
    if src.balance < amount:
        raise InsufficientFunds
    src.balance -= amount
    dst.balance += amount
    src.save(update_fields=["balance"])
    dst.save(update_fields=["balance"])

Пользователь 1 переводит деньги пользователю 2, и в тот же момент пользователь 2 — пользователю 1:

Время transfer(1, 2) transfer(2, 1)
t1 блокирует кошелёк 1
t2 блокирует кошелёк 2
t3 хочет кошелёк 2 → ждёт B
t4 хочет кошелёк 1 → ждёт A

Ни одна не может продолжить. PostgreSQL не проверяет deadlock при каждом ожидании: он ждёт deadlock_timeout (по умолчанию 1 секунда), затем запускает детектор, находит цикл и прерывает одну из транзакций:

ERROR:  deadlock detected
DETAIL:  Process 4121 waits for ShareLock on transaction 9811; blocked by process 4122.
         Process 4122 waits for ShareLock on transaction 9810; blocked by process 4121.
HINT:  See server log for query details.

Вторая транзакция продолжает работу. Ничего не испорчено, но один пользователь получил 500, а запрос длился минимум секунду.

Лекарство — единый порядок блокировок. Если каждая транзакция блокирует кошельки по возрастанию pk, цикл образоваться не может: кто первым взял меньший id, того второй и ждёт, не удерживая при этом больший.

@transaction.atomic
def transfer(from_id: int, to_id: int, amount: int) -> None:
    if from_id == to_id:
        raise ValueError("cannot transfer to the same wallet")

    locked = (
        Wallet.objects.select_for_update()
        .filter(pk__in=[from_id, to_id])
        .order_by("pk")
    )
    wallets = {w.pk: w for w in locked}
    src, dst = wallets[from_id], wallets[to_id]

    if src.balance < amount:
        raise InsufficientFunds
    src.balance -= amount
    dst.balance += amount
    src.save(update_fields=["balance"])
    dst.save(update_fields=["balance"])

Один запрос с ORDER BY id ... FOR UPDATE блокирует строки в отсортированном порядке. То же правило работает везде: пачка update() в цикле по несортированным id, Celery-задачи, которые трогают сначала заказ, потом товар, а view — наоборот. Выберите порядок и держитесь его.

Даже при дисциплине deadlock'и и ошибки сериализации всё равно могут появиться (внешние ключи, триггеры, транзакции SERIALIZABLE). Их безопасно повторять — но только всю транзакцию целиком:

import time

from django.db import OperationalError, connection
from psycopg import errors as pg_errors

RETRYABLE = (pg_errors.DeadlockDetected, pg_errors.SerializationFailure)


def with_retry(fn, *args, attempts: int = 3, **kwargs):
    if connection.in_atomic_block:
        raise RuntimeError("with_retry must wrap the outermost transaction")
    for attempt in range(1, attempts + 1):
        try:
            return fn(*args, **kwargs)
        except OperationalError as exc:
            if attempt == attempts or not isinstance(exc.__cause__, RETRYABLE):
                raise
            time.sleep(0.05 * attempt)


with_retry(transfer, 1, 2, 5_000_000)  # 50 000 so'm in tiyin

Повторять внутри внешнего atomic бессмысленно: после ошибки внешняя транзакция уже прервана. И убедитесь, что до commit у функции нет побочных эффектов вне базы (письма, вызовы платёжного провайдера), иначе retry их повторит.

Оптимистическая блокировка: колонка version

Всё, что выше, — пессимистический подход: сначала блокируем, потом работаем. Иногда это невозможно. Администратор открывает форму редактирования товара, думает пять минут и жмёт «Сохранить». Держать блокировку в базе между двумя HTTP-запросами и пятью минутами раздумий нельзя. Тем временем второй администратор поменял цену, и первый молча её затирает.

Оптимистическая блокировка предполагает, что конфликты редки, и лишь обнаруживает их в момент записи. Форма несёт version, с которой она была загружена:

from django.db.models import F


class ConcurrentUpdate(Exception):
    pass


def update_price(product_id: int, new_price: int, expected_version: int) -> None:
    updated = (
        Product.objects
        .filter(pk=product_id, version=expected_version)
        .update(price=new_price, version=F("version") + 1)
    )
    if updated == 0:
        raise ConcurrentUpdate

Если кто-то успел сохранить между делом, version уже ушла вперёд, WHERE ничего не находит, update() возвращает 0, и вы показываете «Товар изменил кто-то другой, обновите страницу». Пока пользователь думает, никакие блокировки не держатся.

Подход Держит блокировку Подходит для Цена при конкуренции
update() + F() на время одного запроса счётчики, остатки, балансы, где правило влезает в WHERE минимальная
select_for_update() до commit многошаговая логика в одном запросе запросы выстраиваются в очередь на горячих строках
nowait до commit UX «занято, попробуйте позже» ошибки вместо ожидания
skip_locked до commit бронь любого свободного объекта, очереди задач нет, но нет и общей картины
колонка version нет долгое редактирование, API с If-Match конфликты всплывают ошибками, пользователь повторяет

Подводные камни в продакшене

  • Сетевые вызовы под блокировкой. Вызов платёжного провайдера или отправка SMS между select_for_update() и commit означает, что строка заблокирована столько, сколько тормозит внешний API. Все остальные покупатели стоят в очереди. Делайте внешний вызов снаружи или через transaction.on_commit().
  • select_related блокирует больше, чем кажется. С join'ами FOR UPDATE блокирует строки во всех присоединённых таблицах. Используйте of:
order = (
    Order.objects.select_related("product")
    .select_for_update(of=("self",))
    .get(pk=order_id)
)

Для nullable-связи select_related строит outer join, а PostgreSQL отказывается делать FOR UPDATE на nullable-стороне; of=("self",) решает и это. - Внешние ключи и сила блокировки. Вставка Order берёт FOR KEY SHARE на строку товара, на который ссылается. Это конфликтует с FOR UPDATE, поэтому другие транзакции, вставляющие заказы на тот же товар, ждут. Если вы не меняете первичный ключ, select_for_update(no_key=True) берёт FOR NO KEY UPDATE, который такие вставки не блокирует. - Бесконечное ожидание. По умолчанию ожидание блокировки ничем не ограничено. Поставьте потолок на транзакцию:

from django.db import connection, transaction

with transaction.atomic():
    with connection.cursor() as cursor:
        cursor.execute("SET LOCAL lock_timeout = '2s'")
    product = Product.objects.select_for_update().get(pk=product_id)
    ...

По таймауту PostgreSQL бросает ту же ошибку 55P03, что и при nowait. - Тесты, которые не видят гонку. TestCase в Django оборачивает каждый тест в транзакцию и гоняет всё через одно соединение, так что баги конкурентности невидимы. Используйте TransactionTestCase с настоящими потоками; у каждого потока своё соединение:

import threading

from django.contrib.auth import get_user_model
from django.db import connection
from django.test import TransactionTestCase

from shop.models import Product
from shop.services import OutOfStock, buy

User = get_user_model()


class BuyRaceTest(TransactionTestCase):
    def test_last_item_is_sold_once(self):
        product = Product.objects.create(name="Ticket", price=100_000, stock=1)
        users = [User.objects.create(username=f"u{i}") for i in range(2)]
        barrier = threading.Barrier(2)
        results = []

        def worker(user):
            try:
                barrier.wait()
                buy(product.pk, 1, user)
                results.append("ok")
            except OutOfStock:
                results.append("out")
            finally:
                connection.close()

        threads = [threading.Thread(target=worker, args=(u,)) for u in users]
        for t in threads:
            t.start()
        for t in threads:
            t.join()

        self.assertCountEqual(results, ["ok", "out"])
        product.refresh_from_db()
        self.assertEqual(product.stock, 0)

Гонка недетерминирована: сломанная версия иногда будет проходить этот тест. Гоняйте его в цикле и воспроизводите руками в двух окнах psql с BEGIN — это самый быстрый способ увидеть, кто кого ждёт. - Измерять, а не гадать. Если подозреваете конкуренцию за блокировки, смотрите pg_stat_activity (wait_event_type = 'Lock') и pg_locks и включите log_lock_waits, чтобы PostgreSQL логировал любое ожидание дольше deadlock_timeout.

Чеклист

  • Есть чтение в Python, а потом запись на его основе? Это кандидат на гонку.
  • Если правило помещается в WHERE, используйте filter(...).update(F(...)) и проверяйте число обновлённых строк.
  • Иначе — select_for_update() внутри transaction.atomic и запись с update_fields.
  • Несколько строк блокируйте в фиксированном порядке (order_by("pk")) одним запросом.
  • Повторяйте deadlock'и и ошибки сериализации вокруг всей транзакции, а не внутри неё.
  • Никаких внешних HTTP-вызовов под блокировкой строк; выставьте lock_timeout.
  • Для редактирования, растянутого на несколько HTTP-запросов, используйте колонку version.
  • Держите CheckConstraint как последнюю страховку.
  • Тестируйте конкурентность через TransactionTestCase с потоками или в двух сессиях psql.

Итог

Гонка — это любое место, где решение принимается на данных, которые могут измениться до записи. Лечение всегда одно: перенести решение туда, где его может обеспечить база, — в WHERE атомарного UPDATE, под блокировку строки через select_for_update() или в проверку версии. Блокируйте в едином порядке, держите блокировки коротко и повторяйте транзакцию целиком, когда PostgreSQL разрывает deadlock.

// комментарии

Загружаем комментарии...

    // следующий шаг

    Давайте построим что-нибудь вместе.

    Написать в Telegram
    aslbek@asldev: ~
    ❯