← 返回学习路线

SYSTEM

分布式锁

八股2.7 分布式锁system
src/content/notes/system/分布式锁.md

2.7 分布式锁

SETNX + 过期时间

最简单的分布式锁用 SETNX(SET if Not eXists)实现:

# 加锁(原子操作:SET key value NX EX seconds)
SET lock:order:10086 1 NX EX 30

# 释放锁需要先判断是否是自己的锁,用 Lua 脚本保证原子性
# 如果直接 DEL 可能误删别人的锁

存在的问题:

  1. 业务执行超过锁过期时间,锁自动释放后被别人获取,自己执行完误删了别人的锁。
  2. 锁过期但业务未完成,没有续期机制。
  3. Redis 单机宕机,锁丢失。

Redisson 看门狗机制

Redisson 是 Redis 的 Java 客户端,提供了功能完善的分布式锁实现:

RLock lock = redissonClient.getLock("lock:order:10086");
lock.lock();  // 默认30秒过期,看门狗每10秒续期到30秒
// 或指定超时时间
lock.lock(30, TimeUnit.SECONDS);
try {
    // 执行业务逻辑
} finally {
    lock.unlock();
}

看门狗(Watchdog)机制:如果调用 lock() 不指定过期时间,Redisson 启动一个定时任务(每 10 秒),检查持有锁的线程是否还在执行,如果还在就续期到 30 秒。业务执行完 unlock() 后取消定时任务。这样锁不会因为业务执行时间长而过早释放。

Redisson 锁还支持:

  • 可重入:同一线程可多次获取锁,通过 Hash 结构记录重入次数。
  • 公平锁:按请求顺序获取锁。
  • 读写锁:读读共享、读写互斥。

RedLock 算法

RedLock 解决单点 Redis 分布式锁的可靠性问题:

  1. 获取当前时间。
  2. 依次向 N 个(通常 5 个)独立 Redis 实例请求加锁,每个请求设短超时时间。
  3. 如果获取了 majority(多数,即 N/2+1 = 3 个)以上的锁,且总耗时小于锁过期时间,则加锁成功。
  4. 加锁失败时,向所有实例释放锁。

争议:Martin Kleppmann 指出 RedLock 依赖系统时钟,如果某节点发生 GC pause 或时钟跳变,可能导致锁失效。antirez 对此有反驳。生产中如果对正确性要求极高,建议用 ZooKeeper / etcd 的分布式锁。

面试题

Q:Redis 如何实现分布式锁?

A:最简单的方式是 SET key value NX EX seconds,NX 保证互斥,EX 设过期防死锁。但这种方式有锁过期但业务未完成的问题。生产中通常用 Redisson:调用 lock() 不传过期时间会自动启动看门狗,每 10 秒续期到 30 秒,业务执行完 unlock() 取消续期,避免锁过期误删。Redisson 还支持可重入锁(Hash 结构记录重入次数)、公平锁、读写锁。对可靠性要求更高时用 RedLock 算法,向多个独立 Redis 实例加锁,获取多数即成功,避免单点故障。但 RedLock 依赖时钟,GC pause 可能导致问题,对正确性要求极高时建议用 ZooKeeper。


补充材料 · 分布式锁

分布式锁

实现原理

分布式锁可以实现在分布式系统中多个进程有序的访问该临界资源,多个进程之间不会相互干扰

核心思想:当客户端要获取锁,则创建节点,使用完锁,则删除该节点

  1. 客户端获取锁时,在 /locks 节点下创建临时顺序节点

    • 使用临时节点是为了防止当服务器或客户端宕机以后节点无法删除(持久节点),导致锁无法释放
    • 使用顺序节点是为了系统自动编号排序,找最小的节点,防止客户端饥饿现象,保证公平
  2. 获取 /locks 目录的所有子节点,判断自己的子节点序号是否最小,成立则客户端获取到锁,使用完锁后将该节点删除

  3. 反之客户端需要找到比自己小的节点,对其注册事件监听器,监听删除事件

  4. 客户端的 Watcher 收到删除事件通知,就会重新判断当前节点是否是子节点中序号最小,如果是则获取到了锁, 如果不是则重复以上步骤继续获取到比自己小的一个节点并注册监听


Curator

Curator 实现分布式锁 API,在 Curator 中有五种锁方案:

  • InterProcessSemaphoreMutex:分布式排它锁(非可重入锁)

  • InterProcessMutex:分布式可重入排它锁

  • InterProcessReadWriteLock:分布式读写锁

  • InterProcessMultiLock:将多个锁作为单个实体管理的容器

  • InterProcessSemaphoreV2:共享信号量

public class CuratorLock {
    
    public static CuratorFramework getCuratorFramework() {
        // 重试策略对象
        ExponentialBackoffRetry policy = new ExponentialBackoffRetry(3000, 3);
        // 构建客户端
        CuratorFramework client = CuratorFrameworkFactory.builder()
                .connectString("192.168.3.128:2181")
                .connectionTimeoutMs(2000)	// 连接超时时间
                .sessionTimeoutMs(20000)	// 会话超时时间 单位ms
                .retryPolicy(policy)		// 重试策略
                .build();

        // 启动客户端
        client.start();
        System.out.println("zookeeper 启动成功");
        return client;
    }
    
    public static void main(String[] args) {
        // 创建分布式锁1
        InterProcessMutex lock1 = new InterProcessMutex(getCuratorFramework(), "/locks");

        // 创建分布式锁2
        InterProcessMutex lock2 = new InterProcessMutex(getCuratorFramework(), "/locks");

        new Thread(new Runnable() {
            @Override
            public void run() {
                lock1.acquire();
                System.out.println("线程1 获取到锁");

                Thread.sleep(5 * 1000);

                lock1.release();
                System.out.println("线程1 释放锁");
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                lock2.acquire();
                System.out.println("线程2 获取到锁");

                Thread.sleep(5 * 1000);

                lock2.release();
                System.out.println("线程2 释放锁");

            }
        }).start();
    }
}
<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-framework</artifactId>
    <version>4.3.0</version>
</dependency>
<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-recipes</artifactId>
    <version>4.3.0</version>
</dependency>
<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-client</artifactId>
    <version>4.3.0</version>

补充材料 · 分布式锁

分布式锁

基本操作

在分布式场景下,锁变量需要由一个共享存储系统来维护,多个客户端才可以通过访问共享存储系统来访问锁变量,加锁和释放锁的操作就变成了读取、判断和设置共享存储系统中的锁变量值多步操作

Redis 分布式锁的基本使用,悲观锁

  • 使用 SETNX 设置一个公共锁

    SETNX lock-key value	# value任意数,返回为1设置成功,返回为0设置失败

    NX:只在键不存在时,才对键进行设置操作,SET key value NX 效果等同于 SETNX key value

    XX:只在键已经存在时,才对键进行设置操作

    EX:设置键 key 的过期时间,单位时秒

    PX:设置键 key 的过期时间,单位时毫秒

    说明:由于 SET 命令加上选项已经可以完全取代 SETNX、SETEX、PSETEX 的功能,Redis 不推荐使用这几个命令

  • 操作完毕通过 DEL 操作释放锁

    DEL lock-key 
  • 使用 EXPIRE 为锁 key 添加存活(持有)时间,过期自动删除(放弃)锁,防止线程出现异常,无法释放锁

    EXPIRE lock-key second 
    PEXPIRE lock-key milliseconds

    通过 EXPIRE 设置过期时间缺乏原子性,如果在 SETNX 和 EXPIRE 之间出现异常,锁也无法释放

  • 在 SET 时指定过期时间,保证原子性

    SET key value NX [EX seconds | PX milliseconds]
    
    
    
    

防误删

场景描述:线程 A 正在执行,但是业务阻塞,在锁的过期时间内未执行完成,过期删除后线程 B 重新获取到锁,此时线程 A 执行完成,删除锁,导致线程 B 的锁被线程 A 误删

SETNX 获取锁时,设置一个指定的唯一值(UUID),释放前获取这个值,判断是否自己的锁,防止出现线程之间误删了其他线程的锁

// 加锁, unique_value作为客户端唯一性的标识,
// PX 10000 则表示 lock_key 会在 10s 后过期,以免客户端在这期间发生异常而无法释放锁
SET lock_key unique_value NX PX 10000

Lua 脚本(unlock.script)实现的释放锁操作的伪代码:key 类型参数会放入 KEYS 数组,其它参数会放入 ARGV 数组,在脚本中通过 KEYS 和 ARGV 传递参数,保证判断标识和释放锁这两个操作的原子性

EVAL "return redis.call('set', KEYS[1], ARGV[1])" 1 lock_key unique_value # 1 代表需要一个参数
// 释放锁,KEYS[1] 就是锁的 key,ARGV[1] 就是标识值,避免误释放
// 获取标识值,判断是否与当前线程标示一致
if redis.call("get", KEYS[1]) == ARGV[1] then
    return redis.call("del", KEYS[1])
else
    return 0
end

优化锁

不可重入

不可重入:同一个线程无法多次获取同一把锁

使用 hash 键,filed 是加锁的线程标识, value 是锁重入次数

|    key    |       value       |
|           |  filed  |  value  |
|-------------------------------|
|  lock_key | thread1 |    1    |

锁重入:

  • 加锁时判断锁的 filed 属性是否是当前线程,如果是将 value 加 1
  • 解锁时判断锁的 filed 属性是否是当前线程,首先将 value 减一,如果 value 为 0 直接释放锁

使用 Lua 脚本保证多条命令的原子性


不可重试

不可重试:获取锁只尝试一次就返回 false,没有重试机制

  • 利用 Lua 脚本尝试获取锁,获取失败获取锁的剩余超时时间 ttl,或者通过参数传入线程抢锁允许等待的时间
  • 利用订阅功能订阅锁释放的信息,然后线程挂起等待 ttl 时间
  • 利用 Lua 脚本在释放锁时,发布一条锁释放的消息

超时释放

超时释放:锁超时释放可以避免死锁,但如果是业务执行耗时较长,需要进行锁续时,防止业务未执行完提前释放锁

看门狗 Watch Dog 机制:

  • 获取锁成功后,提交周期任务,每隔一段时间(Redisson 中默认为过期时间 / 3),重置一次超时时间
  • 如果服务宕机,Watch Dog 机制线程就停止,就不会再延长 key 的过期时间
  • 释放锁后,终止周期任务

主从一致

主从一致性:集群模式下,主从同步存在延迟,当加锁后主服务器宕机时,从服务器还没同步主服务器中的锁数据,此时从服务器升级为主服务器,其他线程又可以获取到锁

将服务器升级为多主多从:

  • 获取锁需要从所有主服务器 SET 成功才算获取成功
  • 某个 master 宕机,slave 还没有同步锁数据就升级为 master,其他线程尝试加锁会加锁失败,因为其他 master 上已经存在该锁