使用Redis实现锁（支持分布式应用）(整理网络资料)

使用Redis实现锁（支持分布式应用）

1.    简介

使用Redis指令setnx、expire、getset等操做实现互斥资源的访问

        

本文内容来着网络整理，参考：

http://www.linuxidc.com/Linux/2014-12/110958.htm

http://www.jeffkit.info/2011/07/1000/

http://blog.csdn.net/java2000_wl/article/details/8740911

2.    背景

　　在特殊业务逻辑中，须要保证莫一个操做同时只有一个线程在操做，保证数据一致性。防止数据被屡次改写或产生多条重复数据。

3.    思路

经过get 和set 命令实现

　　这种方式很容易想到，就是当每次请求到来时经过get判断这个锁是否存在，若是不存在则set建立。这种方法有一个弊端，因为get和set是两次Redis请求，两者之间有延时，在高并发的环境下，有可能在get检测到锁不存以后在set以前已经被其余线程set，这时当前线程再set，这样锁就失效了。因此这种方法只能应对并发量不是很高的状况

经过setnx 和 expire命令实现

　　在访问须要互斥访问的资源时，经过setnx命令去设置一个lock 键，setnx的做用是判断锁是否存在，若是不存在则建立，返回成功，若是存在则返回失败，服务器返回给客户端，指示客户端稍后重试。expire命令用于给该锁设定一个过时时间，用于防止线程crash，致使锁一直有效，从而致使死锁。例如：设定锁的有效期为100秒，那么即便线程奔溃，在100秒后锁会自动失效。（实际上，这个地方也有问题，高并发下在执行expire命令时偶尔会失败（Redis socket连接问题），失败后这个lock就不会自动过时，值会会一直存在，出现死锁致使后续的重试操做就永远不会成功！ 为保证执行成功须要考虑失败时屡次执行expire）

 

setnx lock "lock"

expire lock 100 //若是锁定成功，则设置过时时间

do work code //工做逻辑代码

del lock //访问互斥资源结束后,删除锁

 

经过setnx和 getset命令加 timespan+timeout (推荐)

如何解决setnx + expire 的死锁问题？能够经过锁的键对应的时间戳来判断这种状况是否发生了，若是当前的时间已经大于lock的值，说明该锁已失效，能够被从新使用。

 

发生这种状况时，可不能简单的经过DEL来删除锁，而后再SETNX一次，当多个客户端检测到锁超时后都会尝试去释放它，这里就可能出现一个竞态条件,让咱们模拟一下这个场景：

 

     C0操做超时了，但它还持有着锁，C1和C2读取lock检查时间戳，前后发现超时了。

     C1 发送DEL lock

     C1 发送SETNX lock而且成功了。

     C2 发送DEL lock

     C2 发送SETNX lock而且成功了。

 

这样一来，C1，C2都拿到了锁！问题大了！

 

幸亏这种问题是能够避免的，让咱们来看看C3这个客户端是怎样作的：

 

    C3发送SETNX lock想要得到锁，因为C0还持有锁，因此Redis返回给C3一个0

    C3发送GET lock以检查锁是否超时了，若是没超时，则等待或重试。

    反之，若是已超时，C3经过下面的操做来尝试得到锁：

    GETSET lock <current Unix time + lock timeout + 1>

    经过GETSET，C3拿到的时间戳若是仍然是超时的，那就说明，C3如愿以偿拿到锁了。

    若是在C3以前，有个叫C4的客户端比C3快一步执行了上面的操做，那么C3拿到的时间戳是个未超时的值，这时，C3没有如期得到锁，须要再次等待或重试。留意一下，尽管C3没拿到锁，但它改写了C4设置的锁的超时值，不过这一点很是微小的偏差带来的影响能够忽略不计。

 

注意：为了让分布式锁的算法更稳键些，持有锁的客户端在解锁以前应该再检查一次本身的锁是否已经超时，再去作DEL操做，由于可能客户端由于某个耗时的操做而挂起，操做完的时候锁由于超时已经被别人得到，这时就没必要解锁了

附伪代码：

# get lock

    lock = 0

    while lock != 1:

        timestamp = current Unix time + lock timeout + 1

        lock = SETNX lock.foo timestamp

        if lock == 1 or (now() > (GET lock.foo) and now() > (GETSET lock.foo timestamp)):

            break;

        else:

            sleep(10ms)

    

    # do your job

    do_job()

    

    # release

    if now() < GET lock.foo:

        DEL lock.foo

4.    代码

经过setnx 和 expire命令实现代码

 1 public boolean tryLock(String key, int timeout, int expiretime, int sleeptime) throws Exception {
 2 
 3  
 4 
 5         Jedis redis = jedisPool.getResource();
 6 
 7         try {
 8 
 9             long nano = System.nanoTime();
10 
11             do {
12 
13                 Long i = redis.setnx(key, "key");
14 
15                 jedisPool.returnResource(redis);
16 
17                 if (i == 1) {
18 
19                     redis.expire(key, expiretime);
20 
21                     return Boolean.TRUE;
22 
23                 }
24 
25                 if (timeout == 0) {
26 
27                     break;
28 
29                 }
30 
31                 Thread.sleep(sleeptime);
32 
33             } while ((System.nanoTime() - nano) < TimeUnit.SECONDS.toNanos(timeout));
34 
35             return Boolean.FALSE;
36 
37         } catch (RuntimeException | InterruptedException e) {
38 
39             if (redis != null) {
40 
41                 jedisPool.returnBrokenResource(redis);
42 
43             }
44 
45             throw e;
46 
47         }
48 
49     }
50 
51  

 

经过setnx和 getset命令加 timespan+timeout (推荐代码)

 

 1 public boolean tryLock(String key, int timeout, int expiretime, int sleeptime) throws Exception {
 2 
 3  
 4 
 5         Jedis redis = jedisPool.getResource();
 6 
 7         try {
 8 
 9             long nano = System.nanoTime();
10 
11  
12 
13             do {
14 
15                 long timestamp = System.currentTimeMillis() + TimeUnit.SECONDS.toMillis(expiretime) + 1;
16 
17                 Long i = redis.setnx(key, String.valueOf(timestamp));
18 
19                 jedisPool.returnResource(redis);
20 
21                 if (i == 1) {
22 
23                     return Boolean.TRUE;
24 
25                 }
26 
27                 String lockVal = getString(key);
28 
29                 if (StringUtils.isBlank(lockVal) || !StringUtils.isNumeric(lockVal)) {
30 
31                     lockVal = "0";
32 
33                 }
34 
35                 if (System.currentTimeMillis() > Long.valueOf(lockVal)) {
36 
37                     lockVal = getAndset(key, String.valueOf(timestamp));
38 
39                     if (StringUtils.isBlank(lockVal) || !StringUtils.isNumeric(lockVal)) {
40 
41                         lockVal = "0";
42 
43                     }
44 
45                     if (System.currentTimeMillis() > Long.valueOf(lockVal)) {
46 
47                         return Boolean.TRUE;
48 
49                     }
50 
51                 }
52 
53                 if (timeout == 0) {
54 
55                     break;
56 
57                 }
58 
59                 Thread.sleep(sleeptime);
60 
61             } while ((System.nanoTime() - nano) < TimeUnit.SECONDS.toNanos(timeout));
62 
63             return Boolean.FALSE;
64 
65         } catch (RuntimeException | InterruptedException e) {
66 
67             if (redis != null) {
68 
69                 jedisPool.returnBrokenResource(redis);
70 
71             }
72 
73             throw e;
74 
75         }
76 
77     }