跳到主要内容
约 13 分钟4 张卡

分布式锁

分布式锁用来协调多个进程对同一资源的访问,让取得锁的任务在约定期限内操作资源。难点在于:锁到期了,持锁任务却未必停止。理解 Redis 分布式锁,既要能解释原子加锁和安全释放,也要能推演进程暂停、续租失败后,旧任务会造成什么影响。本文以 Redis 6、7 为基线。

1. 面试核心​

先记住这几条,再读正文
  • SET key token NX PX ttl 在一条命令里同时完成锁占用和有效期设置,避免拿到锁却没设过期时间。
  • 释放锁时,要在 Redis 内原子比较所有者 token,再删除,防止旧任务误删新持有者的锁。
  • 续租也要原子校验 token,只延长本次获取的锁;结果未知时按剩余有效期决定何时停止新操作。卡 · 原子续租
  • 租约到期不会终止旧任务。资源端可用递增的 fencing token 拒绝落后的请求,编号生成器还要跨故障保持单调性。卡 · 原子加锁与过期
  • 异步复制可能在故障转移时丢失已经取得的锁;超时重试造成的重复业务操作,还需要幂等机制处理。
  • 同一热点资源的临界区仍然串行执行。减少无效轮询可以降低争用开销,提升业务吞吐则要缩短临界区,或在不破坏共同约束的前提下改变协调方式。卡 · 争用为什么会拖慢业务
  • Go 调用应区分未取得锁与调用错误,为网络调用设置期限,并用独立的短期限执行条件释放;取消请求不会自动撤销 Redis 已执行的命令。卡 · Go 客户端的最小调用

2. 原子加锁与过期​

在单个 Redis 节点上,加锁和设置有效期要放在同一条命令里完成:

SET resource:42 <random-token> NX PX 10000

NX 表示只有键不存在时才写入,PX 10000 设置 10000 毫秒有效期。这段有效期就是租约:超过它,其他任务可以重新取得锁。token 标识本次获取,要为每次获取生成独立且足够随机的值。

如果拆成 SETNX 和 EXPIRE,进程可能在两条命令之间崩溃:锁已经占用,过期时间却没设上,其他任务就无法靠到期释放来接替它。

客户端收到 OK 后,才能在本次租约的有效期内执行。请求超时只说明没有拿到确定的响应,Redis 可能已经加锁成功。此时应按 token 核对或等待租约结束,不能直接认为自己已经取得锁。

3. 锁释放与所有者校验​

释放锁时,要确认这个键仍属于本次获取。例如 A 的锁过期后,B 取得了同名锁;A 恢复执行时如果直接 DEL,删掉的就是 B 的锁。

下面的 Lua 脚本把所有者比较和删除放在 Redis 内原子执行:

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

脚本返回 1,表示 token 匹配并删除了锁;返回 0,表示当前键不属于本次获取。如果把 GET 和 DEL 分成两条命令,即使检查时匹配,检查之后锁也可能过期并被 B 重新取得,仍会误删。

4. 租约时间​

租约要留出业务执行、网络往返和线程调度的时间,但不能一味设长。租约越长,持有者崩溃后,其他请求等到锁自动释放的时间也越长。客户端计算还能执行多久时,还要扣除获取锁已经花掉的时间。

正常运行的任务可以靠续租延长有效期,但进程冻结、长时间 GC 或网络隔离都可能让续租来不及完成。任务恢复时要重新检查租约状态,不能因为自己曾经拿到锁,就继续假定锁还有效。

即使客户端发现已经失锁并停止工作,之前发出的外部请求也可能还在途中。要阻止这些旧请求修改资源,还需要资源端参与校验。

5. 原子续租​

续租和释放遵守同一个原则:只操作本次取得的锁。下面的脚本在 token 匹配时才延长期限:

if redis.call('get', KEYS[1]) == ARGV[1] then
return redis.call('pexpire', KEYS[1], ARGV[2])
end
return 0

脚本返回 1 表示延期成功,返回 0 表示当前锁已不属于本次获取。如果省略比较、直接调用 PEXPIRE,旧任务可能延长另一个持有者的新锁。

续租超时同样是结果未知,不能按「已经续租成功」继续运行。客户端要根据最后确认的剩余租约,及时停止发起新操作;已经发出的请求,则靠资源端版本校验和业务幂等处理。

6. 锁过期与 fencing token​

fencing token 是每次成功获取锁时分配的递增编号,资源端用它识别落后的持有者。它与前面的随机 token 用途不同:随机值只区分「是不是本次获取」,递增编号还能区分先后。

例如 A 取得 10 秒锁后暂停了 15 秒,B 在锁到期后取得新锁并写入资源。A 恢复后仍可能继续写,但它携带的编号比 B 小。资源端保存已接受的最大编号,把小于这个编号的写入拒绝掉;收到更大的编号时更新记录。编号检查和业务修改必须原子完成,否则检查之后仍可能插入新持有者的操作。

同一租约内的多次请求可以携带相同编号,业务用请求 ID 区分和去重。如果资源端每次都只接受严格更大的编号,同一持有者就只能写一次,后续正常请求也会被拒绝。

编号生成器还要在故障后保持递增。仅在异步复制的 Redis 上用 INCR,切换副本时可能发生计数回退。外部资源如果根本不能检查编号,也就无法靠这套机制拒绝旧写入。

7. 主从故障转移​

异步复制可能让两个客户端都认为自己持有锁:A 在主节点上加锁成功,但锁还没复制出去,主节点就故障了。落后的副本被提升后看不到这把锁,B 就可能再次加锁成功。复制与接管机制见 故障与数据丢失。

Redlock 通过在多个独立节点上取得多数锁来获取租约。获取总耗时必须小于有效期,还要扣除时钟漂移余量。这些条件仍依赖对故障和时间的假设,也没有消除进程暂停后恢复执行的问题。

资金或库存保存在数据库时,可以优先用数据库条件更新来保护状态。确实需要协调外部资源时,再考虑一致性协调服务,并让资源端校验 fencing token。

8. 业务幂等​

请求超时后,客户端无法仅凭响应判断操作是否完成。重试会再次触发临界区,因此需要独立的幂等机制。

  • 稳定请求 ID 标识同一次业务操作。
  • 唯一约束或状态条件限制重复修改。
  • 执行记录支持事后核对结果。
  • 重试设置次数和总时间上限。

锁未取得时,应明确返回、等待或排队策略。队列长度与等待时间也需设置上限。

9. 多资源加锁​

多个资源使用统一的获取顺序。例如按规范化资源 ID 升序逐个加锁。中途失败时,按各自 token 释放已取得的锁。下一次尝试使用有界随机退避。

如果 A 先锁资源 1 再等资源 2,B 先锁资源 2 再等资源 1,就形成了循环等待。租约只能让锁最终到期,不能让这次操作顺利完成。多个资源还要求一起成功或一起失败时,需要事务或明确的协调协议。

10. 争用为什么会拖慢业务​

锁竞争同时消耗网络资源和业务等待时间。获取失败后立即再发 SET NX,每次都要经过连接、网络往返和 Redis 命令处理;请求多时,还会增加客户端连接池与服务端的排队。它不是只在本地检查一个变量的轻量自旋。

更根本的限制是同一资源的临界区不能并行执行。假设每次持锁工作平均需要 20 毫秒,在持续有请求等待、没有其他开销的理想条件下,这个资源最多完成约 1 / 0.02 = 50 次每秒。增加到一百个争抢者不会把它变成五千次每秒,只会让更多请求等待和重试。这个推算描述串行服务时间,不是 Redis 的性能测试结果。

改进时先区分哪些操作必须共享同一个约束:

方法能减少什么成立条件与代价
有界退避并加入随机抖动,或有界排队密集轮询和同一时刻集中重试设总期限、次数和队列长度;等待延迟可能增加,不能提高同一临界区的服务速率,也不保证公平
缩短临界区持锁时间和后续等待把无共享依赖的计算、准备工作移出去;基于旧状态做的准备,进入临界区后仍要重新校验
按独立资源分锁,例如每个订单一把无关资源之间的误串行化订单确实独立才成立;若还共同扣减同一库存或账户,不能仅按订单拆锁就宣称约束受到保护
用单条原子操作或条件更新获取、释放与重试锁的往返Redis 中的独立计数可用 INCR;权威数据在数据库时,可用带状态、版本或库存谓词的 UPDATE,并检查受影响行数

原子命令或条件更新只能保护它实际检查和修改的状态,不能顺带保证其他系统中的扣款、发货或消息投递也只发生一次。数据库方案可见 乐观并发控制。多资源需要共同保持约束时,仍要按前面的统一顺序、事务或协调协议处理,不能为了降低竞争把一条不可拆的约束拆掉。

11. Go 客户端的最小调用​

一次获取要分别判断 acquired 和 err。以下使用 Go 1.22 与 go-redis/v9 的 9.7.0 版本,固定操作 lock:order:42,只展示单次尝试,不做自动续租或重试。handle 是订单处理函数,必须遵守传入的 context,并在权威资源上实施必要的状态校验。

下面的 releaseLua 与按 token 释放中的脚本相同。tryOrder 的 acquired=true 只表示本次调用曾确认取得租约,不表示函数返回时锁还存在,也不表示业务一定成功。

package main

import (
"context"
"crypto/rand"
"encoding/hex"
"errors"
"fmt"
"os"
"time"

"github.com/redis/go-redis/v9"
)

const releaseLua = `if redis.call('get', KEYS[1]) == ARGV[1] then
return redis.call('del', KEYS[1])
end
return 0
`

func tryOrder(ctx context.Context, client *redis.Client,
handle func(context.Context) error) (acquired bool, err error) {
const key = "lock:order:42"
const ttl = 2 * time.Second
var random [16]byte
if _, err = rand.Read(random[:]); err != nil {
return false, err
}
token := hex.EncodeToString(random[:])
started := time.Now()
callCtx, cancel := context.WithTimeout(ctx, 200*time.Millisecond)
acquired, err = client.SetNX(callCtx, key, token, ttl).Result()
cancel()
if err != nil {
return false, fmt.Errorf("获取结果未确认: %w", err)
}
if !acquired {
return false, nil
}

defer func() {
releaseCtx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond)
defer cancel()
n, releaseErr := client.Eval(releaseCtx, releaseLua, []string{key}, token).Int64()
if releaseErr != nil {
err = errors.Join(err, fmt.Errorf("释放结果未确认: %w", releaseErr))
} else if n == 0 {
err = errors.Join(err, errors.New("释放时已不再持有本次锁"))
}
}()

workCtx, cancel := context.WithDeadline(ctx, started.Add(ttl-200*time.Millisecond))
defer cancel()
if err = workCtx.Err(); err != nil {
return true, err
}
err = handle(workCtx)
return true, errors.Join(err, workCtx.Err())
}

这里生成 128 位随机所有者标识,每次获取都重新生成。SetNX 带正租约参数时,客户端把条件写入和有效期放在同一条 SET 命令中;方法名不代表发出一条不带有效期的裸 SETNX。租约是两秒,业务期限从请求发出前开始计算,并预留 200 毫秒。这个余量只是示例预算,不能保证进程暂停、调度延迟或时钟异常一定小于它。

调用时还要配置客户端的网络超时和重试行为:

func main() {
client := redis.NewClient(&redis.Options{
Addr: os.Getenv("REDIS_ADDR"),
Protocol: 2,
MaxRetries: -1,
ContextTimeoutEnabled: true,
DialTimeout: 200 * time.Millisecond,
ReadTimeout: 200 * time.Millisecond,
WriteTimeout: 200 * time.Millisecond,
})
defer client.Close()
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
acquired, err := tryOrder(ctx, client, func(ctx context.Context) error {
fmt.Println("进入订单 42 的处理")
return ctx.Err()
})
switch {
case err != nil:
fmt.Println("需要按错误和业务记录核对结果:", err)
case !acquired:
fmt.Println("本次没有取得锁")
default:
fmt.Println("示例处理和条件释放完成")
}
}

两个代码块放在同一个 main.go 中,安装上述版本的客户端,并把 REDIS_ADDR 设置为专用实验 Redis 的地址即可运行。示例回调只打印一行,实际处理逻辑放在 handle 中。MaxRetries: -1 在这个版本里表示禁用客户端自动重试,0 会使用默认重试次数;ContextTimeoutEnabled: true 让命令读写使用 context 的期限,网络超时则为底层调用提供另一个上限。

获取时 false, nil 表示收到明确的未取得结果;错误分支不进入 handle。若请求已送达但响应丢失,Redis 里仍可能存在本次 token 对应的锁。这个最小示例不再次获取、不执行临界区,等待短租约自行释放;不能把超时报错理解成锁一定没有写入。

释放使用一个独立的 200 毫秒 context,因此业务 context 已取消后仍能尝试清理;它没有授权继续执行业务。释放返回 0 说明此时没有本次所有权,返回错误则可能是释放结果未知,都不能用无条件 DEL 补救。业务执行失败、取消和释放失败可以同时发生,因此代码合并保留错误,而不把它们覆盖成单一「锁失败」。

context 取消是合作式通知,不会强制停止 handle,也不会撤销 Redis 或外部系统已经执行的命令。 这个客户端版本对在途网络 I/O 的约束依赖读写期限,不能把取消等同于立即中断所有 I/O。即使回调开始前检查了期限,也可能紧接着发生长暂停;所以这段代码不能代替资源端 fencing、条件更新与幂等,更不构成一个跨故障完整锁库。

12. 常见问题​

12.1 可以用线程 ID 作为所有者 token 吗?​

不够。线程 ID 会在不同进程中重复。同一线程后续获取的锁也需与旧任务区分。因此,每次获取都应生成独立且难碰撞的 token。

12.2 有 watchdog 自动续租,就不会失去锁了吗?​

13. 面试题卡片​

14. 参考资料​

来源:Coding 101 原文 · 免费阅读,引用请保留出处。内容使用说明