Redis进阶（5）——Redis数据一致性 & 用Java代码加锁解决一致性 & 采用lua脚本实现减1的原子性 & 分布式环境下的setnex锁及其问题 & Redission框架的使用

逃离我推掉我的手 2023-10-14 19:57 5阅读 0赞

#### 目录 ####

*  引出
 *  Redis中的数据一致性
 *   *  场景
     *  用Java代码加锁解决一致性
     *   *  大量请求拥挤抢购
         *  加锁(java)
         *  什么是可重入锁？
         *  如何保证可重入
         *  滥用锁的代价？
 *  数据一致性改进-Lua脚本
 *   *  采用单独lua脚本+配置类实现
     *   *  创建Lua脚本
         *  配置类
         *  调用lua脚本
     *  将lua代码放入java中
 *  分布式环境下
 *  Redisson框架
 *   *  引入依赖
     *  配置类
     *  加锁和锁释放
 *  总结

## 引出 ##

--------------------

1.redis中数据一致性的问题，大量抢购如何保证数据安全；  
2.用java代码加锁解决一致性问题，可重入锁，以及死锁的产生；  
3.采用lua脚本，让库存-1操作原子化；  
4.分布式环境下setnx锁，以及存在的问题；  
5.Redisson框架的使用，锁的续期，看门狗策略，1/3时续期；

## Redis中的数据一致性 ##

> CAP原则：
> 
> C：一致性
> 
> A: 可用性
> 
> P: 分区容错性（\*） AP CP
> 
> BASE——最终一致性

### 场景 ###

> redis存储库存，多个客户（线程）请求， 库存量100, 如何保证数据一致性。

### 用Java代码加锁解决一致性 ###

#### 大量请求拥挤抢购 ####

![在这里插入图片描述][8df26936fa1a4202a8743c87aa7ddbd5.png]

![在这里插入图片描述][456a1b5abedf4b258191568451aae8a2.png]

@PutMapping("/rushJmeter")
        public void rushJmeter(){
        
            String goodsNum = rushGoodsService.rush();
            System.out.println("goodsNum: "+goodsNum);
        }

![在这里插入图片描述][3779317412954838811260493dd07d30.png]

#### 加锁(java) ####

> 可重入锁： sychronized ReentrantLock

![在这里插入图片描述][c0166fdf66254d049179d82d07bde657.png]

> synchronized (this.getClass())\{\}

![在这里插入图片描述][536abf66fedc4f60b360428f4b3d0d0b.png]

> private final ReentrantLock lock = new ReentrantLock(); // 可重入锁

![在这里插入图片描述][ea04603d16f0448d93615ecea31035e9.png]

#### 什么是可重入锁？ ####

> 当线程获取某个锁后，还可以继续获取它，可以递归调用，而不会发生死锁；

![在这里插入图片描述][eba64fd97a5448d391bb5fb5f587a0b6.png]

![在这里插入图片描述][049824c0ef244ea48717ea4d104a26e7.png]

#### 如何保证可重入 ####

当一个线程访问同步块并获取锁时，会在对象头和栈帧中的锁记录里存储偏向的线程ID，以后该线程在进入和退出同步块时不需要进行CAS操作来加锁和解锁，只需简单测试一下对象头的Mark Word里是否存储着指向当前线程的**偏向锁**。

如果测试成功，表示线程已经获得了锁。  
如果测试失败，则需要再测试一下Mark Word中偏向锁标志是否设置成1：没有则CAS竞争；设置了，则CAS将对象头偏向锁指向当前线程。再维护一个计数器，同个线程进入则自增1，离开再减1，直到为0才能释放

#### 滥用锁的代价？ ####

死锁的四个必要条件?

循环

A —> B —>C —>A

![在这里插入图片描述][101ccd4c58804a1a8e5780d7e8495167.png]

> 可能导致死锁

![在这里插入图片描述][e9091e13bff94a0a8fd1f4f2dd0cf993.png]

> 锁对象ObjLock

package com.tianju.redis.lock;
    
    public class ObjLock {
        
        private String name;
    
        public ObjLock(String name){
        
            this.name = name;
        }
    
        @Override
        public String toString() {
        
            return "ObjLock："+this.name;
        }
    }

> 加锁释放锁方法DeadLockDemo

package com.tianju.redis.lock;
    
    public class DeadLockDemo {
        
    
        private ObjLock a;
        public ObjLock b;
    
        public DeadLockDemo(ObjLock a,ObjLock b){
        
            this.a = a;
            this.b = b;
        }
    
        public void dead(){
        
            System.out.println("********"+a+"对象"+b+"对象都加锁**************");
            System.out.println(a+"--"+b+": "+"准备给"+a+"对象加锁>>");
            synchronized (a){
        
                System.out.println(a+"--"+b+": "+a+"对象加锁成功...");
                System.out.println(a+"--"+b+": "+"准备给"+b+"对象加锁>>>");
                synchronized (b){
        
                    System.out.println(a+"--"+b+": "+b+"对象加锁成功");
                }
                System.out.println(a+"--"+b+": "+"释放"+b+"对象的锁");
            }
            System.out.println(a+"--"+b+": "+"释放"+b+"对象的锁");
            System.out.println("****************");
        }
    }

> 测试方法

package com.tianju.redis.lock;
    
    public class TestDeadLock {
        
    
        /**
         * 一个一个顺序运行
         */
        public static void run(){
        
            ObjLock a = new ObjLock("A");
            ObjLock b = new ObjLock("B");
            ObjLock c = new ObjLock("C");
    
            DeadLockDemo lockDemo1 = new DeadLockDemo(a, b);
            lockDemo1.dead(); // 锁住a和b
    
            DeadLockDemo lockDemo2 = new DeadLockDemo(b, c);
            lockDemo2.dead(); // 锁住a和b
    
            DeadLockDemo lockDemo3 = new DeadLockDemo(c, a);
            lockDemo3.dead(); // 锁住a和b
        }
    
        /**
         * 进行线程抢，死锁
         */
        public static void rushRun(){
        
            ObjLock a = new ObjLock("A");
            ObjLock b = new ObjLock("B");
            ObjLock c = new ObjLock("C");
    
            new Thread(()->{
        
                DeadLockDemo lockDemo1 = new DeadLockDemo(a, b);
                lockDemo1.dead(); // 锁住a和b
                try {
        
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
        
                    throw new RuntimeException(e);
                }
            }).start();
    
            new Thread(()->{
        
                DeadLockDemo lockDemo2 = new DeadLockDemo(b, c);
                lockDemo2.dead(); // 锁住a和b
                try {
        
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
        
                    throw new RuntimeException(e);
                }
            }).start();
    
            new Thread(()->{
        
                DeadLockDemo lockDemo3 = new DeadLockDemo(c, a);
                lockDemo3.dead(); // 锁住a和b
                try {
        
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
        
                    throw new RuntimeException(e);
                }
            }).start();
        }
    
    
        public static void main(String[] args) {
        
    //        run(); // 顺序执行加锁，解锁
            rushRun(); // 线程进行抢
        }
    }

## 数据一致性改进-Lua脚本 ##

*  锁： 多个线程抢—->每个线程按顺序完成
 *  Lua： 原子性

![在这里插入图片描述][80622d03632e4a8bb1efaca9a6861490.png]

### 采用单独lua脚本+配置类实现 ###

![在这里插入图片描述][3b6182ad016f474ab322cf0d6b7ee5b5.png]

#### 创建Lua脚本 ####

> 让减库存这个操作整体是原子性的

local key = KEYS[1]
    
    --- 判断key是否存在
    local isIn = tonumber(redis.call('exists',key))
    
    if isIn==1 then
        local nums = tonumber(redis.call('get',key))
        if nums>0 then
            --- 减库存
            redis.call('decr',key)
            return redis.call('get',key)
        else
            return 'goods is sold out'
        end
    else
        return 'goods not exists'
    end

#### 配置类 ####

package com.tianju.redis.config;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.core.io.ClassPathResource;
    import org.springframework.data.redis.core.script.DefaultRedisScript;
    import org.springframework.data.redis.core.script.RedisScript;
    
    /**
     * lua脚本的Redis配置类
     */
    @Configuration
    public class RedisConfig {
        
        @Bean
        public RedisScript<String> redisScript(){
        
            DefaultRedisScript<String> redisScript = new DefaultRedisScript<>();
            redisScript.setResultType(String.class); // 返回值类型
            redisScript.setLocation(new ClassPathResource("lua/goods.lua")); // 设置lua脚本的路径
            return redisScript;
        }
    }

#### 调用lua脚本 ####

![在这里插入图片描述][0ee4612f2b9b4ed1849dd6c0a4dea725.png]

### 将lua代码放入java中 ###

package com.tianju.redis.service.impl;
    
    import com.tianju.redis.service.IRushGoodsService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.StringRedisTemplate;
    import org.springframework.data.redis.core.script.DefaultRedisScript;
    import org.springframework.data.redis.core.script.RedisScript;
    import org.springframework.stereotype.Service;
    
    import java.util.Collections;
    import java.util.concurrent.locks.ReentrantLock;
    
    @Service
    public class RushGoodsServiceImpl implements IRushGoodsService {
        
    
        @Autowired
        private StringRedisTemplate stringRedisTemplate;
    
        private final String GOODS = "goods";
    
        private final ReentrantLock lock = new ReentrantLock(); // 可重入锁
        @Override
        public String rush() {
        
            lock.lock();
            try{
        
                String sNum = stringRedisTemplate.opsForValue().get(GOODS);
                int nums = Integer.parseInt(sNum);
                if (nums>0){
        
                    try {
        
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                    stringRedisTemplate.opsForValue().decrement(GOODS); // 采用redis的原子减1
                    return stringRedisTemplate.opsForValue().get(GOODS);
                }else {
        
                    return "error";
                }
            }finally {
        
                lock.unlock();
            }
        }
    
        @Autowired
        private RedisScript<String> redisScript;
    
        @Override
        public String rushLua(){
        
            return stringRedisTemplate.execute(
                    redisScript,
                    Collections.singletonList(GOODS)); // 创建只有一个元素的list
        }
    
        @Override
        public String rushLuaJava() {
        
            String lua = "local key = KEYS[1]\n" +
                    "\n" +
                    "--- 判断key是否存在\n" +
                    "local isIn = tonumber(redis.call('exists',key))\n" +
                    "\n" +
                    "if isIn==1 then\n" +
                    "    local nums = tonumber(redis.call('get',key))\n" +
                    "    if nums>0 then\n" +
                    "        --- 减库存\n" +
                    "        redis.call('decr',key)\n" +
                    "        return redis.call('get',key)\n" +
                    "    else\n" +
                    "        return 'goods is sold out'\n" +
                    "    end\n" +
                    "else\n" +
                    "    return 'goods not exists'\n" +
                    "end";
           return stringRedisTemplate.opsForValue().getOperations()
                    .execute(
                            new DefaultRedisScript<>(lua, String.class),
                            Collections.singletonList(GOODS)
                    );
        }
    
    }

## 分布式环境下 ##

![在这里插入图片描述][56621bda4f334990a7200e0bed9f04fb.png]

setnx:特点

如果key不存在，返回为1

如果key存在， 返回为0

![在这里插入图片描述][250f0796946c4e0c8c7147aee2ed4e59.png]

package com.tianju.redis.service.impl;
    
    import com.tianju.redis.service.IRushGoodsService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.StringRedisTemplate;
    import org.springframework.data.redis.core.script.DefaultRedisScript;
    import org.springframework.data.redis.core.script.RedisScript;
    import org.springframework.stereotype.Service;
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.List;
    import java.util.concurrent.locks.ReentrantLock;
    
    @Service
    public class RushGoodsServiceImpl implements IRushGoodsService {
        
    
        @Autowired
        private StringRedisTemplate stringRedisTemplate;
    
        private final String GOODS = "goods";
    
        private final String LOCK = "myLock";
    
        private final String DEFAULT = "1";
    
    
    
        private final ReentrantLock lock = new ReentrantLock(); // 可重入锁
        @Override
        public String rush() {
        
            lock.lock();
            try{
        
                String sNum = stringRedisTemplate.opsForValue().get(GOODS);
                int nums = Integer.parseInt(sNum);
                if (nums>0){
        
                    try {
        
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                    stringRedisTemplate.opsForValue().decrement(GOODS); // 采用redis的原子减1
                    return stringRedisTemplate.opsForValue().get(GOODS);
                }else {
        
                    return "error";
                }
            }finally {
        
                lock.unlock();
            }
        }
    
        @Autowired
        private RedisScript<String> redisScript;
    
        @Override
        public String rushLua(){
        
            return stringRedisTemplate.execute(
                    redisScript,
                    Collections.singletonList(GOODS)); // 创建只有一个元素的list
        }
    
        @Override
        public String rushLuaJava() {
        
            String lua = "local key = KEYS[1]\n" +
                    "\n" +
                    "--- 判断key是否存在\n" +
                    "local isIn = tonumber(redis.call('exists',key))\n" +
                    "\n" +
                    "if isIn==1 then\n" +
                    "    local nums = tonumber(redis.call('get',key))\n" +
                    "    if nums>0 then\n" +
                    "        --- 减库存\n" +
                    "        redis.call('decr',key)\n" +
                    "        return redis.call('get',key)\n" +
                    "    else\n" +
                    "        return 'goods is sold out'\n" +
                    "    end\n" +
                    "else\n" +
                    "    return 'goods not exists'\n" +
                    "end";
           return stringRedisTemplate.opsForValue().getOperations()
                    .execute(
                            new DefaultRedisScript<>(lua, String.class),
                            Collections.singletonList(GOODS)
                    );
        }
    
        @Override
        public String rushSetNx() {
        
            List<String> keys = new ArrayList<>();
            keys.add(GOODS);
            keys.add(LOCK);
    
            Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(LOCK, DEFAULT);
            
    
            System.out.println(flag);
            if (flag){
         // 拿到锁
                return stringRedisTemplate.execute(
                        redisScript,
                        keys); // 创建只有一个元素的list
            }else {
        
                return "锁在使用中，请稍后";
            }
        }
    }

local key = KEYS[1]
    local myLock = KEYS[2]
    --- 判断key是否存在
    local isIn = tonumber(redis.call('exists',key))
    
    if isIn==1 then
        local nums = tonumber(redis.call('get',key))
        if nums>0 then
            --- 减库存
            redis.call('decr',key)
            --- 删掉用于加锁的key，setnx
            redis.call('del',myLock)
            return redis.call('get',key)
        else
            return 'goods is sold out'
        end
    else
        return 'goods not exists'
    end

> 问题1： setnx 没有设置过期时间
> 
> 问题2：执行的业务周期超过锁的有效时间
> 
> 问题3: 业务没有执行完之前，锁要进行续期。
> 
> 问题4： 可重入

## Redisson框架 ##

> 在分布环境下，redis的数据一致性解决方案.

[https://redisson.org/][https_redisson.org]

![在这里插入图片描述][150304be00254605984a96822551ad4f.png]

### 引入依赖 ###

<dependency>
                <groupId>org.redisson</groupId>
                <artifactId>redisson</artifactId>
                <version>3.22.0</version>
            </dependency>

### 配置类 ###

package com.tianju.redis.config;
    
    import org.redisson.Redisson;
    import org.redisson.api.RedissonClient;
    import org.redisson.config.Config;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    @Configuration
    public class RedissonConfig {
        
    
        @Bean
        public RedissonClient redissonClient(){
        
            Config config = new Config();
            config.useSingleServer().setAddress("redis://192.168.111.130:6399");
            return Redisson.create(config);
        }
    }

> 创建redis连接池

![在这里插入图片描述][d7863644a06d460ba5d56e5e82f7601e.png]

### 加锁和锁释放 ###

![在这里插入图片描述][3651ee4f2d244585804f5d70893876d8.png]

package com.tianju.redis.service.impl;
    
    import com.tianju.redis.service.IGoodsService;
    import org.redisson.api.RLock;
    import org.redisson.api.RedissonClient;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.StringRedisTemplate;
    import org.springframework.stereotype.Service;
    
    @Service
    public class GoodsServiceImpl implements IGoodsService {
        
    
        @Autowired
        private StringRedisTemplate stringRedisTemplate;
    
        private final String GOODS = "goods";
    
        private final String LOCK = "myLock";
    
        @Autowired
        private RedissonClient redissonClient;
    
        @Override
        public String rushRedisson() {
        
            RLock lock = redissonClient.getLock(LOCK);
            lock.lock();// 默认的时间是30s
            try {
        
                String s = stringRedisTemplate.opsForValue().get(GOODS);
                int nums = Integer.parseInt(s);
                if (nums>0){
        
                    // 库存-1操作
                    stringRedisTemplate.opsForValue().decrement(GOODS);
                    return stringRedisTemplate.opsForValue().get(GOODS);
                }else {
        
                    return "销售完了";
                }
            } finally {
        
                // 释放锁
                lock.unlock();
            }
        }
    }

--------------------

## 总结 ##

[8df26936fa1a4202a8743c87aa7ddbd5.png]: https://img-blog.csdnimg.cn/8df26936fa1a4202a8743c87aa7ddbd5.png
[456a1b5abedf4b258191568451aae8a2.png]: https://img-blog.csdnimg.cn/456a1b5abedf4b258191568451aae8a2.png
[3779317412954838811260493dd07d30.png]: https://img-blog.csdnimg.cn/3779317412954838811260493dd07d30.png
[c0166fdf66254d049179d82d07bde657.png]: https://img-blog.csdnimg.cn/c0166fdf66254d049179d82d07bde657.png
[536abf66fedc4f60b360428f4b3d0d0b.png]: https://img-blog.csdnimg.cn/536abf66fedc4f60b360428f4b3d0d0b.png
[ea04603d16f0448d93615ecea31035e9.png]: https://img-blog.csdnimg.cn/ea04603d16f0448d93615ecea31035e9.png
[eba64fd97a5448d391bb5fb5f587a0b6.png]: https://img-blog.csdnimg.cn/eba64fd97a5448d391bb5fb5f587a0b6.png
[049824c0ef244ea48717ea4d104a26e7.png]: https://img-blog.csdnimg.cn/049824c0ef244ea48717ea4d104a26e7.png
[101ccd4c58804a1a8e5780d7e8495167.png]: https://img-blog.csdnimg.cn/101ccd4c58804a1a8e5780d7e8495167.png
[e9091e13bff94a0a8fd1f4f2dd0cf993.png]: https://img-blog.csdnimg.cn/e9091e13bff94a0a8fd1f4f2dd0cf993.png
[80622d03632e4a8bb1efaca9a6861490.png]: https://img-blog.csdnimg.cn/80622d03632e4a8bb1efaca9a6861490.png
[3b6182ad016f474ab322cf0d6b7ee5b5.png]: https://img-blog.csdnimg.cn/3b6182ad016f474ab322cf0d6b7ee5b5.png
[0ee4612f2b9b4ed1849dd6c0a4dea725.png]: https://img-blog.csdnimg.cn/0ee4612f2b9b4ed1849dd6c0a4dea725.png
[56621bda4f334990a7200e0bed9f04fb.png]: https://img-blog.csdnimg.cn/56621bda4f334990a7200e0bed9f04fb.png
[250f0796946c4e0c8c7147aee2ed4e59.png]: https://img-blog.csdnimg.cn/250f0796946c4e0c8c7147aee2ed4e59.png
[https_redisson.org]: https://redisson.org/
[150304be00254605984a96822551ad4f.png]: https://img-blog.csdnimg.cn/150304be00254605984a96822551ad4f.png
[d7863644a06d460ba5d56e5e82f7601e.png]: https://img-blog.csdnimg.cn/d7863644a06d460ba5d56e5e82f7601e.png
[3651ee4f2d244585804f5d70893876d8.png]: https://img-blog.csdnimg.cn/3651ee4f2d244585804f5d70893876d8.png