Гонка и 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, когда двум транзакциям нужна одна и та же строка.
- Каждый
UPDATE,DELETEиSELECT ... FOR UPDATEберёт блокировку уровня строки на затронутые строки. Блокировка записывается в саму строку (в заголовок кортежа), а не в отдельную таблицу, поэтому блокировка миллионов строк не съедает память. - Блокировки строк держатся до конца транзакции —
COMMITилиROLLBACK. Отпустить раньше нельзя. - Если транзакция B пытается заблокировать строку, уже заблокированную A, B ждёт. Причём ждёт она не саму строку, а ID транзакции A — поэтому в сообщениях о deadlock'е пишут «waits for ShareLock on transaction 9811».
- Когда A делает commit, B просыпается. В
READ COMMITTEDB не использует для этой строки свой старый снимок: она берёт последнюю зафиксированную версию строки и заново проверяет на ней условие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.
// комментарии
Загружаем комментарии...