redis分布式锁

Posted yanhe言和

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了redis分布式锁相关的知识,希望对你有一定的参考价值。

加锁

1 判断锁是否被占用,没有则获取锁(hset/hincrby)并设置过期时间(expire)

2 如果锁被占用,则判断是否是当前线程占用,如果是则重入(hincrby)并重置过期时间

3 否则获取锁失败

释放锁

1 判断自己的锁是否存在(hexists),不存在返回nil

2 如果存在则减1(hincrby-1),判断减1后是否为0 ,为0则del,并返回1

3 如果不为0,则返回0

续期

判断自己的锁是否存在hexists,如果存在则重置过期时间

 

1 是keys值的数量
lock 是锁的名字
1234567890 是uuid
30 是过期时间
这些参数只是测试用着方便
加锁
eval "if redis.call(\'exists\',KEYS[1])==0 or redis.call(\'hexists\',KEYS[1],ARGV[1]) ==1  then          redis.call(\'hincrby\',KEYS[1],ARGV[1],1)          redis.call(\'expire\',KEYS[1],ARGV[2])     return 1  else          return 0  end" 1 lock 1234567890 30
释放锁
eval "if redis.call(\'hexists\',KEYS[1],ARGV[1])==0 then     return nil elseif redis.call(\'hincrby\',KEYS[1],ARGV[1],-1)==0 then     return redis.call(\'del\',KEYS[1]) else     return 0 end" 1 lock 1234567891
续期
eval "if redis.call(\'hexists\',KEYS[1],ARGV[1])==1 then return redis.call(\'expire\',KEYS[1],ARGV[2]) else return 0 end" 1 lock 1234567890 30

Redis分布式锁

1.概述

分布式锁一般有三种实现方式:1.基于数据库实现分布式锁;2. 基于缓存(Redis,memcached,tair)实现分布式锁; 3.基于Zookeeper实现分布式锁。本片博客将介绍基于缓存实现分布式锁,这里主讲分别针对Redis 2.6.12 之前版本和Redis 2.6.12 及之后版本分布式锁的实现。

2.基于Redis(Redis 2.6.12版本之前)分布式锁的实现方式

(1)命令介绍

  1)SETX

  SETNX key value: setnx是『set if not exists』(即当key不存在时,则set)的简写。setnx具有原子性,当且仅当key不存在时,set一个key为val的字符串,返回1;若key存在,则什么都不做,返回0.

  2)GETSET

  GETSET key value:将给定 key 的值设为 value ,并返回 key 的旧值(old value)。当 key 存在但不是字符串类型时,返回一个错误。当 key 没有旧值时,也即是, key 不存在时,返回 nil 。

 

  3)GET

  GET key:返回 key 所关联的字符串值;如果 key 不存在那么返回特殊值 nil 。假如 key 储存的值不是字符串类型,返回一个错误,因为GET只能用于处理字符串值。

  4)EXPIRE

  EXPIRE key timeout:为key设置一个超时时间,单位为second,超过这个时间锁会自动释放,避免死锁。

 

  5)DELETE

  DELETE key:删除key

2)Redis实现分布式锁的原理

 

* 1.通过setnx(lock_timeout)实现,如果设置了锁返回1, 已经有值没有设置成功返回0


* 2.死锁问题:通过实践来判断是否过期,如果已经过期,获取到过期时间get(lockKey),然后getset(lock_timeout)判断是否和get相同,


* 相同则证明已经加锁成功,因为可能导致多线程同时执行getset(lock_timeout)方法,这可能导致多线程都只需getset后,对于判断加锁成功的线程,


* 再加expire(lockKey, LOCK_TIMEOUT, TimeUnit.MILLISECONDS)过期时间,防止多个线程同时叠加时间,导致锁时效时间翻倍


* 3.针对集群服务器时间不一致问题,可以调用redis的time()获取当前时间

 

(3)图解Redis分布式锁原理

技术图片

 

1. setnx(lockkey, 当前时间+过期超时时间) ,如果返回1,则获取锁成功;如果返回0则没有获取到锁,转向2。 
2. get(lockkey)获取锁的过期时间lockValueA ,并将这个lockValueA 值与当前的系统时间currentTime进行比较,如果小于当前系统时间,则认为这个锁已经超时,可以允许别的请求重新获取,转向3。 
3. 计算新的过期时间 newExpireTime=当前时间+过期超时时间,然后getset(lockkey, newExpireTime) 会返回当前lockkey的值lockValueB。 
4. 判断lockValueA与lockValueB 是否相等,如果相等,说明当前getset设置成功,获取到了锁。如果不相等,说明这个锁又被别的请求获取走了,那么当前请求可以直接返回失败,或者继续重试。 
5. 在获取到锁之后,当前线程可以开始自己的业务处理,当处理完毕后,比较自己的处理时间和对于锁设置的超时时间,如果小于锁设置的超时时间,则直接执行delete释放锁;如果大于锁设置的超时时间,则不需要再锁进行处理。

(4)缺点

Redis 2.6.12之前版本,使用SETNX命令实现Redis分布式锁,但是会出现各种各样的问题。具体罗列出以下几种:

1)setnx和expire的非原子性

设想一个极端场景,当某线程执行setnx,成功得到了锁:

技术图片

 

 

setnx刚执行成功,还未来得及执行expire指令,节点1 Duang的一声挂掉了。 

技术图片

 

 

这样一来,这把锁就没有设置过期时间,变得“长生不老”,别的线程再也无法获得锁了。如示例代码所示

示例代码

public static void wrongGetLock1(Jedis jedis, String lockKey, String requestId, int expireTime) {
 
    Long result = jedis.setnx(lockKey, requestId);
    if (result == 1) {
        // 若在这里程序突然崩溃,则无法设置过期时间,将发生死锁
        jedis.expire(lockKey, expireTime);
    }
 
}

setnx()方法作用就是SET IF NOT EXIST,expire()方法就是给锁加一个过期时间。乍一看好像和前面的set()方法结果一样,然而由于这是两条Redis命令,不具有原子性,如果程序在执行完setnx()之后突然崩溃,导致锁没有设置过期时间。那么将会发生死锁。网上之所以有人这样实现,是因为低版本的jedis并不支持多参数的set()方法。

2)出现并发的可能性

这里使用示例代码来描述

示例代码

这一种错误示例就比较难以发现问题,而且实现也比较复杂。实现思路:使用jedis.setnx()命令实现加锁,其中key是锁,value是锁的过期时间。执行过程:1. 通过setnx()方法尝试加锁,如果当前锁不存在,返回加锁成功。2. 如果锁已经存在则获取锁的过期时间,和当前时间比较,如果锁已经过期,则设置新的过期时间,返回加锁成功。代码如下:

 

public static boolean wrongGetLock2(Jedis jedis, String lockKey, int expireTime) {
 
    long expires = System.currentTimeMillis() + expireTime;
    String expiresStr = String.valueOf(expires);
 
    // 如果当前锁不存在,返回加锁成功
    if (jedis.setnx(lockKey, expiresStr) == 1) {
        return true;
    }
 
    // 如果锁存在,获取锁的过期时间
    String currentValueStr = jedis.get(lockKey);
    if (currentValueStr != null && Long.parseLong(currentValueStr) < System.currentTimeMillis()) {
        // 锁已过期,获取上一个锁的过期时间,并设置现在锁的过期时间
        String oldValueStr = jedis.getSet(lockKey, expiresStr);
        if (oldValueStr != null && oldValueStr.equals(currentValueStr)) {
            // 考虑多线程并发的情况,只有一个线程的设置值和当前值相同,它才有权利加锁
            return true;
        }
    }
 
    // 其他情况,一律返回加锁失败
    return false;
 
}

 

 那么这段代码问题在哪里?1. 由于是客户端自己生成过期时间,所以需要强制要求分布式下每个客户端的时间必须同步。 2. 当锁过期的时候,如果多个客户端同时执行jedis.getSet()方法,那么虽然最终只有一个客户端可以加锁,但是这个客户端的锁的过期时间可能被其他客户端覆盖。3. 锁不具备拥有者标识,即任何客户端都可以解锁。

 

3)del 导致误删

又是一个极端场景,假如某线程成功得到了锁,并且设置的超时时间是30秒。

技术图片

 

 

如果某些原因导致线程A执行的很慢很慢,过了30秒都没执行完,这时候锁过期自动释放,线程B得到了锁。

技术图片

 

 

随后,线程A执行完了任务,线程A接着执行del指令来释放锁。但这时候线程B还没执行完,线程A实际上删除的是线程B加的锁。 

技术图片

 

怎么避免这种情况呢?可以在del释放锁之前做一个判断,验证当前的锁是不是自己加的锁。

至于具体的实现,可以在加锁的时候把当前的线程ID当做value,并在删除之前验证key对应的value是不是自己线程的ID。

加锁:

String threadId = Thread.currentThread().getId()
set(key,threadId ,30,NX)

 

解锁:

if(threadId .equals(redisClient.get(key))){
    del(key)
}

 也可以在释放锁的时候,通过锁的默认value值UUID判断是不是该锁,若是该锁,则执行delete进行锁释放。但是,这样做又隐含了一个新的问题,判断和释放锁是两个独立操作,不是原子性的。具体如代码所示:

示例代码1

最常见的解锁代码就是直接使用jedis.del()方法删除锁,这种不先判断锁的拥有者而直接解锁的方式,会导致任何客户端都可以随时进行解锁,即使这把锁不是它的。

 

public static void wrongReleaseLock1(Jedis jedis, String lockKey) {
    jedis.del(lockKey);
}

 

 示例代码2

这种解锁代码乍一看也是没问题,甚至我之前也差点这样实现,与正确姿势差不多,唯一区别的是分成两条命令去执行,代码如下:

 

public static void wrongReleaseLock2(Jedis jedis, String lockKey, String requestId) {
 
    // 判断加锁与解锁是不是同一个客户端
    if (requestId.equals(jedis.get(lockKey))) {
        // 若在此时,这把锁突然不是这个客户端的,则会误解锁
        jedis.del(lockKey);
    }
 
}

 

 如代码注释,问题在于如果调用jedis.del()方法的时候,这把锁已经不属于当前客户端的时候会解除他人加的锁。那么是否真的有这种场景?答案是肯定的,比如客户端A加锁,一段时间之后客户端A解锁,在执行jedis.del()之前,锁突然过期了,此时客户端B尝试加锁成功,然后客户端A再执行del()方法,则将客户端B的锁给解除了。

 

从Redis 2.6.12版本开始很好的解决了上述的问题,下面是采用Redis2.6.12版本对以上问题的解决

 

3.基于Redis(Redis 2.6.12版本起)分布式锁的实现方式

(1)命令介绍

从Redis2.6.12版本开始,redis为SET命令增加了一系列选项:

  • EX second :设置键的过期时间为 second 秒。 SET key value EX second 效果等同于 SETEX key second value 。
  • PX millisecond :设置键的过期时间为 millisecond 毫秒。 SET key value PX millisecond 效果等同于 PSETEX key millisecond value
  • NX :只在键不存在时,才对键进行设置操作。 SET key value NX 效果等同于 SETNX key value 。
  • XX :只在键已经存在时,才对键进行设置操作。

注意: 由于SET命令加上选项已经可以完全取代SETNX, SETEX, PSETEX的功能,所以在将来的版本中,redis可能会不推荐使用并且最终抛弃这几个命令。使用SET代替SETNX,相当于SETNX+EXPIRE实现了原子性,不必担心SETNX成功,EXPIRE失败的问题!有效的避免死锁,解决了Redis2.6.12之前版本存在的问题。

(2)分布式锁的实现

1)解决非原子性和并发的出现

示例代码

public class RedisTool {
 
    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 tryGetDistributedLock(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;
 
    }
 
}

 

可以看到,我们加锁就一行代码:jedis.set(String key, String value, String nxxx, String expx, int time),这个set()方法一共有五个形参:

  • 第一个为key,我们使用key来当锁,因为key是唯一的。
  • 第二个为value,我们传的是requestId,很多童鞋可能不明白,有key作为锁不就够了吗,为什么还要用到value?原因就是我们在上面讲到可靠性时,分布式锁要满足第四个条件解铃还须系铃人,通过给value赋值为requestId,我们就知道这把锁是哪个请求加的了,在解锁的时候就可以有依据。requestId可以使用UUID.randomUUID().toString()方法生成。
  • 第三个为nxxx,这个参数我们填的是NX,意思是SET IF NOT EXIST,即当key不存在时,我们进行set操作;若key已经存在,则不做任何操作;
  • 第四个为expx,这个参数我们传的是PX,意思是我们要给这个key加一个过期的设置,具体时间由第五个参数决定。
  • 第五个为time,与第四个参数相呼应,代表key的过期时间。

总的来说,执行上面的set()方法就只会导致两种结果:1. 当前没有锁(key不存在),那么就进行加锁操作,并对锁设置个有效期,同时value表示加锁的客户端。2. 已有锁存在,不做任何操作。

心细的童鞋就会发现了,我们的加锁代码满足我们可靠性里描述的三个条件。首先,set()加入了NX参数,可以保证如果已有key存在,则函数不会调用成功,也就是只有一个客户端能持有锁,满足互斥性。其次,由于我们对锁设置了过期时间,即使锁的持有者后续发生崩溃而没有解锁,锁也会因为到了过期时间而自动解锁(即key被删除),不会发生死锁。最后,因为我们将value赋值为requestId,代表加锁的客户端请求标识,那么在客户端在解锁的时候就可以进行校验是否是同一个客户端。由于我们只考虑Redis单机部署的场景,所以容错性我们暂不考虑。

2)解决锁误删

示例代码

 

public class RedisTool {
 
    private static final Long RELEASE_SUCCESS = 1L;
 
    /**
     * 释放分布式锁
     * @param jedis Redis客户端
     * @param lockKey 锁
     * @param requestId 请求标识
     * @return 是否释放成功
     */
    public static boolean releaseDistributedLock(Jedis jedis, String lockKey, String requestId) {
 
        String script = "if redis.call(‘get‘, KEYS[1]) == ARGV[1] then return redis.call(‘del‘, KEYS[1]) else return 0 end";
        Object result = jedis.eval(script, Collections.singletonList(lockKey), Collections.singletonList(requestId));
 
        if (RELEASE_SUCCESS.equals(result)) {
            return true;
        }
        return false;
 
    }
 
}

 

 可以看到,我们解锁只需要两行代码就搞定了!第一行代码,我们写了一个简单的Lua脚本代码,第二行代码,我们将Lua代码传到jedis.eval()方法里,并使参数KEYS[1]赋值为lockKey,ARGV[1]赋值为requestId。eval()方法是将Lua代码交给Redis服务端执行。

那么这段Lua代码的功能是什么呢?其实很简单,首先获取锁对应的value值,检查是否与requestId相等,如果相等则删除锁(解锁)。那么为什么要使用Lua语言来实现呢?因为要确保上述操作是原子性的。那么为什么执行eval()方法可以确保原子性,源于Redis的特性,简单来说,就是在eval命令执行Lua代码的时候,Lua代码将被当成一个命令去执行,并且直到eval命令执行完成,Redis才会执行其他命令。

 

4.总结

本文主要介绍了Redis分布式锁的实现原理,以及如何使用java代码正确实现Redis分布式锁,对于加锁和解锁也分别针对Redis两个版本给出了示例。

5.参考资料

https://blog.csdn.net/qq_33666373/article/details/78870294

https://www.cnblogs.com/SophieLSR/p/9001789.html

https://blog.csdn.net/hxpjava1/article/details/81068355

http://www.importnew.com/27477.html

https://blog.csdn.net/qq_21033663/article/details/79967158

https://blog.csdn.net/andy86869/article/details/81668355

https://blog.csdn.net/kongmin_123/article/details/82080962

http://www.redis.cn/commands/set.html

以上是关于redis分布式锁的主要内容,如果未能解决你的问题,请参考以下文章

redis 分布式锁

如何使用redis实现分布式锁功能?

分布式锁用zookeeper还是redis好

Redis分布式锁的原理是啥?如何续期?

Redis(十三):Redis分布式锁的正确实现方式

Redis分布式锁