---
title: "RedisのSETNXロック実装：SET NX PXとLuaでの解放、Redlockとフェンシングトークンの判断【2026年11月】"
url: "https://www.issoh.co.jp/tech/details/19929/"
published: 2026-11-17
updated: 2026-11-17
categories: ["データベース"]
publisher: "株式会社一創"
---

# RedisのSETNXロック実装：SET NX PXとLuaでの解放、Redlockとフェンシングトークンの判断【2026年11月】

Redisで分散ロックを組むなら、`SETNX`ではなく`SET キー トークン NX PX ミリ秒`で取得し、値がトークンと一致したときだけ消すLuaスクリプトで解放します。これだけで単一のRedisでは正しく動きますが、処理が期限を超えた場合やフェイルオーバーの直後には、2つのプロセスが同時にロックを持つ場合もあるのです。この記事ではRedis公式ドキュメントとredis-pyのソースをもとに、取得と解放のコード、redis-pyのLockクラスの既定値、Redlockの手順、フェンシングトークンの実装、そしてRedisのロックに任せてよい処理の線引きまでを示します。

## まとめ：SET NX PXでの取得とトークン照合の解放、正しさはDB側で担保

ロックの取得は`SET lock:名前 乱数 NX PX 30000`の1コマンドで行います。`SETNX`と`EXPIRE`を分けて送る書き方は、間でプロセスが落ちると期限の無いロックが残るため使いません。

解放は`DEL`ではなく、値が自分のトークンと一致したときだけ消すLuaスクリプトで行います。Redis 8.4以降なら`DELEX キー IFEQ トークン`の1コマンドで同じことができます。

ただし、Redisのロックは期限切れやフェイルオーバーで外れることがあります。重複して実行されても無駄が出るだけの処理なら単一Redisで十分です。決済や在庫の確定のように二重実行が事故になる処理は、DBの一意制約やフェンシングトークンで止めましょう。

## SETNXでのロックが非推奨になった理由とSET NX PXへの置き換え手順

Redisそのものの仕組みは[Redisとは：仕組みとデータ型・Redis 8.10系の新機能とライセンス、Dockerで動かす手順](https://www.issoh.co.jp/tech/details/18876/)で扱いました。ここではロックに使うコマンドの選び方に絞ります。

### SETNXとEXPIREを分けて送ると期限なしのロックが残る2コマンド間の隙間

`SETNX`は「キーが無ければ値を入れる」コマンドで、入れば`1`、既にあれば`0`を返します。古い記事では、これでロックを取ってから`EXPIRE`で期限を付ける2段の書き方が紹介されています。

問題は2つのコマンドの間です。`SETNX`が成功した直後にプロセスが落ちると、期限の無いロックが残り、誰も解放しないまま後続の処理がすべて止まります。[SETNXの公式ページ](https://redis.io/docs/latest/commands/setnx/)は、Redis 2.6.12でこのコマンドを非推奨とし、新しいコードでは`NX`付きの`SET`へ置き換えるよう書いています。同じページに残る、`GETSET`でタイムスタンプを比べて期限切れのロックを奪う手順も、互換のために記録された旧方式です。

### 2.6.12以降のSETでNXとPXを1コマンドに指定してロックを取る書式

[SETコマンド](https://redis.io/docs/latest/commands/set/)の`NX`（無いときだけ入れる）と`PX`（ミリ秒の期限）は、どちらも2.6.12から使えます。1コマンドなので、値と期限が別々に入る隙間がありません。

```
127.0.0.1:6379> SET lock:report:daily 4f1c9a0e7b2d NX PX 30000
OK
127.0.0.1:6379> SET lock:report:daily 8e2b77c1d05a NX PX 30000
(nil)
127.0.0.1:6379> PTTL lock:report:daily
(integer) 28713
```

1回目は`OK`で取得でき、2回目は既にキーがあるため`(nil)`が返ります。`PTTL`の値は実行のたびに変わる例です。値に入れる文字列として指定するのは、ロックごとに一意な乱数です。[Redis公式の分散ロックの解説](https://redis.io/docs/latest/develop/clients/patterns/distributed-locks/)は、`/dev/urandom`から取った20バイトを想定しています。KVSとしての`SET NX`の基本は[KVS（キーバリューストア）とは：Redisで動かして分かる仕組みとRDBとの使い分け](https://www.issoh.co.jp/tech/details/18062/)にもまとめています。

## ロックの解放をトークン照合のLuaスクリプトとDELEXで安全に行う手順

取得よりも事故が多いのが解放です。

### DELだけで解放すると期限切れ後に他のプロセスのロックを消す失敗例

プロセスAが30秒のロックを取り、処理に40秒かかったとします。30秒の時点でキーは期限切れで消え、プロセスBが同じロックを取得します。40秒の時点でAが`DEL`を送ると、消えるのはBのロックです。

この瞬間から、Bが処理中にもかかわらずロックは空になり、プロセスCも取得できてしまいます。1回の期限超過が、後続の排他を連鎖して崩す形です。公式の解説が値を「署名」として扱い、自分が入れた値のときだけ消すよう求めるのはこのためです。

### GETとDELを1つのLuaで実行する解放コードと8.4のDELEX IFEQ

アプリ側で`GET`して比べてから`DEL`を送ると、比べた直後に期限が切れて他のプロセスが取る隙間が残ります。比較と削除はRedisの中で1回に済ませます。[Luaスクリプトの説明](https://redis.io/docs/latest/develop/programmability/eval-intro/)のとおり、Redisはスクリプトの実行を原子的に扱い、実行中は他のコマンドを挟みません。

```
-- 値がトークンと一致したときだけ消す（SETのページと同じ形）
if redis.call("get", KEYS[1]) == ARGV[1] then
    return redis.call("del", KEYS[1])
else
    return 0
end

-- redis-cli からの呼び出し
EVAL "if redis.call('get',KEYS[1])==ARGV[1] then return redis.call('del',KEYS[1]) else return 0 end" 1 lock:report:daily 4f1c9a0e7b2d

-- Redis 8.4 以降は1コマンドで同じことができる
DELEX lock:report:daily IFEQ 4f1c9a0e7b2d
```

[DELEX](https://redis.io/docs/latest/commands/delex/)は8.4.0で加わったコマンドで、値が一致すれば`1`、一致しないかキーが無ければ`0`を返します。マネージドのRedisや互換製品では8.4未満の版が残っているので、両方で動くLuaのほうが安全な既定です。

## redis-pyで分散ロックを実装するPythonコードとLockクラスの設定値

例はPythonのredis-pyで書きます。2026年11月17日時点で[PyPIのredis](https://pypi.org/project/redis/)の最新は8.1.0（2026年7月30日公開）で、Python 3.10以上が必要です。redis-pyの接続の書き方と8.0で変わった既定値は[PythonでRedisを使う方法：redis-py 8系の接続プール・pipeline・asyncioと既定値の変更点](https://www.issoh.co.jp/tech/details/19931/)にまとめました。

### SET NX PXとLua解放を自前で書く最小のロック関数と再試行の待ち方

仕組みを確かめるため、まずライブラリのLockクラスを使わずに書きます。夜間の集計バッチを複数台のサーバーで同時に走らせない、という用途の例です。

```
# pip install "redis>=8.1"
import random
import secrets
import time

import redis

r = redis.Redis(host="localhost", port=6379, decode_responses=True)

RELEASE = r.register_script("""
if redis.call('get', KEYS[1]) == ARGV[1] then
    return redis.call('del', KEYS[1])
end
return 0
""")


def acquire(name, ttl_ms=30000, wait_sec=5.0):
    token = secrets.token_hex(20)          # 20バイトの乱数をトークンにする
    deadline = time.monotonic() + wait_sec
    while True:
        if r.set(name, token, nx=True, px=ttl_ms):
            return token
        if time.monotonic() >= deadline:
            return None                      # 待ちの上限を超えたら諦める
        time.sleep(0.05 + random.random() * 0.1)


def release(name, token):
    return RELEASE(keys=[name], args=[token]) == 1


token = acquire("lock:report:daily")
if token is None:
    raise SystemExit("他のサーバーで集計中のため終了")
try:
    run_daily_report()                       # 本来の処理（30秒以内に終える前提）
finally:
    if not release("lock:report:daily", token):
        print("ロックは期限切れで他に渡っていた。処理の重複を確認する")
```

redis-pyの`set(..., nx=True)`は、取得できれば`True`、既にキーがあれば`None`を返します。再試行の間隔に乱数を足しているのは、公式の解説が、同時に取りに来たクライアント同士がそろって再試行し続けないよう、ランダムな待ちを入れるよう勧めているためです。

### redis-py 8.1系のLockクラスの既定値と、timeoutを必ず渡す理由

実務では、redis-pyに同梱の`Lock`クラスを使えば足ります。[redis-pyのlock.py](https://github.com/redis/redis-py/blob/master/redis/lock.py)を読むと、内部は上と同じく`set(name, token, nx=True, px=timeout)`で取得し、トークンを照合するLuaで解放しています。トークンの生成元として使われているのは`uuid4`です。

| 引数                 | 既定値    | 既定のままだと起きること          |
| ------------------ | ------ | --------------------- |
| `timeout`          | `None` | 期限が付かず、落ちたプロセスのロックが残る |
| `blocking_timeout` | `None` | 取れるまで無期限に待つ           |
| `sleep`            | `0.1`  | 0.1秒間隔で取得を試す          |
| `thread_local`     | `True` | 別のスレッドからは解放できない       |

見落としやすいのは先頭の2つです。`timeout`を渡さないと、この記事の最初で避けた「期限の無いロック」がそのまま作られます。`blocking_timeout`も付けないと、ロックを持つプロセスが詰まったときに後続のリクエストが際限なく待ちます。

```
from redis.exceptions import LockNotOwnedError

lock = r.lock("lock:report:daily", timeout=60, blocking_timeout=5)
if not lock.acquire():
    raise SystemExit("5秒待っても取得できなかった")
try:
    run_daily_report()
finally:
    try:
        lock.release()
    except LockNotOwnedError:
        print("期限切れで他のプロセスに渡っていた")
```

### 長い処理でのextendによる延長と、thread\_localで解放に失敗する例

処理時間が読めない場合は、短めの`timeout`で取り、区切りごとに延長します。`lock.extend(60, replace_ttl=True)`は残り時間を60秒に置き換え、`replace_ttl`を省いた場合の動作は、残り時間への60秒の加算です。延長もトークンを照合するLuaで行われ、既に他に渡っていれば`LockNotOwnedError`になります。

もう1つの落とし穴が`thread_local=True`です。トークンはスレッドごとに保持されるので、メインスレッドで取ったロックをワーカースレッドで解放しようとすると、トークンが見えずに失敗します。lock.pyのdocstringも、取得と解放のスレッドが違うなら`thread_local=False`にするよう書いています。

## 期限切れとフェイルオーバーで2つのプロセスが同時にロックを持つ場面

ここまでのコードは単一のRedisでは正しく動きます。それでも排他が破れる場面が2つあります。

### GCの停止やネットワーク遅延で期限を過ぎてから書き込むプロセスの例

1つ目は、ロックを持つ側の停止です。[Martin Kleppmannの分析](https://martin.kleppmann.com/2016/02/08/how-to-do-distributed-locking.html)は、ロックを取ったプロセスがGCで長く止まり、その間にロックが期限切れになって別のプロセスが書き込み、止まっていたプロセスが再開して古い前提のまま書き込む例を挙げています。

書き込みの直前に残り時間を確かめても防げません。確認と書き込みの間にも停止やネットワークの遅延は入り得るからです。Redisの側から見れば、期限で鍵を外すこと自体が仕様どおりの動きです。

### 非同期レプリケーションのためSentinelの昇格後にロックが消える経路

2つ目は冗長構成のフェイルオーバーです。公式の分散ロックの解説は、次の4手順で排他が破れると説明しています。

1. クライアントAがマスターでロックを取る
2. その書き込みがレプリカへ届く前にマスターが落ちる
3. レプリカがマスターに昇格する
4. クライアントBが同じロックを取得できてしまう

Redisのレプリケーションは非同期なので、Sentinelで自動フェイルオーバーを組んでもこの穴は塞がりません。構成の詳細は[Redisの冗長化：レプリケーションとSentinelで自動フェイルオーバーを組む設定例とElastiCache Multi-AZとの比較](https://www.issoh.co.jp/tech/details/19851/)で扱っています。公式の解説自体も、障害時にまれに二重に取れても困らないなら、この構成のままでよいとしています。

## Redlockの5台構成の取得手順と、Kleppmannの指摘を受けた採用判断

フェイルオーバーの穴を埋めるために公式が示すのが、複数の独立したRedisに同時にロックを取るRedlockです。

### 独立した5台のマスターの過半数3台で取得し、経過時間を差し引く手順

公式の解説は、レプリケーションで結ばない独立したマスターを5台（N=5）置く例で説明しています。

1. 現在時刻をミリ秒で記録する
2. 5台すべてに、同じキーと同じ乱数で`SET NX PX`を並行して送る。1台あたりの待ちは、期限10秒なら5〜50ミリ秒程度に抑える
3. 過半数の3台以上で取れ、かつ経過時間が期限より短ければ取得成功とする
4. ロックの有効時間は、最初の期限から経過時間を引いた残りとみなす
5. 失敗したら、取れたと思っていない台も含めて全台で解放する

Python・Go・Java・Node.jsなどの実装（Pottery、Redsync、Redisson、node-redlockなど）は、同じページに一覧があります。

### 時計のずれと再起動後の遅延起動など、Redlockが置くタイミングの前提

Redlockの安全性は、時間の前提の上に成り立っています。公式の解説自身が、各サーバーの時計の進み方のずれが期限に比べて小さいことを前提とし、RedisのTTLは単調時計ではないため、時刻が飛ぶと複数のプロセスが取得し得ると注意書きしています。

再起動にも条件があります。既定の設定（AOFのfsyncは毎秒）では、停電で落ちた台がロックのキーを失ったまま戻り、再び過半数が作れてしまいます。対策は`appendfsync always`にするか、落ちた台を最大のTTLより長く参加させない遅延起動です。

Kleppmannは、こうした前提に依存する点と、後述のフェンシングトークンを生成できない点を挙げ、正しさが要るロックにはRedlockを使わず、ZooKeeperのような合意システムかトランザクションを持つDBを使うよう主張しました。公式ページはこの分析とantirezの反論を並べて載せ、どちらを採るにせよフェンシングトークンを実装するよう求めています。5台の独立したRedisを運用する負担を考えると、受託開発の現場でRedlockを選ぶ場面は多くありません。効率目的なら単一Redisで足り、正しさ目的ならRedlockでも足りないからです。

## フェンシングトークンをINCRで払い出し、DBの条件付き更新で古い書き込みを拒否

ロックが外れたあとに遅れて届く書き込みを止める仕組みが、フェンシングトークンです。Kleppmannの例では、プロセス1がトークン33、プロセス2が34を受け取り、保存先は34を処理した後に届いた33の書き込みを拒否します。

### ロックを取るたびにINCRで単調増加する番号を受け取るPythonコード

ロックの取得と同時に、増え続ける番号を1つ払い出します。番号はロックとは別のキーに持ち、期限を付けません。

```
def acquire_with_fence(resource, ttl_ms=30000):
    token = acquire(f"lock:{resource}", ttl_ms)    # 前のコードの関数
    if token is None:
        return None, None
    fence = r.incr(f"fence:{resource}")           # 取得のたびに1ずつ増える
    return token, fence


token, fence = acquire_with_fence("stock-sync:SKU-1001")
if token:
    try:
        sync_stock("SKU-1001", fence)             # 書き込みに番号を添える
    finally:
        release("lock:stock-sync:SKU-1001", token)
```

ロックを持たないまま番号だけを取ることはできない作りにしておきます。番号の大小で後勝ちを判定するのは、次の保存先の側です。

### UPDATEのWHERE句でトークンが古い書き込みを弾くSQLとカウンターの永続化

保存先のテーブルに、最後に受け付けた番号の列を足します。更新は、手元の番号が記録より大きいときだけ通します。

```
ALTER TABLE stock ADD COLUMN fence BIGINT NOT NULL DEFAULT 0;

UPDATE stock
   SET quantity = :quantity,
       fence    = :fence
 WHERE sku = :sku
   AND fence < :fence;
-- 更新件数が0なら、より新しい保持者が既に書いている。処理を中止する
```

GCで止まっていたプロセスが古い番号で書き込んでも、更新件数が0になって弾かれます。注意したいのは番号の払い出し元です。`INCR`のキーがフェイルオーバーで巻き戻ると、新しい保持者が小さい番号を受け取り、その書き込みまで拒否されます。安全側には倒れるものの処理が止まるため、カウンターのRedisは永続化を有効にするか、DBのシーケンスから払い出す形を検討してください。DBの行ロックで同じ目的を果たす方法は[楽観ロックと悲観ロックの違いと使い分け｜PostgreSQL・MySQLで実測](https://www.issoh.co.jp/tech/details/5739/)で比べています。

## Redisの分散ロックを使う条件と、DBの行ロックや一意制約に任せる場面

判断の軸は、ロックが外れたときの被害です。

### 二重実行が無駄なコストで済む効率目的のロックに単一Redisを使う判断

次のような処理は、まれに二重実行されても結果が壊れません。単一Redisの`SET NX PX`とLua解放で十分です。

- 定期バッチやcronを複数台で同時に走らせないための排他
- 重い集計やキャッシュの再生成を1プロセスに絞る処理（[Redisキャッシュの実装方法：Cache-AsideとTTL設計・スタンピード対策をredis-pyのコードで解説](https://www.issoh.co.jp/tech/details/19857/)のスタンピード対策）
- 外部APIへの同じ問い合わせの重複を減らす処理

いずれも、重複して走った場合の損失は計算時間や外部APIの利用料にとどまります。この用途でRedlockやフェンシングトークンまで入れるのは過剰です。

### 決済や在庫の確定など、二重実行が事故になる処理をDB側で止める判断

決済の確定、在庫の引き当て、ポイントの付与のように1回の二重実行が金銭や信用の事故になる処理は、Redisのロックを正しさの根拠にしません。Redisのロックは同時実行を減らす前段として置き、最後の砦を担うのはDBです。注文IDの一意制約、前章の条件付き更新、トランザクション内の行ロックのいずれかで、二重の書き込みが物理的に通らない形にします。行ロックの順序を誤ると[デッドロックとは？DBトランザクションで起きる原因・例と解消方法](https://www.issoh.co.jp/tech/details/4122/)で扱う停止が起きるので、ロックの範囲は狭く保ちます。

Redisとデータベースのどちらに排他を任せるか、既存システムの二重計上をどの層で止めるかの切り分けから迷う場合は、[データベース設計・移行支援](https://www.issoh.co.jp/service/system/database/)でデータの整合性の設計から相談を受けています。

## よくある質問

Redisの分散ロックについて、よく検索される質問に答えます。

### RedisのSETNXコマンドは今でも使えますか？

使えます。公式ページは2.6.12で非推奨と位置づけていますが、コマンド自体は残っており、既存のコードが急に動かなくなることはありません。ただし期限を同時に付けられないため、ロックの用途には向きません。新しく書くなら`SET キー 値 NX PX ミリ秒`にし、既存の`SETNX`と`EXPIRE`の組み合わせは、改修の機会に1コマンドへ置き換えてください。SETのページは、`SETNX`などが将来の版で削除される可能性にも触れています。

### ロックのTTL（有効期限）は何秒にすればよいですか？

ロックの中で行う処理の最悪時間より長く取ります。平均3秒のバッチでも、DBの混雑で20秒かかる日があるなら、設定するTTLの目安は30秒以上です。短すぎると処理中に外れて二重実行になり、長すぎるとプロセスが落ちたときに後続がその時間だけ待たされます。処理時間が読めない場合は、短めのTTLで取ってredis-pyの`extend`で延長する形にします。公式の例は30000ミリ秒（30秒）です。

### Redis Clusterでも同じ方法で分散ロックを使えますか？

使えます。1つのロックキーは1つのハッシュスロット、つまり1つのシャードのマスターに置かれるので、動きは単一インスタンスのロックと同じです。解放のLuaもキーが1つなので問題ありません。ただし各シャードのマスターとレプリカの関係は非同期のため、フェイルオーバー時にロックが消える性質も同じです。Redis Clusterをそのまま5台並べてもRedlockにはなりません。Clusterの仕組みは[Redis Clusterの構築手順：16384ハッシュスロットの仕組みとMOVED・ASK、redis-pyでの接続と再シャーディング](https://www.issoh.co.jp/tech/details/19853/)で扱いました。

### RedissonやRedsyncなどのライブラリを使うべきですか？

自前で書くより、言語ごとの定番ライブラリを使う方が安全です。Pythonならredis-pyの`Lock`、JavaならRedisson、GoならRedsyncが、公式ページの実装一覧にも載っています。ただし、ライブラリを使っても期限切れやフェイルオーバーで外れる性質は変わりません。Redissonの`RLock`のように自動で延長する機能もありますが、延長はプロセスが動いている前提の仕組みで、GCの停止中は延長も止まります。ライブラリ選びより、外れたときの被害をDB側で止めているかを先に確かめてください。

### ロックが取れなかったときは待つべきですか、すぐ失敗させるべきですか？

処理の性質で分けます。定期バッチのように「誰か1台が実行すればよい」処理は、待たずに終了させるのが自然です。ユーザーの操作のように結果を返す必要がある処理では、数秒の上限を付けて待ち、超えたら「処理中です」と返す方針です。redis-pyなら`blocking_timeout`で上限を指定し、`blocking=False`にすれば待たずに結果を返します。上限を付けずに待たせると、ロックを持つプロセスが詰まったときに後続のリクエストがすべて止まり、接続プールを使い切ります。

## 関連記事

- [Redisとは：仕組みとデータ型・Redis 8.10系の新機能とライセンス、Dockerで動かす手順](https://www.issoh.co.jp/tech/details/18876/)：Redis本体の仕組みと版
- [Redisキャッシュの実装方法：Cache-AsideとTTL設計・スタンピード対策をredis-pyのコードで解説](https://www.issoh.co.jp/tech/details/19857/)：短いロックでDBへの集中を防ぐ使い方
- [Redisの冗長化：レプリケーションとSentinelで自動フェイルオーバーを組む設定例とElastiCache Multi-AZとの比較](https://www.issoh.co.jp/tech/details/19851/)：ロックが消える経路になるフェイルオーバーの構成
- [楽観ロックと悲観ロックの違いと使い分け｜PostgreSQL・MySQLで実測](https://www.issoh.co.jp/tech/details/5739/)：DB側で排他を取る方法
- [デッドロックとは？DBトランザクションで起きる原因・例と解消方法](https://www.issoh.co.jp/tech/details/4122/)：行ロックを使うときの注意

---

出典: [RedisのSETNXロック実装：SET NX PXとLuaでの解放、Redlockとフェンシングトークンの判断【2026年11月】](<https://www.issoh.co.jp/tech/details/19929/>)（株式会社一創）
