Распределённые блокировки: Redis SET NX, Redlock, fencing tokens и ZooKeeper

Как сделать распределённую блокировку на Redis через SET NX PX, почему Redlock критикуют, зачем нужны fencing tokens, чем помогут ZooKeeper и etcd и когда блокировка не нужна.

16 мин чтениясистемный дизайн · распределённые системы · redis · python

Коротко

  • Распределённая блокировка гарантирует, что в каждый момент критическую секцию выполняет один процесс из многих на разных машинах. Локальный mutex тут не поможет: процессы не видят память друг друга.
  • Базовый рецепт на Redis: SET lock:x <уникальный токен> NX PX 30000 для захвата и Lua-скрипт «удали, только если токен мой» для освобождения. TTL обязателен, иначе упавший клиент держит блокировку вечно.
  • TTL — источник главной проблемы. Клиент может зависнуть (GC-пауза, своп, медленная сеть) дольше TTL, блокировка истечёт, её возьмёт другой — и теперь работают двое. Это не лечится ни Redlock, ни продлением.
  • Fencing token закрывает дыру: блокировка выдаёт монотонно растущий номер, а хранилище отвергает запись со старым номером. Такой номер дают ZooKeeper (zxid) и etcd (ревизия), но не Redis.
  • Сначала спросите, нужна ли блокировка вообще. Атомарный UPDATE ... WHERE, уникальный индекс, оптимистичная версия, SELECT ... FOR UPDATE SKIP LOCKED или партиционирование по ключу часто решают задачу надёжнее.

Зачем блокировка и что от неё требуется

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

Первым делом решите, зачем вам блокировка. Мартин Клеппман, автор книги «Designing Data-Intensive Applications», делит случаи на два класса, и от выбора зависит всё остальное.

ЦельЧто будет, если блокировка сломаетсяЧто подойдёт
Эффективность (efficiency)Работа сделана дважды: лишний отчёт, письмоОдин Redis с SET NX PX
Корректность (correctness)Испорченные данные, двойное списаниеКонсенсус (ZooKeeper, etcd) + fencing token или БД

Если двойной отчёт — это просто лишние 30 секунд CPU, не стройте сложную систему. Если двойное выполнение портит данные, одной блокировки мало при любой реализации — нужна защита на стороне ресурса.

От блокировки ждут трёх свойств:

  1. Безопасность (mutual exclusion). В любой момент блокировку держит не больше одного клиента.
  2. Живучесть без дедлоков. Если держатель упал, блокировка со временем освобождается.
  3. Отказоустойчивость. Пока работает большинство узлов сервиса блокировок, клиенты могут брать и отпускать блокировку.

Первые два свойства тянут в разные стороны. Чтобы освободить блокировку упавшего клиента, нужен таймаут. Но по таймауту нельзя отличить упавший клиент от медленного. Отсюда и все проблемы дальше.

Блокировка на одном Redis

Захват: SET NX PX

Команда, которая встречается в каждом ответе на собеседовании:

SET lock:report 7f3a9c... NX PX 30000
  • NX — записать, только если ключа нет. Проверка и запись атомарны, гонки между ними нет.
  • PX 30000 — ключ живёт 30 секунд. Упавший клиент не заблокирует ресурс навсегда.
  • Значение — уникальный токен этого захвата (UUID), а не 1. Он нужен, чтобы при освобождении отличить свою блокировку от чужой.

Устаревший вариант SETNX + отдельный EXPIRE неатомарен: если процесс упадёт между командами, ключ останется без TTL. С Redis 2.6.12 SET принимает NX и PX сразу, используйте его.

Освобождение: только своё

Наивный DEL lock:report опасен. Сценарий:

  1. Клиент A взял блокировку на 10 секунд и завис на 15.
  2. Через 10 секунд ключ истёк, клиент B взял блокировку.
  3. A проснулся, закончил работу и сделал DEL — удалил блокировку B.
  4. Пришёл клиент C и тоже взял блокировку. Теперь B и C работают одновременно.

Сравнить значение и удалить нужно атомарно, иначе между GET и DEL ключ снова успеет смениться. В Redis это делается Lua-скриптом: он выполняется целиком, другие команды в это время не выполняются.

import random import time import uuid import redis # Удаляем ключ, только если в нём наш токен RELEASE = """ if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) end return 0 """ # Продлеваем TTL, только если блокировка всё ещё наша EXTEND = """ if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('pexpire', KEYS[1], ARGV[2]) end return 0 """ class RedisLock: def __init__(self, client, name, ttl_ms=10_000): self.r = client self.key = f'lock:{name}' self.ttl_ms = ttl_ms self.token = None self._release = client.register_script(RELEASE) self._extend = client.register_script(EXTEND) def acquire(self, wait_s=5.0): token = uuid.uuid4().hex deadline = time.monotonic() + wait_s while time.monotonic() < deadline: if self.r.set(self.key, token, nx=True, px=self.ttl_ms): self.token = token return True time.sleep(0.02 + random.random() * 0.03) # ретрай с jitter return False def extend(self): res = self._extend(keys=[self.key], args=[self.token, self.ttl_ms]) return res == 1 def release(self): res = self._release(keys=[self.key], args=[self.token]) self.token = None return res == 1 r = redis.Redis(port=6379, decode_responses=True) r.delete('lock:report') a = RedisLock(r, 'report', ttl_ms=200) b = RedisLock(r, 'report', ttl_ms=200) print('A взял:', a.acquire()) print('B взял сразу:', b.acquire(wait_s=0.1)) time.sleep(0.3) # A «завис» дольше TTL — ключ истёк print('B взял после паузы A:', b.acquire(wait_s=0.1)) print('A отпускает:', a.release()) print('ключ на месте, владелец B:', r.get('lock:report') == b.token) print('B продлевает:', b.extend()) print('B отпускает:', b.release())

Вывод на локальном Redis 7:

A взял: True B взял сразу: False B взял после паузы A: True A отпускает: False ключ на месте, владелец B: True B продлевает: True B отпускает: True

A не смог удалить чужую блокировку: скрипт увидел, что токен в ключе не его, и вернул 0. Ретраи с небольшой случайной задержкой (jitter) нужны, чтобы десяток ждущих клиентов не долбили Redis синхронно — подробнее про это в статье об идемпотентности и ретраях.

Какой TTL выбрать и зачем продление

TTL — компромисс. Короткий TTL быстро освобождает ресурс после падения клиента, но повышает шанс, что живой, просто медленный клиент потеряет блокировку посреди работы. Длинный — наоборот.

Обычное решение — продление (watchdog): TTL небольшой, например 30 секунд, а фоновый поток каждые 10 секунд вызывает extend(). Если процесс упал, продлевать некому, и ключ истечёт. Так работает Redisson для Java: пока держатель жив, его watchdog продлевает блокировку, по умолчанию с таймаутом 30 секунд.

Если extend() вернул False, блокировку уже потеряли. Правильная реакция — прервать работу, а не продолжать «на авось».

Но продление не спасает от главного. Фоновый поток тоже останавливается во время stop-the-world паузы GC. Процесс может зависнуть сразу после успешной проверки «блокировка ещё моя» — и выполнить запись через минуту, когда блокировкой давно владеет другой.

Что ломается на одном Redis

  • Падение Redis. Один инстанс — единая точка отказа. Пока он лежит, блокировок нет ни у кого.
  • Failover с репликой. Репликация в Redis асинхронная. Клиент A взял блокировку на мастере, мастер упал до того, как ключ дошёл до реплики. Реплику повысили до мастера — ключа на ней нет, и блокировку берёт B. Команда WAIT уменьшает окно, но не делает репликацию синхронной в смысле консенсуса.
  • Паузы клиента. GC, своп, перегруженный гипервизор, SIGSTOP. Процесс не знает, что спал: после паузы он продолжает с той же строки.
  • Сеть. Пакет с записью может идти до хранилища дольше TTL — эффект тот же, что у паузы.

Первые два пункта пытается закрыть Redlock. Вторые два он не закрывает, и в этом суть критики.

Redlock: блокировка на нескольких Redis

Алгоритм

Redlock описан в документации Redis. Берут N независимых мастеров — обычно 5, без репликации между ними — и захватывают блокировку большинством:

  1. Запомнить текущее время.
  2. По очереди сделать SET key token NX PX ttl на всех N узлах с коротким таймаутом на каждый запрос (миллисекунды при TTL в секунды), чтобы зависший узел не съел время.
  3. Блокировка взята, если её удалось поставить на большинстве узлов (≥ N/2 + 1) и суммарное время захвата меньше TTL.
  4. Время действия блокировки = TTL − время захвата − поправка на дрейф часов.
  5. Если не получилось — снять блокировку на всех узлах, даже на тех, где захват вроде бы не удался: ответ мог потеряться.

Пять узлов переживают отказ двух. Реализация в 40 строк:

import time import uuid import redis RELEASE = """ if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) end return 0 """ def connect(port): # Короткие таймауты: зависший узел не должен съесть весь TTL return redis.Redis(port=port, socket_timeout=0.05, socket_connect_timeout=0.05) def redlock_acquire(nodes, key, ttl_ms, drift_factor=0.01): token = uuid.uuid4().hex start = time.monotonic() acquired = 0 for node in nodes: try: if node.set(key, token, nx=True, px=ttl_ms): acquired += 1 except redis.RedisError: pass # узел недоступен — идём дальше elapsed_ms = (time.monotonic() - start) * 1000 drift_ms = ttl_ms * drift_factor + 2 validity_ms = ttl_ms - elapsed_ms - drift_ms if acquired >= len(nodes) // 2 + 1 and validity_ms > 0: return token, acquired, validity_ms redlock_release(nodes, key, token) # не вышло — откатываемся везде return None, acquired, 0 def redlock_release(nodes, key, token): for node in nodes: try: node.eval(RELEASE, 1, key, token) except redis.RedisError: pass

Сценарий, где Redlock выдаёт блокировку двоим

Сымитируем пример из критики Клеппмана. Пять Redis на портах 7001–7005:

for p in 7001 7002 7003 7004 7005; do redis-server --port $p --daemonize yes --save '' --appendonly no done

Клиент 1 из-за сетевого разрыва видит только A, B и C. Он берёт блокировку на трёх узлах из пяти — это большинство. Затем на узле C прыгают часы (NTP резко подвёл время вперёд или админ поправил его вручную), и ключ на C истекает раньше срока. Клиент 2 видит C, D и E — тоже большинство.

A, B, C, D, E = (connect(p) for p in range(7001, 7006)) for n in (A, B, C, D, E): n.delete('lock:report') # Клиент 1 видит A, B, C; до D и E у него сеть не доходит dead = connect(7999) client1 = [A, B, C, dead, dead] client2 = [A, B, C, D, E] t1, n1, v1 = redlock_acquire(client1, 'lock:report', ttl_ms=30_000) print(f'клиент 1: узлов {n1}/5, взял: {t1 is not None}') t2, n2, _ = redlock_acquire(client2, 'lock:report', ttl_ms=30_000) print(f'клиент 2: узлов {n2}/5, взял: {t2 is not None}') # На узле C часы прыгнули вперёд — ключ истёк раньше срока C.delete('lock:report') t2, n2, _ = redlock_acquire(client2, 'lock:report', ttl_ms=30_000) print(f'клиент 2 после прыжка часов на C: узлов {n2}/5, взял: {t2 is not None}') print('оба считают себя владельцами:', t1 is not None and t2 is not None)
клиент 1: узлов 3/5, взял: True клиент 2: узлов 2/5, взял: False клиент 2 после прыжка часов на C: узлов 3/5, взял: True оба считают себя владельцами: True

Прыжок часов здесь изображён удалением ключа — результат для алгоритма тот же. Тот же эффект даёт перезапуск узла C без fsync на диск: ключ блокировки не пережил рестарт. Для этого случая автор Redis предлагает отложенный рестарт — не принимать запросы дольше максимального TTL.

Критика Клеппмана и ответ antirez

В феврале 2016 года Клеппман опубликовал разбор «How to do distributed locking». Главные тезисы:

  1. Redlock полагается на тайминги. Он корректен, только если задержки сети, паузы процессов и дрейф часов ограничены и меньше TTL. В реальных системах ни одно из этого не ограничено: GC-паузы в JVM бывают на минуты, пакеты застревают, часы прыгают. Алгоритм, корректность которого зависит от таких допущений, нельзя использовать там, где важна корректность.
  2. Пауза клиента ломает любую блокировку с TTL. Клиент проверил, что блокировка его, ушёл в паузу, проснулся после истечения TTL и записал. Ни один сервис блокировок от этого не защитит — нужна проверка на стороне ресурса.
  3. Redlock не выдаёт fencing token. Случайный UUID не монотонен, по нему хранилище не поймёт, какой владелец новее. А чтобы сделать монотонный счётчик на пяти независимых Redis, нужен консенсус — то есть совсем другой алгоритм.
  4. Вывод. Для эффективности хватит одного Redis — Redlock здесь тяжеловат. Для корректности Redlock недостаточно — берите ZooKeeper или etcd и fencing tokens.

Сальваторе Санфилиппо (antirez), автор Redis, ответил статьёй «Is Redlock safe?». Его аргументы: большие прыжки часов предотвращаются настройкой (плавная подстройка NTP вместо скачков), шаг 3 алгоритма проверяет, что время захвата меньше TTL, а пауза после получения блокировки — проблема любой системы блокировок, не только Redlock. С последним Клеппман согласен — именно поэтому он настаивает на fencing.

Практический итог спора, который стоит озвучить на собеседовании: Redlock не делает блокировку безопасной для корректности. Если вам нужна корректность, гарантию даёт не сервис блокировок, а проверка токена в ресурсе.

Fencing tokens

Идея из главы 8 DDIA. Сервис блокировок при каждом захвате выдаёт число, которое строго больше предыдущего. Клиент передаёт это число с каждой записью в защищаемый ресурс. Ресурс помнит максимальный виденный токен и отвергает запросы с меньшим.

Сценарий с паузой GC теперь безопасен:

  1. A берёт блокировку и получает токен 33. Уходит в паузу.
  2. TTL истекает. B берёт блокировку, получает 34, пишет в хранилище. Хранилище запоминает 34.
  3. A просыпается и пишет с токеном 33. Хранилище видит 33 < 34 и отказывает.

Проверку удобно сделать условием в UPDATE — она атомарна вместе с записью:

import sqlite3 class LockService: """Блокировка с TTL и монотонным счётчиком. Время логическое.""" def __init__(self, ttl): self.ttl = ttl self.holder = None self.expires_at = 0 self.counter = 32 def acquire(self, client, now): if self.holder is None or now >= self.expires_at: self.counter += 1 self.holder, self.expires_at = client, now + self.ttl return self.counter # fencing token return None db = sqlite3.connect(':memory:') db.execute('CREATE TABLE files (id TEXT PRIMARY KEY, body TEXT, fence INTEGER)') db.execute("INSERT INTO files VALUES ('report', '', 0)") def write(file_id, body, token, fencing=True): sql = 'UPDATE files SET body = ?, fence = ? WHERE id = ?' params = [body, token, file_id] if fencing: sql += ' AND fence <= ?' # старый токен не пройдёт params.append(token) return db.execute(sql, params).rowcount == 1 def scenario(fencing): db.execute("UPDATE files SET body = '', fence = 0") lock = LockService(ttl=10) t_a = lock.acquire('A', now=0) # A взял блокировку # A ушёл в GC-паузу на 15 секунд, TTL истёк t_b = lock.acquire('B', now=12) # B честно взял блокировку ok_b = write('report', 'данные B', t_b, fencing) ok_a = write('report', 'данные A', t_a, fencing) # A проснулся и пишет body = db.execute("SELECT body FROM files WHERE id = 'report'").fetchone()[0] print(f'fencing={fencing}: токены A={t_a} B={t_b}, ' f'запись B={ok_b}, запись A={ok_a}, в файле: {body!r}') scenario(fencing=False) scenario(fencing=True)
fencing=False: токены A=33 B=34, запись B=True, запись A=True, в файле: 'данные A' fencing=True: токены A=33 B=34, запись B=True, запись A=False, в файле: 'данные B'

Без fencing проснувшийся A затёр данные B. С fencing его запись отклонена, хотя сама блокировка вела себя одинаково в обоих случаях.

Условие fence <= ?, а не <: держатель блокировки может писать несколько раз с одним токеном.

Ограничения

  • Ресурс должен уметь проверять токен. База данных, своё хранилище, сервис с API — да. Внешний платёжный шлюз или отправка SMS — нет. Там спасает только идемпотентность: ключ операции, по которому сторонняя система отбросит дубль.
  • Токен должен быть по-настоящему монотонным. INCR на одном Redis работает, пока не случился failover с потерей последних записей — тогда счётчик откатится и выдаст уже использованный номер. Надёжный счётчик дают системы на консенсусе.
  • Несколько ресурсов. Если критическая секция пишет в два хранилища, проверять токен должны оба.

Заметьте: если ресурс сам проверяет токены, блокировка становится оптимизацией — она лишь уменьшает число отклонённых записей. Корректность обеспечивает ресурс. Это и есть главный вывод всей дискуссии.

ZooKeeper и etcd

Обе системы построены на консенсусе (ZAB в ZooKeeper, Raft в etcd): запись подтверждается большинством узлов, лидер не может «забыть» подтверждённую запись при failover. Это закрывает проблему асинхронной репликации Redis. Подробнее о том, почему за это платят доступностью при разделении сети, — в статье о CAP-теореме.

ZooKeeper: эфемерные последовательные узлы

Рецепт из документации ZooKeeper:

  1. Клиент создаёт узел /locks/report/lock- с флагами EPHEMERAL | SEQUENTIAL. ZooKeeper добавит номер: lock-0000000007.
  2. Клиент читает список детей /locks/report. Если его номер минимальный — блокировка взята.
  3. Иначе клиент ставит watch на узел с номером прямо перед своим и ждёт его удаления, затем повторяет шаг 2.

Почему так:

  • Эфемерный узел живёт, пока жива сессия клиента. Клиент упал или перестал слать heartbeat дольше session timeout — ZooKeeper удаляет узел, блокировка освобождается. Это тот же TTL, только управляемый сервером.
  • Watch на предшественника, а не на родителя, спасает от herd effect: при освобождении просыпается один следующий клиент, а не все сто ждущих.
  • Очередь честная: блокировку получают в порядке номеров.
  • Fencing token бесплатный: zxid создания узла или его порядковый номер монотонно растут.

Руками этот рецепт никто не пишет: в Java есть Apache Curator с InterProcessMutex, в Python — kazoo с Lock.

Важная деталь: истечение сессии — это тот же TTL. Если клиент ушёл в GC-паузу дольше session timeout, ZooKeeper удалит его узел и отдаст блокировку следующему, а клиент после паузы об этом не узнает, пока не обработает событие сессии. Поэтому fencing token нужен и с ZooKeeper — просто здесь его есть откуда взять.

etcd: lease и ревизии

В etcd аналог эфемерного узла — lease: ключ привязан к аренде с TTL, клиент продлевает её через KeepAlive. Аренда истекла — все её ключи удалены.

Блокировка в пакете concurrency клиента Go устроена так же, как рецепт ZooKeeper: каждый претендент пишет ключ /locks/report/<lease-id>, блокировку держит ключ с минимальной create revision, остальные ждут удаления предшественника. Из командной строки то же самое делает etcdctl lock.

Ревизия в etcd — глобальный монотонный счётчик всех изменений кластера. Ревизия создания ключа блокировки и есть готовый fencing token: его можно передать в хранилище, а в самом etcd ещё и проверить в транзакции Txn условием на ревизию.

Kubernetes выбирает лидера контроллеров через объекты Lease поверх того же etcd — если сервис уже живёт в Kubernetes, это готовый механизм leader election.

Сравнение

РешениеОтказоустойчивостьFencing tokenКогда брать
Один Redis, SET NX PXНет, failover теряет ключиНетЭффективность: не делать работу дважды
Redlock (5 Redis)Переживает отказ 2 узловНетРедко: для эффективности избыточен, для корректности мало
ZooKeeperКонсенсус, большинство узловzxid, номер узлаКорректность, уже есть ZooKeeper (Kafka, Hadoop)
etcdКонсенсус (Raft)РевизияКорректность, Kubernetes-окружение
Advisory lock в PostgresКак у самой базыНет, но ресурс та же базаРесурс — эта же база

Когда блокировка не нужна

На собеседовании сильный ответ часто начинается с вопроса: «А можно обойтись без распределённой блокировки?» Обычно можно.

Атомарная операция в базе. Списание с баланса не требует блокировки:

UPDATE accounts SET balance = balance - 100 WHERE id = 42 AND balance >= 100;

Обновилась одна строка — деньги списаны. Ноль строк — денег не хватило. База сама сериализует конкурирующие обновления одной строки.

Уникальный индекс. «Создать заказ один раз», «отправить приветственное письмо один раз» — INSERT ... ON CONFLICT DO NOTHING по естественному ключу. Это основа ключей идемпотентности.

Оптимистичная блокировка. Читаем строку с версией, пишем UPDATE ... SET ..., version = version + 1 WHERE id = ? AND version = ?. Конфликт — перечитываем и повторяем. По сути это fencing, где токен — версия самой записи. Как это сочетается с уровнями изоляции, разобрано в статье про изоляцию транзакций.

Очередь задач на SKIP LOCKED. Вместо «воркер берёт блокировку на задачу» — каждый воркер забирает свою строку, а занятые чужими транзакциями пропускает:

UPDATE jobs SET status = 'running' WHERE id = ( SELECT id FROM jobs WHERE status = 'new' ORDER BY id LIMIT 1 FOR UPDATE SKIP LOCKED ) RETURNING id, payload;

Работает в Postgres 9.5+ и MySQL 8.0+. Строчная блокировка живёт ровно в рамках транзакции, и упавший воркер её не «забудет».

Advisory lock в Postgres. Если ресурс — данные в той же базе, возьмите блокировку там же:

BEGIN; SELECT pg_try_advisory_xact_lock(hashtext('report:2026-11')); -- t или f -- если t, делаем работу COMMIT; -- блокировка снимается вместе с транзакцией

Отдельный Redis не нужен, а блокировка и запись живут в одной системе.

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

Идемпотентный результат. Если отчёт за 6 ноября перезаписывается целиком и два воркера получат одинаковый файл, двойное выполнение безвредно. Хватит блокировки «для эффективности» или даже её отсутствия.

Как отвечать на собеседовании

Вопрос обычно звучит как «как сделать, чтобы крон-задача выполнялась на одной реплике» или всплывает внутри большого дизайна. Примерный план ответа:

  1. Уточнить цель. Двойное выполнение — это лишняя работа или порча данных?
  2. Предложить обойтись без блокировки, если ресурс — база: атомарный UPDATE, уникальный индекс, SKIP LOCKED, оптимистичная версия.
  3. Для эффективности — Redis SET key token NX PX ttl, освобождение Lua-скриптом по токену, продление watchdog'ом.
  4. Назвать пределы: пауза клиента дольше TTL, асинхронная репликация при failover. Redlock закрывает отказ узла, но не паузы и не часы.
  5. Для корректности — ZooKeeper или etcd плюс fencing token, который проверяет сам ресурс.

Частые уточняющие вопросы:

  • Почему не DEL при освобождении? Можно удалить чужую блокировку после истечения своего TTL.
  • Почему токен — UUID, а не ID процесса? Один процесс может брать блокировку много раз, и старый захват не должен освобождать новый. Плюс ID процессов на разных машинах совпадают.
  • Что делать, если продление не удалось? Прекратить работу и откатить незавершённое: блокировка уже может быть у другого.
  • Чем ZooKeeper лучше Redis здесь? Консенсус вместо асинхронной репликации и встроенный монотонный счётчик для fencing. Цена — отдельный кластер и задержка записи через большинство.
  • Сделает ли блокировка обработку exactly-once? Нет. Она уменьшает вероятность дублей, но после сбоя посреди работы задачу всё равно выполнят повторно. Exactly-once эффект дают идемпотентность и дедупликация.

Частые ошибки

  • Блокировка без TTL. Упавший клиент держит её вечно, ресурс встаёт до ручного вмешательства.
  • SETNX и EXPIRE двумя командами. Падение между ними оставляет вечный ключ.
  • DEL без проверки владельца. Медленный клиент снимает чужую блокировку.
  • GET и DEL двумя командами из клиента. Между ними ключ успевает смениться, нужна атомарная проверка в Lua.
  • Использовать системное время для таймаутов. Для замера длительности на клиенте берите монотонные часы (time.monotonic()), а не time.time(): системное время может прыгнуть.
  • Вера в Redlock как в гарантию корректности. Он не выдаёт fencing token и полагается на ограниченные паузы и дрейф часов.
  • Fencing без проверки на ресурсе. Токен, который никто не сравнивает, ничего не защищает.
  • Распределённая блокировка там, где хватает базы. Лишний компонент, лишняя точка отказа и ложное чувство безопасности.

Итог

Распределённая блокировка на TTL — это аренда, а не владение: никто не гарантирует, что вы всё ещё держите её в момент записи. Для экономии работы хватит одного Redis с SET NX PX и освобождением по токену. Когда на кону корректность данных, переносите проверку в сам ресурс: fencing token из ZooKeeper или etcd, условие на версию в базе или уникальный индекс. А лучше всего — спроектировать систему так, чтобы блокировка не понадобилась.

Потренироваться в спокойной обстановке

Все задачи