Redis 系列06--Redis 分布式锁专题

最新推荐文章于 2024-04-25 07:30:00 发布
最新推荐文章于 2024-04-25 07:30:00 发布
阅读量514 收藏
点赞数
文章标签： redis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fengxianaa/article/details/124390301
版权
本文探讨了如何在用户类中实现唯一名称约束，初始采用数据库唯一索引，但遇到分布式部署时转而使用Redisson分布式锁。文章详细介绍了加锁、守护线程延时以及Redisson MultiLock在高可用场景的应用，最终通过Redisson简化并发控制并解决数据一致性问题。
摘要由CSDN通过智能技术生成

上一篇：https://blog.csdn.net/fengxianaa/article/details/124389991

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. 解决方案

解决上述问题，就需要使用分布式锁

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

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){
            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("用户名已经存在！");
    }

4. 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("用户名已经存在");
    }
}

注意：上面代码有两个 tryLock 方法，一个带参数，一个不带参数

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

可以用下面的方法：

  • tryLock()
    • 直接申请锁，不需要任何参数
  • tryLock(long waitTime, TimeUnit unit)
    • 参数分别是：获取锁的最大等待时间(期间会重试)，时间单位

结果：

3. RedissonMultiLock

截止目前我们的 redis 只有一个节点，实际上 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();
}

5. 补充

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

  • 守护线程阻塞
  • watchDog 阻塞
  • 多个redis主节点同时宕机

等等

针对这种情况：凉拌

其实这就是告诉我们

  • 线程可能随时随地的阻塞在任何位置
  • 代码永远都是不完美的，我们所做的一起都是为了尽量避免出现问题，而不能保证毫无问题

fengxianaa
关注
Redisson——联合锁和红锁
m0_64363449的博客
09-04 1074
联合锁和红锁放在一起来分析，是因为这两种锁实现在Redisson中，关联密切。红锁是官方提出的一个锁方案，大概如下：假设redis集群有5个节点，一个客户端申请锁时，会向所有的节点申请锁，只有大于一半的节点数量返回成功，且耗费的总时间小于锁有效时间，才会判定为拿锁成功，否则会被认定为失败，需要将已经成功的节点锁释放掉。
Redisson联锁
sinat_34241861的博客
01-08 3234
一、联锁概述 联锁（RedissonMultiLock）对象可以将多个RLock对象关联为一个联锁，实现加锁和解锁功能。每个RLock对象实例可以来自于不同的Redisson实例。 联锁的好处： 如果负责储存分布式锁的某些Redis节点宕机以后，而且这些锁正好处于锁住状态，就会出现死锁问题。为了避免这种情况的发生，Redisson内部提供了一个监控锁的看门狗。看门狗的作用是在Redisson实例被关闭前，不断延长锁的有效期。默认情况下，看门狗的检查锁的超时时间是30秒，也可以通过修改Config.lockW
基于Redisson的联锁(MultiLock)
于琦海
08-22 2127
基于Redis的分布式MultiLock对象允许对Lock对象进行分组并将它们作为单个锁进行处理。每个RLock对象可能属于不同的Redisson实例。如果获取的Redisson实例MultiLock崩溃，那么它可能永远挂在获取状态。为了避免这种情况，Redisson维护了一个锁看门狗，它会在持有者Redisson实例处于活动状态时延长锁过期时间。默认情况下，锁定看门狗超时为30s，可以通过Config.lockWatchdogTimeout设置进行更改。
redis分布式锁
zhaocuit的博客
05-28 499
redis分布式锁 概述 随着技术快速发展，数据规模增大，分布式系统越来越普及，一个应用往往会部署在多台机器上（多节点），在有些场景中，为了保证数据不重复，要求在同一时刻，同一任务只在一个节点上运行，即保证某一方法同一时刻只能被一个线程执行。在单机环境中，应用是在同一进程下的，只需要保证单进程多线程环境中的线程安全性，通过 JAVA 提供的 volatile、ReentrantLock、synchronized 以及 concurrent 并发包下一些线程安全的类等就可以做到。而在多机部署环境中，不同机器不
redis-distribute-lock:Redis分布式锁的try-with-resources实现
05-17
Redis分布式锁的try-with-resources实现 一、简介 在当今这个时代，单体应用（standalone）已经很少了，java提供的synchronized已经不能满足需求，大家自然 而然的想到了分布式锁。谈到分布式锁，比较流行的方法有3...
redis-windows-7.2.5.zip
最新发布
05-20
在分布式系统中，用作消息队列或分布式锁。 综上所述，Redis是一个强大且灵活的键值数据库，广泛应用于各种场景。在Windows上部署Redis需要下载相应版本的压缩包，解压并配置后运行服务，即可开始使用。通过掌握...
人工智能-项目实践-redis-基于 Redis 实现的分布式锁.zip
12-23
人工智能-项目实践-redis-基于 Redis 实现的分布式锁 redis-lock 基于 Redis 实现的分布式锁。要求： Redis >= v7: 理论上来说低于 Redis 7 的也可以，但是暂时我还没在这些 Redis 版本上测试 Go >= 18: 低版本的 ...
tomcat-redis-session-manager
06-06
因此，在大型分布式系统中，推荐将Redis部署在靠近应用服务器的网络位置，以减少延迟影响。 此外，为了确保高可用性，可以考虑在Redis集群上运行`tomcat-redis-session-manager`，这样即使某个Redis节点故障，...
Another-Redis-Desktop-Manager.1.6.1
09-23
《Redis桌面管理器Another-Redis-Desktop-Manager详解》 Redis，全称为Remote Dictionary Server，是一种高性能的键值存储系统，常被用作数据库、缓存和消息中间件。其简洁的数据结构和丰富的数据类型使其在分布式...
redis 红锁
weixin_44313232的博客
03-09 419
并且，每个节点执行完tryLock()尝试获取锁之后，无论是否获取锁成功，都会判断目前从各个节点获取锁已经消耗的总时间，如果已经等于最大等待时间，则认定最终申请锁失败，需要对成功加锁集合 acquiredLocks 中的所有锁执行锁释放，然后返回false。线程2来到了redis抢占锁，因为3挂了，1，2有锁，只有4和5可以加锁，因为我们注册的时候是5台，4和5这两台不满足n/2+1原则，抢占锁失败。当redis3挂了，此时线程1获取到了锁，正在顺序执行，难道用了红锁一定能保证加的锁的一定不丢失吗？
redisson实现的MultiLock、RedLock分布式锁使用场景和可能存在的问题。
qq_25156781的博客
11-01 2073
Redisson是一个在Redis的基础上实现的Java驻内存数据网格（In-Memory Data Grid）。它是一个基于Redis实现的高级分布式锁客户端。同时Redisson是Redis官网指定的RedlLock使用Java语言的实现。网络上沿着Redisson的官方文档的介绍已经很多，公平锁、读写锁、信号量、闭锁的用法和源码解析。我这里就不做赘述。本篇博文主要讲使用联锁MultiLock和红锁RedLock的必要场景，以及可能出现的问题。
Redis第14讲——Redis实现分布式锁（Redission源码解析）
让~学习~成为一种习惯（橡 皮 人の技术博客）
04-25 1765
在多线程环境下，为了保证数据的线程安全，我们通常用加锁的方式，使同一时刻只有一个线程可以对这个共享资源进行操作，在单服务系统我们常用JVM锁——Synchronized、ReentrantLock等。然而在多台服务系统的情况下，JVM锁就无法在多个服务器之间生效了，这时候我们就需要用分布式锁来解决线程安全的问题。分布式锁的实现方式有很多，主流的就是基于数据库、zookeeper以及redis，当然使用redis的居多，由于篇幅原因，本节就详细介绍一下使用redis实现分布式锁的几种方式。
【Redis】Redis高级：分布式锁
qq_50675319的博客
09-20 1015
上述任务的执行时间我们可以看到，是internalLockLeaseTime / 3，那么这个internalLockLeaseTime又是多少呢？其实这里的internalLockLeaseTime和我们之前提到的看门狗过期时间是同一个时间，也就是30秒，也就是说这里任务的执行时间就是10秒之后，而每当我们执行一次任务之后，任务内部又会再次调用renewExpiration()，也就是说这段任务每隔10秒就会执行一次，刷新当前线程持有锁的有效期，模拟一个锁永不过期的效果，这个任务也就被称为"看门狗"
redis分布式锁（redis实现及redisson实现）
weixin_44307338的博客
01-19 963
今天做任务用到了redis的分布式锁，分享一下，不足之处还请大佬指正。 方法一 使用redis，我们想要自己实现分布式锁，首先要防止死锁、占用时间过长等问题，以下是分布式锁的流程，分为两个线程，左半边为主线程，右半边为守护线程。 由于我并没有用这种方法做，只是设计了一下，就不战列具体代码，只说思路。 首先我们要封装三个方法，降低耦合性，设置参数的时候要考虑灵活性，这样其他的代码也可以使用，第一个方法tryGetDistributed...
Redisson分布式锁详解（非公平、公平、红锁、联锁）
mlwsmqq的博客
01-09 6088
本文讲解了Redisson框架提供的分布式锁（公平/非公平）、红锁、联锁的基本使用及效果演示，帮助大家快速熟悉分布式锁，相信一定对大家有所收益，欢迎观看！
Redisson分布式联锁RedissonMultiLock
皮球
02-28 1044
Redisson分布式联锁RedissonMultiLock
再谈分布式锁之剖析Redis实现
weixin_30364325的博客
07-24 238
之前笔者已经写过关于分布式锁的内容，但囿于彼时对于分布式锁的研究还不算太深入，如今读来发现还是存在一些问题，故而写作本文，对Redis分布式锁的实现做一个更加全面、进阶的阐述和总结，帮助读者对Redis分布式锁有一个更加深入客观的了解。关于更多分布式锁的其他实现，在后续的文章中也会陆续展开。 我们还是通过经典的WWH(what why how)三段论方式进行行文。首先再次从宏观上了解什么是分布式锁...
Lock锁及获取锁的四种方法
热门推荐
是小D吖！的博客
11-07 1万+
Lock锁
spring-redis实现的Redis分布式锁的例子
11-21
以下是使用Spring Redis实现Redis分布式锁的例子： 首先，在pom.xml文件中添加以下依赖： ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> ``` 然后，创建一个Redis分布式锁的接口： ```java public interface RedisLock { /** * 获取锁 * * @param key 锁的key * @param expireTime 锁的过期时间 * @return 是否获取成功 */ boolean lock(String key, long expireTime); /** * 释放锁 * * @param key 锁的key */ void unlock(String key); } ``` 接着，实现Redis分布式锁的接口： ```java @Component public class RedisLockImpl implements RedisLock { private final RedisTemplate<String, String> redisTemplate; private final ThreadLocal<Map<String, Integer>> lockers = new ThreadLocal<>(); @Autowired public RedisLockImpl(RedisTemplate<String, String> redisTemplate) { this.redisTemplate = redisTemplate; } @Override public boolean lock(String key, long expireTime) { Map<String, Integer> localLockers = getLocalLockers(); Integer count = localLockers.get(key); if (count != null) { localLockers.put(key, count + 1); return true; } Boolean result = redisTemplate.opsForValue().setIfAbsent(key, ""); if (!result) { return false; } redisTemplate.expire(key, expireTime, TimeUnit.MILLISECONDS); localLockers.put(key, 1); return true; } @Override public void unlock(String key) { Map<String, Integer> localLockers = getLocalLockers(); Integer count = localLockers.get(key); if (count == null) { return; } if (count > 1) { localLockers.put(key, count - 1); } else { localLockers.remove(key); redisTemplate.delete(key); } } private Map<String, Integer> getLocalLockers() { Map<String, Integer> localLockers = lockers.get(); if (localLockers != null) { return localLockers; } lockers.set(new HashMap<>()); return lockers.get(); } } ``` 最后，在需要使用分布式锁的地方，注入RedisLock接口，使用lock()方法获取锁，使用unlock()方法释放锁： ```java @Service public class UserService { private final RedisLock redisLock; @Autowired public UserService(RedisLock redisLock) { this.redisLock = redisLock; } public void updateUser(String userId) { String lockKey = "user_" + userId; boolean locked = redisLock.lock(lockKey, 5000); if (!locked) { throw new RuntimeException("获取锁失败"); } try { // 更新用户信息 } finally { redisLock.unlock(lockKey); } } } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值