Системный дизайн бронирования билетов: резерв мест, конкурентность и очередь ожидания
Как спроектировать сервис продажи билетов уровня Ticketmaster: резерв места с TTL, защита от двойной продажи, оплата, карта зала, виртуальная очередь ожидания и пиковые продажи.
Коротко
| Вопрос | Решение в этом разборе |
|---|---|
| Главный инвариант | Одно место продаётся ровно одному покупателю |
| Как держим место | Временный резерв с TTL (обычно 5–10 минут), пока человек платит |
| Как избегаем гонок | Атомарный условный UPDATE ... WHERE status = 'free' в ACID-базе, без распределённых блокировок |
| Что делать с пиком | Виртуальная очередь ожидания перед сайтом: пускаем столько, сколько выдержит бронирование |
| Что масштабируем отдельно | Каталог и карту зала (чтение, кэш) и бронирование (запись, строгая согласованность) |
- Задача выглядит как CRUD, но интервьюер проверяет одно: как вы поведёте себя, когда 100 000 человек одновременно жмут на одно и то же место.
- Резерв — это не блокировка в памяти, а состояние строки в базе со сроком годности. Просроченный резерв просто считается свободным, отдельный «уборщик» не обязателен.
- Очередь ожидания нужна не для красоты: она превращает непредсказуемый всплеск в ровный поток, который база точно переварит.
Шаг 1. Требования
Начните с уточнений. Под «Ticketmaster» могут понимать что угодно — от кинотеатра до стадиона на 80 000 мест.
| Вопрос | Ответ интервьюера | Что это меняет |
|---|---|---|
| Места с номерами или танцпол? | и то, и другое | две модели инвентаря: конкретное место и счётчик |
| Можно выбрать место на схеме? | да, плюс кнопка «лучшие доступные» | нужна карта зала с почти актуальной занятостью |
| Сколько мест в одном заказе? | до 6 | резерв нескольких мест должен быть атомарным |
| Сколько времени на оплату? | 10 минут | TTL резерва, таймер на клиенте |
| Бывают продажи «на хайпе»? | да, стадионные туры распродаются за час | очередь ожидания, защита от ботов |
| Перепродажа, динамические цены? | вне рамок | не усложняем |
Нефункциональные требования назовите сами:
- Никакой двойной продажи. Это жёсткий инвариант: два человека с билетами на одно место у входа — инцидент.
- Строгая согласованность для бронирования, eventual consistency для просмотра. Схема зала может отставать на пару секунд: максимум человек кликнет в место, которое уже заняли, и получит понятную ошибку.
- Честность. Кто раньше пришёл, тот раньше выбирает. Боты не должны выкупать всё за секунды.
- Доступность под пиком. Лучше показать «вы в очереди, ожидание 12 минут», чем отдать 502.
Шаг 2. Оценка нагрузки
Допущения для крупной площадки:
- 50 000 событий в день по всей системе, в среднем 2 000 мест на событие.
- Обычный день: 2 млн проданных билетов в сутки.
- Горячее событие: стадион на 60 000 мест, на старт продаж пришли 2 млн человек.
| Параметр | Расчёт | Результат |
|---|---|---|
| Средний поток бронирований | 2 млн / 86 400 | около 25 в секунду |
| Строк в таблице мест в день | 50 000 × 2 000 | 100 млн |
| Желающих на одно горячее место | 2 млн / 60 000 | больше 30 |
| Запросов к карте зала на старте | 2 млн × обновление раз в 5 с | около 400 000 в секунду |
Выводы:
- Средняя нагрузка смешная. Систему ломает не она, а несколько горячих событий в год.
- Чтение и запись несоизмеримы. Смотрят карту зала в тысячи раз чаще, чем бронируют. Их надо разделить.
- На одно место претендуют десятки людей. Значит, конфликты не редкость, а норма, и стратегия «попробовать и откатить» должна быть дешёвой.
Как прикидывать такие цифры, разобрано в статье про оценки на салфетке.
Шаг 3. API
GET /events?city=...&date=... — каталог, поиск GET /events/{id}/seatmap — схема зала и занятость POST /events/{id}/holds — зарезервировать места { "seats": ["A5", "A6"] } -> { "hold_id", "expires_at" } DELETE /holds/{hold_id} — отпустить резерв POST /holds/{hold_id}/checkout — перейти к оплате Idempotency-Key: <uuid> GET /orders/{id} — статус заказа и билеты
Резерв — отдельный ресурс со своим идентификатором и сроком годности. Это упрощает всё остальное: оплата ссылается на hold_id, таймер на клиенте показывает expires_at, повторный клик не создаёт второй резерв. Заголовок Idempotency-Key на оплате защищает от двойного списания при ретраях, подробнее — в статье об идемпотентности.
Шаг 4. Модель данных
Место в рамках события проходит через маленький конечный автомат:
free ──hold──> held ──pay──> sold ^ │ └──expire/cancel┘
Минимальная схема:
CREATE TABLE seats ( event_id BIGINT, seat_id TEXT, -- 'A5', 'сектор 12, ряд 3, место 7' status TEXT NOT NULL, -- free / held / sold holder TEXT, -- id резерва или пользователя hold_until TIMESTAMPTZ, version INT NOT NULL DEFAULT 0, PRIMARY KEY (event_id, seat_id) ); CREATE TABLE orders ( order_id UUID PRIMARY KEY, event_id BIGINT, user_id BIGINT, seats TEXT[], status TEXT, -- pending / paid / failed / refunded created_at TIMESTAMPTZ );
Строки мест создаются при публикации события: для зала на 2 000 мест это 2 000 строк. Для стадиона — 60 000, тоже нормально.
Танцпол без номеров устроен иначе: вместо строк мест — счётчик.
UPDATE ga_inventory SET available = available - :qty WHERE event_id = :id AND available >= :qty;
Если затронута одна строка — места есть. Но счётчик — это одна горячая строка, за которую бьются все. На пике её режут на несколько «вёдер» по 1 000 билетов и раздают покупателей по вёдрам.
Шаг 5. Резерв места: где возникает гонка
Наивный код выглядит так:
seat = db.query("SELECT status FROM seats WHERE ...") if seat.status == 'free': db.execute("UPDATE seats SET status = 'held' ...")
Между SELECT и UPDATE другой запрос успевает прочитать тот же free. Оба обновят строку, оба получат «успех», место продано дважды. Это классическая гонка check-then-act, и на интервью её ждут именно здесь.
Варианты решения:
| Подход | Как работает | Минусы |
|---|---|---|
SELECT ... FOR UPDATE | строка блокируется до конца транзакции | очередь из 30 ждущих транзакций на одной строке, долгие локи |
Оптимистическая блокировка по version | UPDATE ... WHERE version = :v, при 0 строк — повтор | при высокой конкуренции много пустых попыток |
Условный UPDATE по статусу | UPDATE ... WHERE status = 'free', проверка и запись — одно действие | почти нет; это и есть рекомендуемый вариант |
| Распределённая блокировка в Redis | SET lock:seat NX PX, потом запись в базу | лишний компонент, проблемы с TTL и failover |
Разница между подходами подробно разобрана в статье про оптимистичную и пессимистичную блокировку. Для бронирования мест лучше всего работает третий вариант: база сама гарантирует, что условие проверяется и строка меняется атомарно. Нам не нужно «знать», свободно ли место, — мы просим базу занять его, только если оно свободно, и смотрим, сколько строк изменилось.
Ниже рабочая модель на SQLite. 50 потоков одновременно пытаются занять место A5:
import sqlite3 import threading import time DB = 'tickets.db' def setup(): conn = sqlite3.connect(DB) conn.executescript(''' DROP TABLE IF EXISTS seats; CREATE TABLE seats ( event_id INTEGER, seat_id TEXT, status TEXT NOT NULL DEFAULT 'free', -- free / held / sold holder TEXT, hold_until REAL, version INTEGER NOT NULL DEFAULT 0, PRIMARY KEY (event_id, seat_id) ); ''') conn.executemany( 'INSERT INTO seats (event_id, seat_id) VALUES (1, ?)', [(f'A{i}',) for i in range(1, 11)], ) conn.commit() conn.close() def hold_seat(conn, event_id, seat_id, user, ttl=600): now = time.time() # Атомарный условный UPDATE: место свободно или чужой резерв истёк cur = conn.execute( '''UPDATE seats SET status = 'held', holder = ?, hold_until = ?, version = version + 1 WHERE event_id = ? AND seat_id = ? AND (status = 'free' OR (status = 'held' AND hold_until < ?))''', (user, now + ttl, event_id, seat_id, now), ) conn.commit() return cur.rowcount == 1 def confirm(conn, event_id, seat_id, user): # Продаём, только если резерв всё ещё наш и не истёк cur = conn.execute( '''UPDATE seats SET status = 'sold' WHERE event_id = ? AND seat_id = ? AND status = 'held' AND holder = ? AND hold_until >= ?''', (event_id, seat_id, user, time.time()), ) conn.commit() return cur.rowcount == 1 setup() winners = [] lock = threading.Lock() def worker(user): conn = sqlite3.connect(DB, timeout=10) if hold_seat(conn, 1, 'A5', user): with lock: winners.append(user) conn.close() threads = [threading.Thread(target=worker, args=(f'user{i}',)) for i in range(50)] for t in threads: t.start() for t in threads: t.join() print('Резерв получили:', len(winners)) conn = sqlite3.connect(DB) print('Чужой confirm:', confirm(conn, 1, 'A5', 'intruder')) print('Свой confirm:', confirm(conn, 1, 'A5', winners[0])) # Резерв с истёкшим TTL перехватывается print('A6 user1:', hold_seat(conn, 1, 'A6', 'user1', ttl=-1)) print('A6 user2:', hold_seat(conn, 1, 'A6', 'user2')) print('A6 user1 confirm:', confirm(conn, 1, 'A6', 'user1'))
Вывод:
Резерв получили: 1 Чужой confirm: False Свой confirm: True A6 user1: True A6 user2: True A6 user1 confirm: False
Обратите внимание на последние три строки. user1 получил резерв, но его срок истёк, место перехватил user2, и попытка user1 подтвердить покупку отклонена. Проверка holder = ? AND hold_until >= ? в confirm обязательна: без неё опоздавший покупатель «продаст» себе место, которое уже принадлежит другому.
Несколько мест в одном заказе
Человек выбрал A5 и A6. Если A5 занять удалось, а A6 нет, резерв A5 надо отпустить. Проще всего сделать это одной транзакцией:
BEGIN; UPDATE seats SET status = 'held', holder = :hold_id, hold_until = now() + interval '10 minutes' WHERE event_id = :e AND seat_id = ANY(:seats) AND (status = 'free' OR hold_until < now()); -- если изменено строк меньше, чем len(:seats) — ROLLBACK, иначе COMMIT COMMIT;
Все места события лежат в одном шарде (шардируем по event_id), поэтому распределённая транзакция не нужна. Чтобы две транзакции, берущие пересекающиеся наборы мест, не попали в дедлок, места внутри запроса упорядочивают по seat_id.
Кнопка «лучшие доступные места»
Пользователю на танцпол не нужно выбирать, а на трибуну хочется сидеть рядом. Задача «найти свободных мест подряд в ряду» — это проход скользящим окном по ряду, на ряд:
def best_block(row, k): """Индекс начала первого блока из k подряд свободных мест или -1.""" run = 0 for i, seat in enumerate(row): run = run + 1 if seat == '.' else 0 if run == k: return i - k + 1 return -1 row = 'XX..X...XX....X' # X — занято, . — свободно print(best_block(row, 2)) # 2 print(best_block(row, 3)) # 5 print(best_block(row, 4)) # 10 print(best_block(row, 5)) # -1
В реальности ряды перебирают по убыванию «качества» (ближе к сцене и центру), а найденный блок сразу пытаются зарезервировать тем же условным UPDATE. Не получилось — кто-то успел раньше — ищем следующий.
Шаг 6. Истечение резерва
Резерв, за который не заплатили, должен вернуться в продажу. Есть три способа:
- Ленивое истечение. Просроченный
heldсчитается свободным прямо в условииUPDATE(как в коде выше). Ничего не надо запускать по расписанию, и место освобождается ровно в момент истечения. - Фоновая уборка. Раз в минуту
UPDATE seats SET status = 'free' WHERE status = 'held' AND hold_until < now(). Нужна, чтобы карта зала показывала правильную картину, а не «занято» на просроченных местах. - Отложенные сообщения. При создании резерва в очередь кладут задачу «проверить через 10 минут». Удобно, если по истечении нужно ещё что-то сделать: отменить заказ, уведомить пользователя.
Хорошая комбинация — ленивое истечение для корректности плюс уборка для красоты карты. Тогда сбой уборщика не ломает продажи.
Часы. Время истечения считает база (now() на сервере БД), а не приложение. Иначе два сервера с расхождением часов в пару секунд по-разному решат, истёк ли резерв.
Резерв на сервере, таймер на клиенте. Таймер в браузере — только подсказка. Когда пользователь жмёт «оплатить» на 9:59, до сервера запрос дойдёт уже после истечения, и это нормально: ответ «время вышло, места снова в продаже» лучше, чем двойная продажа. Некоторые сервисы дают льготные 30–60 секунд, если оплата уже началась: hold_until продлевается при переходе в checkout.
Шаг 7. Оплата
Оплата — самый медленный и ненадёжный шаг. Внешний платёжный провайдер отвечает за секунды, а с 3-D Secure — за минуту. Держать транзакцию базы открытой всё это время нельзя.
Поэтому бронирование и оплата разделены:
POST /holds/{id}/checkoutсоздаёт заказ в статусеpendingи продлевает резерв на время оплаты.- Клиент платит через провайдера.
- Вебхук провайдера (или опрос статуса) переводит заказ в
paid, места — вsoldусловнымUPDATEс проверкойholder. - Если места к этому моменту уже ушли (резерв истёк, а провайдер ответил через 20 минут), делаем автоматический возврат денег.
Это маленькая сага с компенсацией, про сам паттерн есть отдельная статья, а про устройство платежей — разбор платёжной системы. Вебхуки приходят повторно, поэтому их обработка тоже идемпотентна: повторный paid для уже оплаченного заказа ничего не меняет.
Билет выпускается после sold: генерируем уникальный штрихкод или QR, подписываем его, кладём в заказ и отправляем письмо асинхронно через очередь.
Шаг 8. Карта зала и каталог
Каталог (события, площадки, цены) — классическая read-heavy часть: реплики базы, поисковый индекс, CDN для картинок, кэш на минуты.
Карта зала сложнее: её занятость меняется каждую секунду. Решение — разделить статику и динамику:
- Геометрия зала (секторы, ряды, координаты мест) не меняется и отдаётся с CDN.
- Занятость — компактный битовый массив по местам события. 60 000 мест — это 60 000 бит, меньше 8 КБ. Его держат в Redis и отдают всем с кэшем на 1–2 секунды.
- Обновления можно пушить через WebSocket или SSE, но на горячем событии проще и дешевле опрос раз в несколько секунд: подписка 2 млн соединений на одно событие — отдельная инженерная задача. Сравнение подходов — в статье WebSocket vs long polling.
Ключевая мысль, которую стоит проговорить: карта может врать, бронирование — нет. Источник истины — таблица seats, а кэш только помогает не кликать в заведомо занятые места.
Шаг 9. Виртуальная очередь ожидания
Теперь главное. В 10:00 открываются продажи стадионного тура, и приходят 2 млн человек. Если пустить всех сразу:
- база бронирования получает сотни тысяч конфликтующих
UPDATEв секунду на одни и те же 60 000 строк; - карта зала устаревает быстрее, чем обновляется, люди кликают в занятые места и повторяют попытки;
- ретраи умножают нагрузку, сервис падает, а очередь из разочарованных людей — главный репутационный риск. Хрестоматийный пример — предпродажа The Eras Tour Тейлор Свифт в ноябре 2022 года, когда Ticketmaster не справился с наплывом покупателей.
Решение — комната ожидания (waiting room) перед бронированием:
Пользователь ──> Edge / CDN ──> Waiting room ──(пропуск)──> Сервис бронирования │ Redis: очередь, счётчик впущенных
Как она работает:
- До старта продаж все пришедшие попадают в «предбанник». В момент старта каждому присваивается случайная позиция: так честнее, чем по времени прихода, и бессмысленно держать открытыми 50 вкладок за час до старта.
- Позиции хранятся в Redis sorted set:
ZADD queue:<event> <position> <user>. Позиция пользователя —ZRANK. - Контроллер впуска с постоянной скоростью (например, 2 000 человек в минуту) выдаёт следующей пачке токен доступа: подписанный JWT с
event_id,user_idи сроком жизни. - Сервис бронирования принимает запросы только с валидным токеном. Проверка подписи без похода в базу стоит микросекунды.
- Клиент в очереди опрашивает свою позицию раз в 10–30 секунд, и ответы отдаются из Redis или даже кэшируются на edge.
Скорость впуска — главная ручка. Её подбирают не по тому, сколько выдержит сайт, а по тому, сколько людей реально успевают выбрать места: если впустить 50 000 человек на 60 000 мест, многие будут драться за лучшие сектора и упираться в конфликты. Часто впуск адаптивный: чем меньше осталось мест и чем больше активных сессий, тем медленнее. Когда места кончились — очередь честно сообщает «билетов нет», а не держит людей зря.
Это та же идея, что и ограничение частоты запросов, только с честным порядком: вместо 429 пользователь получает номер в очереди и время ожидания.
Шаг 10. Боты и перекупщики
Без защиты горячие билеты уходят скриптам за секунды. Слои защиты:
- Лимит на аккаунт и карту: не больше 6 билетов на событие, проверка при оплате.
- Верифицированные фанаты: регистрация заранее, отбор и персональные коды доступа на предпродажу.
- Rate limiting по IP, аккаунту, устройству; капча при подозрительной активности.
- Токен доступа привязан к сессии: его нельзя передать другому клиенту.
- Короткий TTL резерва на горячих событиях: ботам невыгодно держать места «про запас».
Шаг 11. Масштабирование
- Шардирование по
event_id. Все места события в одном шарде, атомарный резерв нескольких мест остаётся локальной транзакцией. Подробнее — в статье о шардировании и репликации. - Горячий шард. Одно стадионное событие может перегрузить свой шард. Помогают очередь ожидания (главное) и вынос событий-хедлайнеров на выделенные узлы заранее: о старте продаж известно за недели.
- Чтение с реплик для каталога и истории заказов, но не для проверки свободных мест перед резервом.
- Redis вместо базы для резерва? Можно держать горячие места в Redis (
SET seat:<e>:<s> <hold> NX EX 600) и синхронизировать с базой. Это быстрее, но появляются два источника истины и вопрос, что будет при failover Redis без синхронной репликации. Риски такого подхода хорошо видны на примере распределённых блокировок. На интервью лучше начать с базы и честно сказать, когда и зачем переходить на Redis.
Типичные ошибки
- Check-then-act:
SELECTстатуса, потомUPDATE. Гонка гарантирована. - Резерв в памяти приложения. Перезапуск инстанса — и все резервы потеряны, а другой инстанс о них не знал с самого начала.
- Нет проверки владельца при подтверждении. Истёкший резерв подтверждается и продаёт место, уже отданное другому.
- Таймер только на клиенте. Сервер обязан сам знать
hold_until. - Транзакция базы открыта на время оплаты. Локи держатся минутами, пропускная способность падает до нуля.
- Карта зала читается из основной базы. Сотни тысяч запросов в секунду ложатся туда же, где идут резервы.
- Нет плана на пик. Если вы не произнесли «очередь ожидания», интервьюер почти наверняка спросит сам.
Как рассказывать на собеседовании
- Требования: места с номерами и без, TTL резерва, лимит на заказ, ожидаемый пик. Сформулируйте инвариант: место продаётся один раз.
- Оценка: средняя нагрузка мала, проблема — горячие события; чтение на порядки больше записи.
- API и конечный автомат места
free → held → sold. - Конкурентность: покажите гонку check-then-act и решите её условным
UPDATE. УпомянитеFOR UPDATEи optimistic locking как альтернативы и почему они хуже. - Истечение резерва, оплата как сага, идемпотентность вебхуков.
- Карта зала: статика на CDN, занятость в кэше, допустимая неточность.
- Очередь ожидания, токены доступа, защита от ботов.
- Шардирование по событию и что делать с горячим шардом.
Если на всё не хватает времени, приоритет такой: инвариант и условный UPDATE, затем TTL резерва, затем очередь ожидания. Эти три пункта и отличают продуманный ответ от схемы «клиент — сервер — база».