如何设计高性能的分布式锁

什么是分布式锁？

在 JVM 中，在多线程并发的情况下，我们可以使用同步锁或 Lock 锁，保证在同一时间内，只能有一个线程修改共享变量或执行代码块。但现在我们的服务都是基于分布式集群来实现部署的，对于一些共享资源，在分布式环境下使用 Java 锁的方式就失去作用了。

使用数据库实现一个分布式锁比较简单易懂，直接基于数据库实现就行了，不需要再引入第三方中间件，所以这是很多分布式业务实现分布式锁的首选。但是数据库实现的分布式锁在一定程度上，存在性能瓶颈，所以我推荐使用Redis。

Redis 实现分布式锁

Redis 实现分布式锁的方式，是使用 SETNX+EXPIRE 组合来实现，在 Redis 2.6.12 版本之前，具体实现代码如下：

public static boolean tryLock(Jedis jedis, String lockKey, String requestId, int expireTime) {

    Long result = jedis.setnx(lockKey, requestId);//设置锁
    if (result == 1) {//获取锁成功
        // 若在这里程序突然崩溃，则无法设置过期时间，将发生死锁
        jedis.expire(lockKey, expireTime);//通过过期时间删除锁
        return true;
    }
    return false;
}

 

 

这种方式实现的分布式锁，是通过 setnx() 方法设置锁，如果 lockKey 存在，则返回失败，否则返回成功。设置成功之后，为了能在完成同步代码之后成功释放锁，方法中还需要使用 expire() 方法给 lockKey 值设置一个过期时间，确认 key 值删除，避免出现锁无法释放，导致下一个线程无法获取到锁，即死锁问题。

​ 如果程序在设置过期时间之前、设置锁之后出现崩溃，此时如果 lockKey 没有设置过期时间，将会出现死锁问题。

在 Redis 2.6.12 版本后 SETNX 增加了过期时间参数：

private static final String LOCK_SUCCESS = "OK";
    private static final String SET_IF_NOT_EXIST = "NX";
    private static final String SET_WITH_EXPIRE_TIME = "PX";

    /**
     * 尝试获取分布式锁
     * @param jedis Redis客户端
     * @param lockKey 锁
     * @param requestId 请求标识
     * @param expireTime 超期时间
     * @return 是否获取成功
     */
    public static boolean tryLock(Jedis jedis, String lockKey, String requestId, int expireTime) {

        String result = jedis.set(lockKey, requestId, SET_IF_NOT_EXIST, SET_WITH_EXPIRE_TIME, expireTime);

        if (LOCK_SUCCESS.equals(result)) {
            return true;
        }
        return false;

    }

我们也可以通过 Lua 脚本来实现锁的设置和过期时间的原子性，再通过 jedis.eval() 方法运行该脚本：

// 加锁脚本
private static final String SCRIPT_LOCK = "if redis.call('setnx', KEYS[1], ARGV[1]) == 1 then redis.call('pexpire', KEYS[1], ARGV[2]) return 1 else return 0 end";

// 解锁脚本
private static final String SCRIPT_UNLOCK = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";

虽然 SETNX 方法保证了设置锁和过期时间的原子性，但如果我们设置的过期时间比较短，而执行业务时间比较长，就会存在锁代码块失效的问题。我们需要将过期时间设置得足够长，来保证以上问题不会出现。

​ 这个方案是目前最优的分布式锁方案，但如果是在 Redis 集群环境下，依然存在问题。由于 Redis 集群数据同步到各个节点时是异步的，如果在 Master 节点获取到锁后，在没有同步到其它节点时，Master 节点崩溃了，此时新的 Master 节点依然可以获取锁，所以多个应用服务可以同时获取到锁。

Redlock 算法

​ Redisson 由 Redis 官方推出。它不仅提供了一系列的分布式的 Java 常用对象，还提供了许多分布式服务。Redisson 是基于 netty 通信框架实现的，所以支持非阻塞通信，性能相对于我们熟悉的 Jedis 会好一些。

​ Redisson 中实现了 Redis 分布式锁，且支持单点模式和集群模式。在集群模式下，Redisson 使用了 Redlock 算法，避免在 Master 节点崩溃切换到另外一个 Master 时，多个应用同时获得锁。我们可以通过一个应用服务获取分布式锁的流程，了解下 Redlock 算法的实现：

​ 具体的代码实现如下：

1. 首先引入 jar 包：

   <dependency>
        <groupId>org.redisson</groupId>
        <artifactId>redisson</artifactId>
        <version>3.8.2</version>
   </dependency>

    

2. 实现 Redisson 的配置文件：

   @Bean
   public RedissonClient redissonClient() {
      Config config = new Config();
      config.useClusterServers()
              .setScanInterval(2000) // 集群状态扫描间隔时间，单位是毫秒
              .addNodeAddress("redis://127.0.0.1:7000).setPassword("1")
              .addNodeAddress("redis://127.0.0.1:7001").setPassword("1")
              .addNodeAddress("redis://127.0.0.1:7002")
              .setPassword("1");
      return Redisson.create(config);
   }

    

3. 获取锁操作：

   long waitTimeout = 10;
   long leaseTime = 1;
   RLock lock1 = redissonClient1.getLock("lock1");
   RLock lock2 = redissonClient2.getLock("lock2");
   RLock lock3 = redissonClient3.getLock("lock3");
   
   RedissonRedLock redLock = new RedissonRedLock(lock1, lock2, lock3);
   // 同时加锁：lock1 lock2 lock3
   // 红锁在大部分节点上加锁成功就算成功，且设置总超时时间以及单个节点超时时间
   redLock.trylock(waitTimeout,leaseTime,TimeUnit.SECONDS);
   ...
   redLock.unlock(); 

扩展阅读：

Redis的三个框架：Jedis,Redisson,Lettuce

Jedis 地址：https://github.com/xetorthio/jedis，是Redis的Java实现客户端，提供了比较全面的Redis命令的支持。SpringBoot1.x系列中默认采用的是jedis。

Redisson 官网地址：https://redisson.org/，实现了分布式和可扩展的Java数据结构。

Lettuce 官网地址：https://lettuce.io/，高级Redis客户端，用于线程安全同步，异步和响应使用，支持集群，Sentinel，管道和编码器。SpringBoot2.x系列中抛弃了原有的jedis，默认采用lettuce。