Распределённые блокировки: Redis SET NX, Redlock, fencing tokens и ZooKeeper
Как сделать распределённую блокировку на Redis через SET NX PX, почему Redlock критикуют, зачем нужны fencing tokens, чем помогут ZooKeeper и etcd и когда блокировка не нужна.
Коротко
- Распределённая блокировка гарантирует, что в каждый момент критическую секцию выполняет один процесс из многих на разных машинах. Локальный
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, не стройте сложную систему. Если двойное выполнение портит данные, одной блокировки мало при любой реализации — нужна защита на стороне ресурса.
От блокировки ждут трёх свойств:
- Безопасность (mutual exclusion). В любой момент блокировку держит не больше одного клиента.
- Живучесть без дедлоков. Если держатель упал, блокировка со временем освобождается.
- Отказоустойчивость. Пока работает большинство узлов сервиса блокировок, клиенты могут брать и отпускать блокировку.
Первые два свойства тянут в разные стороны. Чтобы освободить блокировку упавшего клиента, нужен таймаут. Но по таймауту нельзя отличить упавший клиент от медленного. Отсюда и все проблемы дальше.
Блокировка на одном 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 опасен. Сценарий:
- Клиент A взял блокировку на 10 секунд и завис на 15.
- Через 10 секунд ключ истёк, клиент B взял блокировку.
- A проснулся, закончил работу и сделал
DEL— удалил блокировку B. - Пришёл клиент 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, без репликации между ними — и захватывают блокировку большинством:
- Запомнить текущее время.
- По очереди сделать
SET key token NX PX ttlна всех N узлах с коротким таймаутом на каждый запрос (миллисекунды при TTL в секунды), чтобы зависший узел не съел время. - Блокировка взята, если её удалось поставить на большинстве узлов (≥ N/2 + 1) и суммарное время захвата меньше TTL.
- Время действия блокировки = TTL − время захвата − поправка на дрейф часов.
- Если не получилось — снять блокировку на всех узлах, даже на тех, где захват вроде бы не удался: ответ мог потеряться.
Пять узлов переживают отказ двух. Реализация в 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». Главные тезисы:
- Redlock полагается на тайминги. Он корректен, только если задержки сети, паузы процессов и дрейф часов ограничены и меньше TTL. В реальных системах ни одно из этого не ограничено: GC-паузы в JVM бывают на минуты, пакеты застревают, часы прыгают. Алгоритм, корректность которого зависит от таких допущений, нельзя использовать там, где важна корректность.
- Пауза клиента ломает любую блокировку с TTL. Клиент проверил, что блокировка его, ушёл в паузу, проснулся после истечения TTL и записал. Ни один сервис блокировок от этого не защитит — нужна проверка на стороне ресурса.
- Redlock не выдаёт fencing token. Случайный UUID не монотонен, по нему хранилище не поймёт, какой владелец новее. А чтобы сделать монотонный счётчик на пяти независимых Redis, нужен консенсус — то есть совсем другой алгоритм.
- Вывод. Для эффективности хватит одного Redis — Redlock здесь тяжеловат. Для корректности Redlock недостаточно — берите ZooKeeper или etcd и fencing tokens.
Сальваторе Санфилиппо (antirez), автор Redis, ответил статьёй «Is Redlock safe?». Его аргументы: большие прыжки часов предотвращаются настройкой (плавная подстройка NTP вместо скачков), шаг 3 алгоритма проверяет, что время захвата меньше TTL, а пауза после получения блокировки — проблема любой системы блокировок, не только Redlock. С последним Клеппман согласен — именно поэтому он настаивает на fencing.
Практический итог спора, который стоит озвучить на собеседовании: Redlock не делает блокировку безопасной для корректности. Если вам нужна корректность, гарантию даёт не сервис блокировок, а проверка токена в ресурсе.
Fencing tokens
Идея из главы 8 DDIA. Сервис блокировок при каждом захвате выдаёт число, которое строго больше предыдущего. Клиент передаёт это число с каждой записью в защищаемый ресурс. Ресурс помнит максимальный виденный токен и отвергает запросы с меньшим.
Сценарий с паузой GC теперь безопасен:
- A берёт блокировку и получает токен 33. Уходит в паузу.
- TTL истекает. B берёт блокировку, получает 34, пишет в хранилище. Хранилище запоминает 34.
- 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:
- Клиент создаёт узел
/locks/report/lock-с флагамиEPHEMERAL | SEQUENTIAL. ZooKeeper добавит номер:lock-0000000007. - Клиент читает список детей
/locks/report. Если его номер минимальный — блокировка взята. - Иначе клиент ставит 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 ноября перезаписывается целиком и два воркера получат одинаковый файл, двойное выполнение безвредно. Хватит блокировки «для эффективности» или даже её отсутствия.
Как отвечать на собеседовании
Вопрос обычно звучит как «как сделать, чтобы крон-задача выполнялась на одной реплике» или всплывает внутри большого дизайна. Примерный план ответа:
- Уточнить цель. Двойное выполнение — это лишняя работа или порча данных?
- Предложить обойтись без блокировки, если ресурс — база: атомарный
UPDATE, уникальный индекс,SKIP LOCKED, оптимистичная версия. - Для эффективности — Redis
SET key token NX PX ttl, освобождение Lua-скриптом по токену, продление watchdog'ом. - Назвать пределы: пауза клиента дольше TTL, асинхронная репликация при failover. Redlock закрывает отказ узла, но не паузы и не часы.
- Для корректности — 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, условие на версию в базе или уникальный индекс. А лучше всего — спроектировать систему так, чтобы блокировка не понадобилась.