Redis之分布式锁

1 分布式锁（distributed lock）是Reids常见的使用场景

分布式锁的问题场景：

1. 例如一个简单的用户操作，一个线程去修改用户的状态，首先从数据库中读取出用户的状态，然后在内存中进行修改，修改后再把数据存储回去。
2. 在单线程这个操作是没有问题的，但是在多线程中，由于读取、修改、存储 这是三个操作，不是原子操作（一起成功、一起完成），所以在多线程中，这样就会出现问题（例如数据混乱，多个线程一起去操作该数据，改完以后发现数据不正确）。

对于这种问题，我们可以用分布式锁去限制程序的并发执行。（实现比较简单）

• 分布式的实现思路：就是进行一个线程以后先占位，当有别的线程在此时进行操作的时候，会发现有个占位了，就会放弃或者稍后再试（不会去抢占）。
• 在Redis中，占位一般使用setnx指令（该指令去存一个值，如果该值没有的话就存进行，有就放弃不存），先进来的线程先占位，线程的操作执行完成后，再调用del指令释放位子。

添加依赖

    <dependencies>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.2.0</version>
            <type>jar</type>
            <scope>compile</scope>
        </dependency>
    </dependencies>

1.1 代码示例

public class LockTest {
    public static void main(String[] args) {
        Redis redis = new Redis();
        redis.exectu(jedis -> {
            //返回的是long
            //System.out.println(jedis.ping());
            Long setnx = jedis.setnx("k11", "v1");
            if(setnx==1){//不存在为1
                //说明没有占位
                jedis.set("name", "ql");
                String name = jedis.get("name");
                System.out.println(name);
                //操作完，删除释放k1
                jedis.del("k11");
            }else{//存在为0
                //说明有人占位，停止或者暂缓操作
                System.out.println("k11已经存在");
            }
        });
    }
}

//清除已经存在的key
// jedis.flushAll();

上面的代码存在一个小问题，如果代码在业务的执行过程中，即if成功后的那一段抛异常或者挂了，就会导致del指令没有别调用。这样，会导致k1无法被释放，后来的请求全部堵塞在这里，锁也永远得不到释放。

• 要解决该问题可以给锁添加一个过期时间，确保锁在一定的时间之后，可以得到释放。

改进后代码如下：

public class LockTest {
    public static void main(String[] args) {
        Redis redis = new Redis();
        redis.exectu(jedis -> {
            //返回的是long
            //System.out.println(jedis.ping());
            //清除已经存在的key
           // jedis.flushAll();
            Long setnx = jedis.setnx("k11", "v1");
            if(setnx==1){//不存在为1
                //给锁添加过期时间,5秒，防止应用在运行过程中异常导致锁无法及时得到释放
                jedis.expire("k11",5);
                //说明没有占位
                jedis.set("name", "ql");
                String name = jedis.get("name");
                System.out.println(name);
                //操作完，删除释放k1
                jedis.del("k1");
            }else{//存在为0
                //说明有人占位，停止或者暂缓操作
                System.out.println("k11已经存在");
            }
        });
    }
}

这样改造后，会出现新的问题，就是在获取锁和设置过期时间之间，如果服务器突然挂掉，这个时候锁被占用，无法及时得到释放，也会造成死锁，因为获取锁和设置过期时间是俩个操作不是一个操作，不具备原子性。

为了解决这个问题，从Reids2.8开始，setnx和expire可以通过一个命令一起执行了。如下代码所示：

public class LockTest {
    public static void main(String[] args) {
        Redis redis = new Redis();
        redis.exectu(jedis -> {
            //setnx和过期时间的结合,确保一起执行
            String set = jedis.set("k1", "v1", new SetParams().nx().ex(5));
            //设置成功set为OK
            if(set!=null&&"OK".equals(set)){//不存在为1
                //给锁添加过期时间,5秒，防止应用在运行过程中异常导致锁无法及时得到释放
               // jedis.expire("k11",5);
                //说明没有占位
                jedis.set("name", "ql");
                String name = jedis.get("name");
                System.out.println(name);
                //操作完，删除释放k1
                jedis.del("k1");
            }else{//存在为0
                //说明有人占位，停止或者暂缓操作
                System.out.println("k11已经存在");
            }
        });
    }
}

1.2 解决超时问题

为了防止业务代码在执行的时候抛出异常，我们给每一个锁添加了一个超时时间，超时之后，锁会自动释放，但是也带来新的问题：如果要执行的业务非常耗时，可能会出现混乱。

• 例如：第一个线程首先获得锁，然后开始执行业务代码，但是业务代码比较耗时，执行了8秒，这样，会在第一个线程的任务还没执行成功的时候，锁就被释放了，此时，第二个会进来获取到锁开始执行，在第二个线程刚执行了3秒，第一个线程也执行完了，此时第一个线程会释放锁，但是要注意的是，它释放的是第二个线程的锁，释放之后，第三个线程进来了。

可以从两个角度入手：

1. 尽量避免在获取锁之后，执行耗时操作。
2. 可以在锁上面做文章，将锁的value设置为一个随机字符串，每次释放锁的时候，都去比较随机字符串是否一致，如果一致，再去释放，否则，不释放。

对于第二种方案，由于释放锁的时候，第一要去查看锁的value，第二比较value的值是否正确，第三步释放锁，有三个步骤，很明显这三个步骤不具备原子性。为了解决这个问题，我们可以引入Lua脚本。

Lua脚本的优势：

1. 使用方便，Redis中内置了对Lua脚本的职称；
2. Lua脚本可以在Redis服务端原子执行多个Redis命令；
3. 由于网络在很大程度上会影响到Redis性能，而使用Lua脚本可以让多个命令一次执行，可以有效解决网络给Redis代理的性能问题。

在Redis中，使用Lua脚本，大致两种思路：

1. 提前在Redis服务端写好Lua脚本，然后在java客户端调用脚本（推荐）
2. 可以直接在java端去写Lua脚本，写好之后，需要执行时，每次将脚本发送到Redis上去执行

创建lua脚本文件夹

mkdir lua
cd lua

vi releasewherevalueequls.lua

在Redis服务端，创建文件写脚本

if redis.call("get",KEYS[1])==ARGV[1] then
   return redis.call("del",KEYS[1])
else
   return 0
end

接下来，可以给Lua脚本求一个SHAI和，命令如下：

cat lua/releasewherevalueequls.lua |redis-cli -a password script load --pipe

验证，给脚本加缓存，会生成校验和代码

script load 这个命令会在Redis服务器中缓存Lua脚本，并返回脚本内容的SHAI校验和，然后在java端调用时，传入SHA校验和作为参数，这样Reids服务端就知道指向哪一个脚本了。

public class LuaTest {
    public static void main(String[] args) {
        Redis redis = new Redis();
        for(int i=0;i<2;i++){
            redis.exectu(jedis -> {
                //1.先获取一个随机字符串
                String value = UUID.randomUUID().toString();
                //2.获取锁
                String k1 = jedis.set("k1", value, new SetParams().nx().ex(5));
                if(k1!=null&&"OK".equals(k1)){
                    //4.具体的业务操作
                    jedis.set("site","www.ql.com");
                    String site = jedis.get("site");
                    System.out.println(site);
                    //5.调用脚本，释放锁
                    jedis.evalsha("b8059ba43af6ffe8bed3db65bac35d452f8115d8", Arrays.asList("k1"),Arrays.asList(value));
                }else{
                    System.out.println("没有拿到锁");
                }
            });
        }
    }
}

参考：视频