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

Когда сервис разворачивается в N инстансов, локальные sync.Mutex уже не помогают: каждый процесс блокирует только сам себя, а соседний инстанс об этом не знает. Внутри одной базы конкуренцию за строку решает SELECT ... FOR UPDATE (см. уровни изоляции), но координировать нужно не только строки - ещё запуск задачи по расписанию, выбор лидера, обработку одного заказа ровно один раз.

Redis для этого подходит: он один на всех и выполняет команды по очереди. Дальше вся сложность в деталях - кто владелец лока, что будет при истёкшем TTL и почему DEL без проверки владельца однажды удалит чужой лок.

⚠️ Сначала - что распределённый lock не даёт

Дальше будет SET NX EX, токен владельца, Lua-release и Redlock. Всё это работает и полезно, но начать стоит с границы, потому что переоценка lock - источник самых дорогих ошибок в этой теме:

lock ограничивает конкуренцию, но не гарантирует исключительное выполнение после истечения аренды.

Почему так и что с этим делать - в разделе про fencing ниже. Если операция под lock двигает деньги или делает необратимый внешний вызов, читать его надо раньше, чем писать код.

Distributed Lock через SET NX

func AcquireLock(ctx context.Context, rdb *redis.Client, key string, ttl time.Duration) (string, error) {
    token := uuid.New().String()
    ok, err := rdb.SetNX(ctx, "lock:"+key, token, ttl).Result()
    if err != nil {
        return "", err
    }
    if !ok {
        return "", fmt.Errorf("lock already held")
    }
    return token, nil
}

func ReleaseLock(ctx context.Context, rdb *redis.Client, key, token string) error {
    script := redis.NewScript(`
        if redis.call("GET", KEYS[1]) == ARGV[1] then
            return redis.call("DEL", KEYS[1])
        end
        return 0
    `)
    result, err := script.Run(ctx, rdb, []string{"lock:" + key}, token).Int()
    if err != nil {
        return err
    }
    if result == 0 {
        return fmt.Errorf("lock not held or expired")
    }
    return nil
}
<?php
declare(strict_types=1);

use Predis\Client;
use Symfony\Component\Uid\Uuid;

final readonly class DistributedLock
{
    public function __construct(private Client $redis) {}

    /**
     * @return string token владения - нужен для release
     * @throws RuntimeException если lock уже занят
     */
    public function acquire(string $key, int $ttlSeconds): string
    {
        $token = Uuid::v4()->toRfc4122();
        $ok = $this->redis->set('lock:' . $key, $token, 'EX', $ttlSeconds, 'NX');

        if ($ok === null) {
            throw new RuntimeException('lock already held: ' . $key);
        }

        return $token;
    }

    public function release(string $key, string $token): void
    {
        $script = <<<'LUA'
            if redis.call("GET", KEYS[1]) == ARGV[1] then
                return redis.call("DEL", KEYS[1])
            end
            return 0
        LUA;

        $result = (int) $this->redis->eval($script, 1, 'lock:' . $key, $token);
        if ($result === 0) {
            throw new RuntimeException('lock not held or expired: ' . $key);
        }
    }
}
import uuid
from datetime import timedelta

import redis

RELEASE_SCRIPT = """
if redis.call("GET", KEYS[1]) == ARGV[1] then
    return redis.call("DEL", KEYS[1])
end
return 0
"""


class LockError(Exception):
    pass


class DistributedLock:
    def __init__(self, rdb: redis.Redis) -> None:
        self._rdb = rdb
        # register_script: SCRIPT LOAD один раз, дальше EVALSHA,
        # при NOSCRIPT после рестарта Redis - откат на EVAL автоматически
        self._release = rdb.register_script(RELEASE_SCRIPT)

    def acquire(self, key: str, ttl: timedelta) -> str:
        """Возвращает token владения - он нужен для release."""
        token = str(uuid.uuid4())
        # nx=True + px=ttl - одна команда SET NX PX, без окна между SET и EXPIRE
        ok = self._rdb.set(f"lock:{key}", token, nx=True, px=ttl)
        if not ok:
            raise LockError("lock already held")
        return token

    def release(self, key: str, token: str) -> None:
        result = self._release(keys=[f"lock:{key}"], args=[token])
        if result == 0:
            raise LockError("lock not held or expired")

Это тоже «учебный» вариант. В redis-py есть готовый rdb.lock(name, timeout=..., blocking=False) - под капотом тот же SET NX PX + токен + Lua-release, а with rdb.lock(...) освобождает лок в __exit__, как defer.

Это «учебный» вариант для понимания механики. В реальном Symfony-коде бери symfony/lock с RedisStore - там уже всё это сделано, плюс auto-release через defer-эквивалент try/finally.

Ключевые моменты:

  1. SET NX - атомарная установка только если ключа нет (set if not exists)
  2. TTL - обязательно. Без TTL после краха процесса lock останется навсегда (deadlock)
  3. token (UUID) - защита от ситуации, когда вы дёрнули lock, его TTL истёк, кто-то другой захватил, а вы потом DEL - удалите чужой
  4. Lua script для release - атомарность compare-and-delete: в одном Redis-вызове проверить владение и удалить

Redlock - для нескольких инстансов Redis

SET NX надёжен только при одном Redis. При репликации master-replica есть гонка: master подтвердил SET, упал до репликации, реплика стала master без lock-ключа - два процесса считают себя владельцами.

Алгоритм Redlock (Antirez):

  1. Получаем текущее время T1
  2. Пытаемся захватить lock на N (обычно 5) независимых Redis-инстансах
  3. Lock считается захваченным, если ≥ N/2+1 успешных и время прошло меньше TTL
  4. При release - выполняем Lua-скрипт compare-and-delete (проверка токена + DEL) на всех инстансах: голый DEL удалил бы чужой лок, как разобрано выше

Важно: готовые библиотеки ниже - это не Redlock, а аккуратный лок на одном Redis (SET NX + токен + Lua-release). Именно он нужен в большинстве случаев. Настоящий Redlock на нескольких независимых мастерах - отдельные библиотеки: в Go github.com/go-redsync/redsync/v4, в PHP CombinedStore с ConsensusStrategy, в Python redlock-py или pottery. Пример для Go - сразу после вкладок.

import "github.com/bsm/redislock"

locker := redislock.New(rdb)

lock, err := locker.Obtain(ctx, "my-lock", 100*time.Millisecond,
    &redislock.Options{
        RetryStrategy: redislock.LinearBackoff(50 * time.Millisecond),
    })
if err != nil {
    return err
}
defer lock.Release(ctx)
<?php
declare(strict_types=1);

use Symfony\Component\Lock\LockFactory;
use Symfony\Component\Lock\Store\RedisStore;
use Symfony\Component\Lock\Exception\LockConflictedException;

$store = new RedisStore($redis);
$factory = new LockFactory($store);

$lock = $factory->createLock(resource: 'my-lock', ttl: 0.1); // 100ms

try {
    $lock->acquire(blocking: true); // ждёт до получения, с автоматическим retry
    // критическая секция
} catch (LockConflictedException) {
    // блокировка не получена
    return;
} finally {
    $lock->release();
}
import redis
from redis.exceptions import LockError


def run_exclusive(rdb: redis.Redis) -> None:
    # redis.lock.Lock - аналог bsm/redislock: SET NX PX + токен + Lua-release.
    # timeout - TTL лока, blocking_timeout - сколько ждать захват,
    # sleep - пауза между попытками (linear backoff)
    try:
        with rdb.lock("my-lock", timeout=0.1, blocking_timeout=0.5, sleep=0.05):
            ...  # критическая секция; release в __exit__, как defer
    except LockError:
        # блокировка не получена за blocking_timeout
        return

redis.lock.Lock работает с одним Redis. Для Redlock на нескольких независимых мастерах - пакет redlock-py (Redlock([{"host": ...}, ...]), кворум N/2+1 внутри) или pottery.

Настоящий Redlock на Go - через redsync, которому передают пулы нескольких независимых Redis:

import (
    "github.com/go-redsync/redsync/v4"
    "github.com/go-redsync/redsync/v4/redis/goredis/v9"
)

// rdb1, rdb2, rdb3 - клиенты к трём НЕЗАВИСИМЫМ Redis (не реплики одного мастера)
rs := redsync.New(goredis.NewPool(rdb1), goredis.NewPool(rdb2), goredis.NewPool(rdb3))

mutex := rs.NewMutex("my-lock", redsync.WithExpiry(10*time.Second))
if err := mutex.LockContext(ctx); err != nil { // успех, если взяли лок на большинстве (2 из 3)
    return err
}
defer mutex.UnlockContext(ctx) // compare-and-delete на всех инстансах

В Symfony для Redlock на нескольких независимых Redis нужен CombinedStore из нескольких RedisStore с ConsensusStrategy (кворум большинства). Один RedisStore работает с одним подключением, даже если это RedisArray или RedisCluster: они шардируют ключи, а не дают кворум.

⚠️ Redlock - алгоритм с моделью времени, а не «решение проблемы блокировок»

Про Redlock есть известный спор: Martin Kleppmann разобрал его в 2016-м, Antirez ответил. Читать стоит обоих, но вывод для практики короткий и не про то, кто прав.

Redlock решает одну задачу: убирает зависимость от единственного мастера, чтобы падение одного Redis не приводило к двум владельцам. Он не решает и не может решить другую - ту, что разобрана в разделе про fencing: процесс с истёкшей арендой всё равно способен продолжить работу. Кворум из пяти инстансов от stop-the-world паузы не спасает.

Плюс у алгоритма есть допущение, которое легко не заметить: он опирается на ограниченный дрейф часов и на то, что задержки в сети не превышают некоторой величины. В окружении, где виртуалку могут заморозить на секунды, это допущение не выполняется.

Поэтому формулировка «нужны абсолютные гарантии - берите Zookeeper/etcd» тоже неточная: consensus даёт надёжную выдачу аренды, но исключительность выполнения по-прежнему требует fencing на стороне ресурса. Правильный порядок вопросов другой: что случится, если операция выполнится дважды? Если ничего страшного - хватит SET NX EX. Если страшное - нужен fencing или перенос решения в транзакцию базы, а выбор между одним Redis, Redlock и etcd влияет только на частоту таких случаев.

Fencing: чего lock не умеет в принципе

Всё, что мы делали выше - токен владельца, TTL, Lua-release, - защищает от одной вещи: от того, чтобы удалить чужой lock. От другой не защищает ничего, и это следует понимать до того, как lock попадёт в код, охраняющий деньги.

Lock ограничивает конкуренцию, но не гарантирует исключительное выполнение после истечения lease.

Разложим по шагам:

t=0    процесс A взял lock, TTL 30s
t=5    A ушёл в stop-the-world паузу / его контейнер заморозили /
       он ждёт ответа от медленного API
t=30   TTL истёк, Redis удалил ключ
t=31   процесс B взял lock и начал работу
t=40   A проснулся - он всё ещё считает себя владельцем -
       и пишет в тот же ресурс

В момент t=40 в критической секции два процесса. Redis ни в чём не виноват: он выдал аренду на 30 секунд и честно её закончил. Не виноват и код A - у него нет способа узнать, что аренда истекла, пока он не сходит в Redis снова, а между проверкой и записью снова будет окно.

Единственное реальное лекарство - fencing token: монотонно растущее число, которое выдаётся вместе с блокировкой и которое проверяет защищаемый ресурс.

A получил lock с токеном 33 → пишет с токеном 33
B получил lock с токеном 34 → пишет с токеном 34
A проснулся, пишет с токеном 33 → хранилище отвергает: 33 < 34

Ключевое здесь - последняя строка: проверку делает не клиент, а сторона, которую мы защищаем. Поэтому fencing применим не всегда: нужно, чтобы у ресурса была условная запись. Для PostgreSQL это UPDATE ... SET last_token = $1 WHERE id = $2 AND last_token < $1: запись с устаревшим токеном обновит ноль строк. Обратите внимание на сравнение «меньше», а не равенство: WHERE version = $1 - это другой механизм, оптимистическая блокировка. Для собственного API - явный параметр токена, который сервер сравнивает с последним принятым.

Откуда взять монотонный токен? UUID из примеров выше не подходит - он не растёт. Проще всего выдавать токен тем же Lua-скриптом, что и захватывает лок, через INCR отдельного счётчика:

-- KEYS[1] - ключ лока, KEYS[2] - счётчик токенов (lock:my-lock:fence)
-- ARGV[1] - идентификатор владельца, ARGV[2] - TTL в миллисекундах
if redis.call("SET", KEYS[1], ARGV[1], "NX", "PX", ARGV[2]) then
    return redis.call("INCR", KEYS[2])  -- это и есть fencing token
end
return nil  -- лок занят

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

ℹ️ Что делать, если fencing невозможен

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

  1. сделать операцию идемпотентной - тогда двойное выполнение безвредно, и lock нужен только для экономии ресурсов, а не для корректности (как);
  2. вынести решение в одну транзакцию базы - SELECT ... FOR UPDATE или UPDATE ... WHERE вместо внешнего lock. База даёт настоящую взаимную исключительность, потому что видит и данные, и блокировки;
  3. согласиться с рисками и держать критическую секцию короткой, зная, что гарантии нет.

Чего делать не стоит - считать, что «взяли lock, значит одни». Разница между «конкуренция снижена» и «исключительное выполнение гарантировано» и есть та самая, из-за которой в проде появляются двойные списания.

Lock gotchas

  1. Долгие операции под lock - TTL может истечь раньше окончания работы. Решения: heartbeat (продление TTL), лимит длительности.
  2. Lock leak при панике - без defer Release лок останется до TTL.
  3. Паузы и заморозки процесса - сам GC в Go останавливает мир на доли миллисекунды, но процесс могут заморозить на секунды (троттлинг CPU в контейнере, миграция VM, своп) или он зависнет на медленном внешнем вызове. Лок истечёт, кто-то другой зайдёт. Защита: fencing token.
  4. Кросс-сервис lock - все участники должны использовать одну и ту же стратегию (имя ключа, TTL).

Типичные ошибки

  • SET key val NX без TTL - процесс упал/завис → ключ висит вечно, никто не может взять lock. Всегда SET key val NX EX <ttl> атомарно одной командой, не SET NX + EXPIRE (между ними может упасть и lock останется без TTL).
  • DEL key для release без проверки владельца - твой TTL истёк, lock взял другой процесс, ты завершил работу и удалил его lock. Запоминай uuid владельца в значении и удаляй через Lua-скрипт if GET == myUUID then DEL.
  • Lock как замена транзакции - критическая секция занимает дольше TTL. К концу работы lock уже не твой, два процесса работают одновременно с одними данными. Лекарство - короткие критические секции или lock с watchdog-renewal (PEXPIRE каждые TTL/3).
  • Redlock на одном Redis-инстансе - Redlock работает только при 3-5 независимых мастерах. На одном инстансе он просто эквивалентен SET NX EX + сложности кода. Используй Redlock когда у тебя реально несколько Redis-кластеров.

Мини-практика

Реализуй Lock(ctx, key, ttl) / Unlock(ctx, key) на SET NX EX с uuid владельца и освобождением через Lua-скрипт. Проверь тестом на двух горутинах, что второй захват не проходит, пока первый держит лок, и что после истечения TTL лок берётся заново.

Затем проверь утверждение из раздела про fencing прогоном, а не чтением. Добавь выдачу fencing token через INCR и напиши тест по сценарию t=0 ... t=40: A берёт лок и «засыпает» дольше TTL, B берёт лок и пишет, потом просыпается A и пишет со старым токеном. Сделай два варианта ресурса: с проверкой last_token < token и без неё. Первый должен отвергнуть запись A, второй - потерять работу B. Так видно, что защиту даёт проверка на стороне ресурса, а не сама блокировка.

Дальше - ограничение частоты запросов.

Зарегистрируйтесь бесплатно, чтобы пройти квиз, вести прогресс.