Redis分布式锁专题

最新推荐文章于 2024-08-31 10:44:02 发布
最新推荐文章于 2024-08-31 10:44:02 发布
阅读量73 收藏
点赞数
文章标签： java redis Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lx112459/article/details/129183827
版权

1. 问题

有一个 User 类，name字段需要唯一

public class User {
    public int id;
    public String name;//需要整保证唯一
    public int age;

   //get set 省略
}

最初的做法：利用数据库唯一约束（这种方法不详细介绍）

但如果 User 类中再加个字段 dr，表示数据是否删除，如下：

public class User {
    public int id;
    public String name;//需要整保证唯一
    public int age;
    public int dr;// 1：表示一删除，0：表示未删除

   //get set 省略
}

这时候数据库唯一索引就不能用了，想让 name 保持唯一，就只能在代码中加锁，比如：

public void addUser(User user){
    //1. 根据用户名查询User对象
    User oldUser = getUserByName(user.getName());
    if(oldUser == null){
        //2. 对用户名进行加锁
        synchronized (user.getName().intern()){
            //3. 再次根据用户名查询User对象
            oldUser = getUserByName(user.getName());
            if(oldUser == null){
                //4. 保存用户
                String sql = "insert into user(id,name,age) values(?,?,?)";
                jdbcTemplate.update(sql, user.getId(), user.getName(), user.getAge());
            }else{
                throw new IllegalArgumentException("用户名已经存在");
            }
        }
    }else{
        throw new IllegalArgumentException("用户名已经存在");
    }
}

上面的代码用 synchronized 对 用户名 加锁，这样能保证多线程调用 addUser 方法的时，用户名不重复

但是这只能对单机部署有效，如果你的服务是集群部署，如下图：

上图中

  • 用户1 和 用户2，同时发起注册用户的请求，申请的用户名一样

  • 后端是集群，服务1 处理 用户1 的请求，服务2 处理 用户2 的请求，这样就算我们在代码用使用了**synchronized **，用户名还是会重复存储

2. 方案

使用 synchronized 并不能解决，集群下的数据安全问题，这时候就应该考虑分布式锁，比如：

上图中，服务1和服务2不再使用 synchronized 而是去Redis中set key，这样只有一个服务能够设置成功

原因：

  • Redis 中的 setnx 命令：当指定 key 不存在的时候，才能执行成功

  • Redis 服务端对应客户端发送的命令是同步执行的

  • 也就是说：如果同时有两个人执行 setnx test haha，只有一个会成功

这样就能保证集群下的数据安全问题，具体流程：

上图，如果用户名不存在，就加分布式锁，加锁成功后才能保存到数据库

public void addUser(User user){
    //1. 根据用户名查询User对象
    User oldUser = getUserByName(user.getName());

    if(oldUser == null){
        //2. 如果用户名不存在，加分布式锁
        Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent(user.getName() + "_userName_lock", "lock", 60, TimeUnit.SECONDS);
        if(lock){
            Thread.sleep(10 * 1000);//加锁成功后休眠10秒
            String sql = "insert into user(id,name,age) values(?,?,?)";
            jdbcTemplate.update(sql, user.getId(), user.getName(), user.getAge());
            //3. 释放锁，解锁的代码要写到finally中
            stringRedisTemplate.delete(user.getName() + "_userName_lock");
        }else{
            //4. 加锁失败
            throw new IllegalArgumentException("服务器繁忙，请稍后再试！");
        }
    }else{
        throw new IllegalArgumentException("用户名已经存在！");
    }
}

private User getUserByName(String name) {
    List<User> list = jdbcTemplate.query("select * from user where name= ?",
            new Object[]{name}, new BeanPropertyRowMapper<>(User.class));
    if(CollectionUtils.isEmpty(list)){
        return null;
    }
    return list.get(0);
}

Controller

@GetMapping("/save")
public String save(@RequestParam int id, @RequestParam String name, @RequestParam int age){
    try{
        User user = new User();
        user.setId(id);
        user.setName(name);
        user.setAge(age);
        userService.addUser(user);
    }catch (Exception e){
        return e.getMessage();
    }
    return "success";
}

结果：

第一个页签，加锁成功

第二个页签，加锁失败

3. 完善

但是，上面代码在特殊情况下还会出现问题，比如：

如果代码按照上图中的顺序执行，还是会产生数据重复的问题

  • 服务 1，加锁成功后，保存数据库，但是线程阻塞(或者是处理业务的时间比较长)，数据还未存到数据库，锁就过期了

  • 这时服务 2，接到了一个请求，加锁成功，保存数据库

  • 然后服务 1，继续运行，导致数据重复

解决：为分布式锁延期，加锁成功后，新建一个守护线程，监控锁的过期时间，在快要过期的时候，给锁延期

代码：

public void addUser(User user){
    //1. 根据用户名查询User对象
    User oldUser = getUserByName(user.getName());

    if(oldUser == null){
        //2. 如果用户名不存在，加分布式锁
        Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent(user.getName() + "_userName_lock", "lock", 20, TimeUnit.SECONDS);
        if(lock){
            //3. 新开一个守护线程，为分布式锁延期
            Thread t = new Thread(() -> {
                try{
                    while (true){
                        //每5秒查看一下锁的过期时间，如果小于10秒，延期
                        Thread.sleep(5 * 1000);
                        Long expire = stringRedisTemplate.getExpire(user.getName() + "_userName_lock");
                        if(expire == -2){//表示key不存在
                            break;
                        }
                        if(expire < 10){
                            //重新设置失效时间
                            stringRedisTemplate.expire(user.getName() + "_userName_lock", 20, TimeUnit.SECONDS);
                        }
                    }
                }catch (Exception e){}
            });
            t.setDaemon(true);//当主线程结束后，守护线程自动结束
            t.start();
            String sql = "insert into user(id,name,age) values(?,?,?)";
            jdbcTemplate.update(sql, user.getId(), user.getName(), user.getAge());
            //3. 释放锁，解锁的代码要写到finally中
            stringRedisTemplate.delete(user.getName() + "_userName_lock");
        }else{
            //4. 加锁失败
            throw new IllegalArgumentException("服务器繁忙，请稍后再试！");
        }
    }else{
        throw new IllegalArgumentException("用户名已经存在！");
    }

问题1：为什么使用守护线程？

不一定非得使用守护线程，只要你能保证给锁延期的线程可以正常结束就行

问题2：为什么要设置过期时间？

为了避免出现特殊情况后，锁一直留在redis中，比如：断电、删除锁失败

4. 插入一个网上的说法

其实上面的代码在极端情况下也是可能出现问题的，比如：

  • 假如有 2 个线程A、B，一前一后执行上述的代码

  • A 线程正常执行，但是执行业务时间比较长，而且守护线程阻塞或者延期失败，导致锁自动过期

  • 这时候 B 线程过来加锁，然后 A 线程继续执行，最后释放锁

  • 但其实 A 线程加的锁已经自动过期了，它释放的是B线程加的锁

针对这种情况，网上有种说法：

  • 在执行 setIfAbsent 方法时，给key设置一个唯一值（那么 2 个线程设置的值是不同的）

  • 在释放锁时，先判断value对不对（就是判断这个锁是不是自己加的）

但是本人一直对这种说法持质疑态度，我们加锁的目的：避免多个线程同时执行这段代码

但上面的说法明显是支持多线程同时执行，违背了我们加锁的初衷，而且也没有意义

5. Redisson（了解）

上面的代码经过完善后，可以看出已经很复杂了，为了解决这个问题，我们引入 Redisson

Redisson 也是 Redis 的一个客户端，宗旨是促进使用者对Redis的关注分离，从而让使用者能够将精力更集中地放在处理业务逻辑上，不过目前只是演示加锁功能。

它提供了一个监控锁的看门狗，它的作用是在Redisson实例被关闭前，不断的延长锁的有效期。

如果一个锁的有效期是30秒，那么看门狗会在过期时间剩余20秒的时候，重新延期至30秒。

锁的有效期通过修改 Config.lockWatchdogTimeout 指定。

官方地址：https://github.com/redisson/redisson/wiki

1. Maven 依赖

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

2. 代码

配置类

@Bean
public RedissonClient redissonClient(){
    // 配置类
    Config config = new Config();
    // 添加redis地址
    config.useSingleServer().setAddress("redis://192.168.56.103:6379");
    // 设置锁的超时时间，单位：毫秒
    // 我们设置的是20秒，watchdog会在过期时间剩余14秒的时候，延期
    config.setLockWatchdogTimeout(20000);
    // 创建 RedissonClient 对象
    return Redisson.create(config);
}

Service

@Autowired
private RedissonClient redissonClient;

public void addUser(User user) throws InterruptedException {
    //1. 根据用户名查询User对象
    User oldUser = getUserByName(user.getName());
    if(oldUser == null){
        //2. 如果用户名不存在，加分布式锁
        RLock lock = redissonClient.getLock(user.getName() + "_userName_lock");
        // 尝试获取锁，3个参数分别是：获取锁的最大等待时间(期间会重试)，锁的过期时间，时间单位
//      boolean locked = lock.tryLock(1,20, TimeUnit.SECONDS);
        boolean locked = lock.tryLock();
        if(locked){
            Thread.sleep(20000);//模拟业务阻塞
            String sql = "insert into user(id,name,age) values(?,?,?)";
            jdbcTemplate.update(sql, user.getId(), user.getName(), user.getAge());
            //3. 释放锁，一般放在 finally 中
            lock.unlock();
        }else{
            //4. 加锁失败
            throw new IllegalArgumentException("服务器繁忙，请稍后再试！");
        }

    }else{
        throw new IllegalArgumentException("用户名已经存在");
    }
}

结果：

注意，想要：watchdog 生效，那么在加锁的时候不能给锁指定过期时间，

可以用

  • tryLock()

  • 直接申请锁，不需要任何参数

  • tryLock(long waitTime, TimeUnit unit)

  • 参数分别是：获取锁的最大等待时间(期间会重试)，时间单位

3. RedissonMultiLock

截止目前我们的 redis 只有一个节点，但实际上 redis 往往是集群或主从模式

上图，主节点提供写，从节点提供读，主从之间会有数据同步，但是数据同步会有延迟，这就可能出现问题

  • 首先向 主节点 中写数据（加锁），成功后，从节点同步

  • 就在同步时，主节点宕机，数据同步未成功，

  • 这时 Redis 有哨兵机制，会选择一个从节点作为新的主节点，但是它没有锁的数据

。。。。。。

Redisson 的 RedissonMultiLock，可以解决这个问题

同时往多个 主节点 加锁，这在Redisson中成为：联锁，这样只要不是所有主节点一起宕机，就没问题

代码，再加两个 RedisClient 配置

@Bean
public RedissonClient redissonClient2(){
    // 配置类
    Config config = new Config();
    // 添加redis地址
    config.useSingleServer().setAddress("redis://192.168.56.102:6379");
    // 设置看门狗检查时间，单位：毫秒
    config.setLockWatchdogTimeout(20000);
    // 创建 RedissonClient 对象
    return Redisson.create(config);
}

@Bean
public RedissonClient redissonClient3(){
    // 配置类
    Config config = new Config();
    // 添加redis地址
    config.useSingleServer().setAddress("redis://192.168.56.101:6379");
    // 设置看门狗检查时间，单位：毫秒
    config.setLockWatchdogTimeout(20000);
    // 创建 RedissonClient 对象
    return Redisson.create(config);
}
@Autowired
private RedissonClient redissonClient;
@Autowired
private RedissonClient redissonClient2;
@Autowired
private RedissonClient redissonClient3;


public void test() throws InterruptedException {
    RLock lock1 = redissonClient.getLock("business_lock_key");
    RLock lock2 = redissonClient2.getLock("business_lock_key");
    RLock lock3 = redissonClient3.getLock("business_lock_key");

    //创建联锁
    RedissonMultiLock multiLock = new RedissonMultiLock(lock1, lock2, lock3);
    boolean locked = multiLock.tryLock();
    //TODO 业务处理

    //释放锁
    multiLock.unlock();
}

6. 补充

上面的逻辑已经很完善了，但是，在极端的情况下，还是可能出现问题，比如

  • 守护线程阻塞

  • watchDog 阻塞

  • 多个redis主节点同时宕机

针对这种情况：凉拌

其实这就是告诉你们

  • 线程可能随时随地的阻塞在任何位置

  • 代码永远都是不完美的，我们所做的一起都是为了尽量避免出现问题，而不能保证毫无问题

lx112459
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
高并发场景下，如何保证缓存与数据库一致性？
qq1353424111的博客
09-18 4万+
面试题：高并发场景下，如何保证缓存与数据库一致性？ 问题分析 我们日常开发中，对于缓存用的最多的场景就像下图一样，可能仅仅是对数据进行缓存，减轻数据库压力，缩短接口响应时间。 这种方案在不需要考虑高并发得去写缓存，高并发得读写缓存时，是不会有问题，但是如果是在高并发场景下，要保证缓存和数据库的一致性，至少需要解决以下问题： 高并发写时的数据不一致问题 高并发读写时，请求执行各步骤的顺序是不可控的。假设此时有一个请求A，B都在在执行写流程，请求A是需要将某个数据改成1，请求B是需要将某个数据改为
专题四 Redis分布式锁中——Redission
热门推荐
新入坑的嵌入式的小白
05-29 1万+
Redis分布式锁
Redis分布式锁
vincentchen1990的博客
10-10 172
一、悲观锁 使用redis实现分布式悲观锁，主要是使用了redis原生命令的set命令（http://redisdoc.com/string/set.html）， SET key value [EX seconds] [PX milliseconds] [NX|XX] 从 Redis 2.6.12 版本开始， SET 命令的行为可以通过一系列参数来修改，比如NX参数，就能取代SETNX命令...
说说Redis分布式锁是如何实现的。含Redis面试专题及答案
m0_67322837的博客
04-18 1572
前言 近来，分布式的问题被广泛提及，比如分布式事务、分布式框架、ZooKeeper、SpringCloud等等。本文先回顾锁的概念，再介绍分布式锁，以及如何用Redis来实现分布式锁。 一、锁的基本了解 首先，回顾一下我们工作学习中的锁的概念。 为什么要先讲锁再讲分布式锁呢？ 我们都清楚，锁的作用是要解决多线程对共享资源的访问而产生的线程安全问题，而在平时生活中用到锁的情况其实并不多，可能有些朋友对锁的概念和一些基本的使用不是很清楚，所以我们先看锁，再深入介绍分布式锁。 通过一个卖票的小案例来看
纠结！分布式锁到底用Redis好还是ZooKeeper好？
程序媛小琬的博客
03-20 525
前言 1. 什么是分布式锁 分布式锁是控制分布式系统之间同步访问共享资源的一种方式。在分布式系统中，常常需要协调他们的动作。如果不同的系统或是同一个系统的不同主机之间共享了一个或一组资源，那么访问这些资源的时候，往往需要互斥来防止彼此干扰来保证一致性，在这种情况下，便需要使用到分布式锁。 2. 为什么要使用分布式锁 为了保证一个方法或属性在高并发情况下的同一时间只能被同一个线程执行，在传统单体应用单机部署的情况下，可以使用Java并发处理相关的API(如ReentrantLock或Synchronized)
Redis专题（3）：锁的基本概念到Redis分布式锁实现
gao2175的博客
09-25 430
拓展阅读：Redis闲谈（1）：构建知识图谱 Redis专题(2)：Redis数据结构底层探秘 近来，分布式的问题被广泛提及，比如分布式事务、分布式框架、ZooKeeper、SpringCloud等等。本文先回顾锁的概念，再介绍分布式锁，以及如何用Redis来实现分布式锁。 一、锁的基本了解 首先，回顾一下我们工作学习中的锁的概念。 为什么要先讲锁再讲分布式锁呢？ 我们都清楚，锁的作用是要解决多线...
Redis从入门到精通（二）：分布式锁以及缓存相关问题
wufeifan_learner的博客
05-08 261
目录： Redis从入门到精通（一）：缓存 Redis从入门到精通（二）：分布式锁以及缓存相关问题 Redis从入门到精通（三）：Redis持久化算法以及内存淘汰策略 Redis从入门到精通（四）：Redis常用数据结构以及指令 Redis从入门到精通（五）：Redis6整合SpringBoot2.x+Mybatis+SpringCache Redis从入门到精通（六）：Redis高可用原理+实战 Redis从入门到精通（七）：待定 分布式架构 什么是分布式架构？ 很简单，那就是服务不放在同一台主机上，或者
Java基础（6）- Java代码笔记3
weixin_47062560的博客
08-30 591
数据类型[][] 数组名 = new 数据类型[m][n]数据类型 数组名[][] = new 数据类型[m][n]数据类型[] 数组名[] = new 数据类型[m][n]m：代表二维数组长度n：代表二维数组中每个一维数组的长度。
[C++规范] 访问类成员变量的方式：直接访问还是通过成员函数访问？
Loewen丶的小窝
08-26 8133
在面向对象编程（OOP）中，通过成员函数（如`ME_HardwareTypeEnum Type() const;` 和 `int Id() const;`）来访问类的私有或受保护成员（如`m_hardwareType` 和 `m_id`），而不是直接通过公共成员访问，是一种更好的做法。
操作系统原子操作
zzt_is_me的博客
08-28 5446
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
基于Java+Springboot+Vue+elememt宠物用品商城系统设计实现
最新发布
央顺科技官方博客
08-31 800
随着信息技术的不断发展，我们现在已经步入了信息化的时代了，而信息时代的代表便是网络技术的日渐成熟，而现在网络已经和我们的生活紧密的联系起来了，我们不敢想象没有网络我们的生活会像怎么样，也许就像食物中没有调料现在的生活离开了网络会变得索然无味。通过网络我们可以足不出户的做许多事情，例如工作、娱乐、学习，交友和购物等等许多我们数之不尽的事情，而就是因为网络我们的生活变得多姿多彩，或许有时甚至帮我们省下不少的时间和给予了我们更多的机遇。宠物网上商城对我们来说就有这些意义。
输入三个正整数，找出不大不小的值
laocooon的博客
08-30 508
/ 找出最大值，找出最小值，然后不是最大值也不是最小值的。// 2、输入三个正整数，找出不大不小的值。
spring-data-redis中RedisRepository仓储
OceanSky的专栏
08-27 435
Id@RedisHash注解的value属性和@Id注解指定键值的命名空间，组合成user:id；@RedisHash的属性timeToLive属性指定键值的超时时间。CrudRepository接口中默认定义实现了save、saveAll、findById、existsById、findAll、findAllById、count、deleteById、delete、deleteAllById、deleteAll等方法，基本满足了对redis操作的需求；如果有特殊需求可以自定义实现。
死锁及其产生条件
秋夫人
08-26 2479
死锁是指两个或多个线程（或进程）互相等待对方释放资源，导致所有相关线程都无法继续执行的情况。这是并发编程中的一个常见问题，可能会导致系统部分或完全停止响应。
优秀的开源项目
猪猪
08-28 533
目录热key多线程并行秒级百G级日志工具ES操作工具消息推送平台HTTP 客户端业务层的分布式限流组件企业级微服务解决方案hotkey: 京东App后台中间件，毫秒级探测热点数据，毫秒级推送至服务器集群内存，大幅降低热key对数据层查询压力asyncTool: 解决任意的多线程并行、串行、阻塞、依赖、回调的并行框架，可以任意组合各线程的执行顺序，带全链路执行结果回调。多线程编排一站式解决方案。来自于京东主App后台。asyncTool: 解决任意的多线程并行、串行、阻塞、依赖、回调的并行框架，可以任意组合各
JVM 内存参数
iOS逆向与安全
08-29 1440
它屏蔽了与具体操作系统平台相关的信息，使Java程序只需生成在Java虚拟机上运行的目标代码（字节码），就可以在各种平台上不加修改的运行。‌例如，‌可以将最小堆内存设置为2GB（‌-Xms2048m）‌，‌最大堆内存设置为4GB（‌-Xmx4096m）‌。如果初始化的高水位线设置过低，会频繁的触发Full GC，高水位线会被多次调整。一般来说，垃圾回收器都会有默认的对象晋升到老年代的年龄参数阈值，CMS默认是6，G1默认是15，不过这参数值也不是一成不变的，它会根据动态年龄判断规则来重新被赋值。
Redis面试深度解析：主从复制、集群模式与分布式锁设计
与Redis分布式锁相比，Zookeeper的锁机制更偏向于分布式协调，而Redis分布式锁则更直接地利用了数据库操作来实现锁的创建和释放。 Redis以其丰富的数据结构、高效的数据管理和灵活的扩展性在面试中备受关注。了解并...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值