浅谈分布式锁实现原理

本篇讲的是基于redis实现的分布式锁

很多程序员都知道redis有个命令叫setnx，它可以给我们的redis加锁

执行这个命令，如果它判断这个锁的名字，也就是key存在的时候，不做操作

假设我这里有段代码，我需要给他加锁以保证线程安全，解决分布式下的资源共享问题

String lockKey = "myLock";
Boolean result = stringRedisTemplate.opsForValue().setIfAbsent(lockKey, "achao");  //加锁
if (!result) {
    throw new Exception("error!");
}
//执行业务
System.out.println("执行业务");
stringRedisTemplate.delete(lockKey);  //释放锁

现在有个问题，就是如果我按上面这样写，如果我们中途程序执行的时候抛出了一个异常，那么我们的锁就永远得不到释放，下一个线程过来，发现锁没释放，就导致整个系统卡死

为了解决这个问题，我们加上try/finally语句

String lockKey = "myLock";
Boolean result;
try {
    result = stringRedisTemplate.opsForValue().setIfAbsent(lockKey, "achao");
    if (!result) {
        throw new Exception("error!");
    }
    //执行业务
    System.out.println("执行业务");
} finally {
    stringRedisTemplate.delete(lockKey);			//释放锁
}

这样之后，程序执行出了异常，咱们的锁也能得到释放了

但是如果执行到一半，程序挂了。。。比如服务器死机，或者重启等等，这样我们的锁还是得不到释放

所以，我们可以给这个锁设置个有效期

String lockKey = "myLock";
Boolean result;
try {
    result = stringRedisTemplate.opsForValue().setIfAbsent(lockKey, "achao");		//加锁
    stringRedisTemplate.expire(lockKey, 30, TimeUnit.SECONDS);		//设置有效期
    if (!result) {
        throw new Exception("error!");
    }
    //执行业务
    System.out.println("执行业务");
} finally {
    stringRedisTemplate.delete(lockKey);
}

但这样还有个问题。。。

我在执行第一句加锁，刚执行完，我第二句设置有效期还没执行，这。。。就跟上面一样了

所以我们又来，把它俩合成一条代码

result = stringRedisTemplate.opsForValue().setIfAbsent(lockKey, "achao",10,TimeUnit.SECONDS);

这样，就不会出现那种问题了，但你以为这就结束了？？？

不！

设想，在高并发下，我们第一个线程进来，他的锁有效期是10秒，但他执行了15秒，在10秒的时候他的锁有效期到了，这时候，他释放了锁。

第二个线程，他的锁有效期也是十秒，他在第一个线程执行到10秒的时候开始执行，它看到前面的锁已经失效，那么他又可以加锁了！

这个时候！

两个线程再执行了5秒，第一个线程执行完业务逻辑，到了finally语句的时候，他执行释放锁的操作，可是这个锁。。。是第二个线程的锁！

然后第三个线程，它发现前面的锁被释放掉了，然后它又可以加锁了。。。

第二个线程执行到finally的时候又释放了第三把锁。。。

这样我们就相当于没有锁了

我们这个时候就需要给requestId一个随机值

String lockKey = "myLock";
Boolean result;
String requestId = UUID.randomUUID().toString();	//生成随机值
try {
    result = stringRedisTemplate.opsForValue().setIfAbsent(lockKey, requestId, 10, TimeUnit.SECONDS);
    if (!result) {
        throw new Exception("error!");
    }
    //执行业务
    System.out.println("执行业务");
} finally {
    if (requestId.equals(stringRedisTemplate.opsForValue().get(lockKey))) {
        stringRedisTemplate.delete(lockKey);
    }
}

这样，就不会删除到别的线程的锁了

然而，这个时间设置很令人头疼，如果锁失效时间设置为5s，可能太少，但如果设置为30s，也可能不够。。。比如mysql执行卡住了，遇到了慢查询之类的

但如果我设置非常久。。。比如设置个30分钟，那如果执行到finally之前服务器死机了，这样就变成30分钟锁释放了才能再执行下一个线程了。。。

所以我们一般采用锁续命的方式：

新建一个分支线程，设置一个定时任务，比如每10s判断一下线程还活着没，如果这个线程存在，就把expire再设置成30s，重置锁的失效时间

这就是分布式锁的底层原理了，具体实现这个锁续命的操作，可以使用redisson

redisson调用LUA脚本（一个小众化脚本语言）实现，用的hash保证原子性，内部机制采用C语言实现

String lockKey = "myLock";
RLock lock = redisson.getLock(lockKey);					//1 获得锁对象
try {
    lock.lock();					//2  加锁（默认设置了有效时间，并开启分支线程定时续命）
    //业务
    System.out.println("业务");
}finally {
    lock.unlock();				//3  解锁
}

就这样，redisson帮我们做了以上所有操作，一个很漂亮的分布式锁，就只需要这三行代码