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

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

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

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

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
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); //释放锁
}

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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);
}

但这样还有个问题。。。

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

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

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

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

不!

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

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

这个时候!

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

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

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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语言实现

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

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