百度360必应搜狗淘宝本站头条
php redisredis 命令redis 锁redis 主从redis 删除
当前位置：网站首页 > 技术教程 > 正文

关于Redis分布式锁这一篇应该是讲的最好的了，赶紧收藏起来

mhr18 2024-10-22 12:36 21 浏览 0 评论

前言

在Java并发编程中，我们通常使用到synchronized 、Lock这两个线程锁，Java中的锁，只能保证对同一个JVM中的线程有效。而在分布式集群环境，这个时候我们就需要使用到分布式锁。

实现分布式锁的方案

  • 基于数据库实现分布式锁
  • 基于缓存Redis实现分布式锁
  • 基于Zookeeper的临时序列化节点实现分布式锁

Redis实现分布式锁

场景：在高并发的情况下，可能有大量请求来到数据库查询三级分类数据，而这种数据不会经常改变，可以引入缓存来存储第一次从数据库查询出来的数据，其他线程就可以去缓存中获取数据，来减少数据库的查询压力。

在集群的环境下，就可以使用分布式锁来控制去查询数据库的次数。

阶段一

    private  Map<String, List<Catelog2Vo>>  getCatalogJsonDBWithRedisLock() {
        // 去Redis中抢占位置
        Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent("lock", "1111");
        if (lock){
            // 抢到锁了 执行业务
            Map<String, List<Catelog2Vo>> dataFromDb = getDataFromDb();
            // 删除锁
            stringRedisTemplate.delete("lock");
            return dataFromDb;
        }else {
            // 自旋获取锁
            // 休眠100ms
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return getCatalogJsonDBWithRedisLock();
        }
    }

得到锁以后，我们应该再去缓存中确定一次，如果没有才需要继续查询，从数据库查到数据以后，应该先把数据放入缓存中，再将数据返回。

  private Map<String, List<Catelog2Vo>> getDataFromDb() {
        // 得到锁以后，我们应该再去缓存中确定一次，如果没有才需要继续查询
        String catalogJson = stringRedisTemplate.opsForValue().get("catalogJson");
        if (!StringUtils.isEmpty(catalogJson)) {
            // 反序列化 转换为指定对象
            Map<String, List<Catelog2Vo>> result = JSON.parseObject(catalogJson, new 
            TypeReference<Map<String, List<Catelog2Vo>>>() {});
            return result;
        }
        System.out.println("查询数据库了......");
        // 查询所有分类数据在进行刷选
        List<CategoryEntity> categoryEntityList = baseMapper.selectList(null);
        // 查询一级分类
        List<CategoryEntity> leave1Categorys = getParent_cid(categoryEntityList, 0L);
        Map<String, List<Catelog2Vo>> listMap = leave1Categorys.stream().collect(Collectors.toMap(k -> k.getCatId().toString(), l1 -> {

            List<CategoryEntity> categoryL2List = getParent_cid(categoryEntityList, l1.getCatId());
            List<Catelog2Vo> catelog2Vos = null;
            if (categoryL2List != null) {
                catelog2Vos = categoryL2List.stream().map(l2 -> {
                    Catelog2Vo catelog2Vo = new Catelog2Vo(l2.getParentCid().toString(), null, l2.getCatId().toString(), l2.getName());

                    List<CategoryEntity> categoryL3List = getParent_cid(categoryEntityList, 
                                                                        l2.getCatId());
                    if (categoryL3List != null) {
                        List<Catelog2Vo.Catelog3Vo> catelog3Vos =  
                            categoryL3List.stream().map(l3 -> {
                            Catelog2Vo.Catelog3Vo catelog3Vo = new 
                               Catelog2Vo.Catelog3Vo(l2.getCatId().toString(), 
                                                      l3.getCatId().toString(), 
                                                      l3.getName());
                            return catelog3Vo;
                        }).collect(Collectors.toList());
                        catelog2Vo.setCatalog3List(catelog3Vos);
                    }
                    return catelog2Vo;
                }).collect(Collectors.toList());
            }
            return catelog2Vos;
        }));
        // 最后需将数据加入的缓存中
        String jsonString = JSON.toJSONString(listMap);
        stringRedisTemplate.opsForValue().set("catalogJson", jsonString, 1L, 
                                              TimeUnit.DAYS);

        return listMap;
    }

阶段二

    private  Map<String, List<Catelog2Vo>>  getCatalogJsonDBWithRedisLock() {
        // 去Redis中抢占位置
        Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent("lock", "1111");
        if (lock){
            // 抢到锁了 执行业务
            // 设置过期时间
            stringRedisTemplate.expire("lock",3,TimeUnit.SECONDS);
            Map<String, List<Catelog2Vo>> dataFromDb = getDataFromDb();
            // 删除锁
            stringRedisTemplate.delete("lock");
            return dataFromDb;
        }else {
            // 自旋获取锁
            // 休眠100ms
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return getCatalogJsonDBWithRedisLock();
        }
    }

阶段三

  private  Map<String, List<Catelog2Vo>>  getCatalogJsonDBWithRedisLock() {
        // 去Redis中抢占位置  保证原子性
      Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent("lock", 
      "1111",300,TimeUnit.SECONDS);
        if (lock){
            // 抢到锁了 执行业务
            Map<String, List<Catelog2Vo>> dataFromDb = getDataFromDb();
            // 删除锁
            stringRedisTemplate.delete("lock");
            return dataFromDb;
        }else {
            // 自旋获取锁
            // 休眠100ms
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return getCatalogJsonDBWithRedisLock();
        }
    }

阶段四

private  Map<String, List<Catelog2Vo>>  getCatalogJsonDBWithRedisLock() {
        String uuid = UUID.randomUUID().toString();
        // 去Redis中抢占位置  保证原子性
        Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent("lock", uuid,300,TimeUnit.SECONDS);
        if (lock){
            // 抢到锁了 执行业务
            Map<String, List<Catelog2Vo>> dataFromDb = getDataFromDb();
            String s = stringRedisTemplate.opsForValue().get("lock");
            if (uuid.equals(s)){
                // 删除锁
                stringRedisTemplate.delete("lock");
            }
            return dataFromDb;
        }else {
            // 自旋获取锁
            // 休眠100ms
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return getCatalogJsonDBWithRedisLock();
        }
    }

阶段五

  private  Map<String, List<Catelog2Vo>>  getCatalogJsonDBWithRedisLock() {
        String uuid = UUID.randomUUID().toString();
        // 去Redis中抢占位置  保证原子性
        Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent("lock", uuid,300,TimeUnit.SECONDS);
        if (lock){
            // 抢到锁了 执行业务
            Map<String, List<Catelog2Vo>> dataFromDb = getDataFromDb();
            String s = stringRedisTemplate.opsForValue().get("lock");
            // 获取值对比+对比成功删除=原子操作 Lua脚本解锁
            String script = "if redis.call(\"get\",KEYS[1]) == ARGV[1] then\n" +
                    "    return redis.call(\"del\",KEYS[1])\n" +
                    "else\n" +
                    "    return 0\n" +
                    "end";
            Long lock1 = stringRedisTemplate.execute(new DefaultRedisScript<Long>(script, Long.class) , Arrays.asList("lock"), uuid);
            return dataFromDb;
        }else {
            // 自旋获取锁
            // 休眠100ms
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return getCatalogJsonDBWithRedisLock();
        }
    }

小总结

  1. stringRedisTemplate.opsForValue().setIfAbsent(“lock”, uuid,300,TimeUnit.SECONDS);
  2. stringRedisTemplate.execute(new DefaultRedisScript(script, Long.class) , Arrays.asList(“lock”), uuid);
  3. 使用Redis来实现分布式锁需保证加锁【占位+过期时间】和删除锁【判断+删除】操作的原子性。
  4. Redis锁的过期时间小于业务的执行时间该如何自动续期？设置一个比业务耗时更长的过期时间Redisson的看门狗机制

Redisson实现分布式锁

Redisson 简介

Redisson是一个在Redis的基础上实现的Java驻内存数据网格（In-Memory Data Grid）。它不仅提供了一系列的分布式的Java常用对象，还提供了许多分布式服务。其中包括(BitSet, Set, Multimap, SortedSet, Map, List, Queue, BlockingQueue, Deque, BlockingDeque, Semaphore, Lock, AtomicLong, CountDownLatch, Publish / Subscribe, Bloom filter, Remote service, Spring cache, Executor service, Live Object service, Scheduler service) Redisson提供了使用Redis的最简单和最便捷的方法。Redisson的宗旨是促进使用者对Redis的关注分离（Separation of Concern），从而让使用者能够将精力更集中地放在处理业务逻辑上。

原理机制

集成Spring Boot 项目

  1. 引入依赖 【可引入Spring Boot 封装好的starter】 <!-- https://mvnrepository.com/artifact/org.redisson/redisson --> <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> <version>3.12.0</version> </dependency>
  2. 添加配置类@Configuration public class MyRedissonConfig { @Bean(destroyMethod = "shutdown") public RedissonClient redissonClient(){ // 创建配置 记得加redis:// Config config = new Config(); config.useSingleServer().setAddress("redis://192.168.26.104:6379"); // 根据配置创建RedissClient客户端 RedissonClient redissonClient = Redisson.create(config); return redissonClient; } }

可重入锁 Reentrant Lock

  1. 获取一把锁 redissonClient.getLock(“my-lock”);
  2. 给业务代码加锁 lock.lock();
  3. 解锁 lock.unlock();
  4. 看门狗机制 锁会自动续期
@ResponseBody
    @GetMapping("/hello")
    public String hello(){
        // 1、获取一把锁，只要锁的名字一样，就是同一把锁
        RLock lock = redissonClient.getLock("my-lock");
        // 加锁
        // 阻塞式等待，默认加的锁都是【看门狗时间】30s时间
        //1)、锁的自动续期，如果业务超长，运行期间自动给锁续上新的30s，不用担心业务时间长，锁自动过期被删掉
        //2)、加锁的业务只要运行完成，就不会给当前锁续期，即使不手动解锁，锁默认在30s以后自动删除
        lock.lock();
        try {
            System.out.println("加锁成功......."+Thread.currentThread().getId());
            Thread.sleep(30000);
        } catch (InterruptedException e) {

        }finally {
            // 释放锁   不会出现死锁状态 如果没有执行解锁，锁有过期时间，过期了会将锁删除
            lock.unlock();
            System.out.println("解锁成功......"+Thread.currentThread().getId());
        }
        return "hello";
    }

lock方法有一个重载方法 lock(long leaseTime, TimeUnit unit)

  public void lock(long leaseTime, TimeUnit unit) {
        try {
            this.lock(leaseTime, unit, false);
        } catch (InterruptedException var5) {
            throw new IllegalStateException();
        }
    }

注意：指定了过期时间后，不会进行自动续期，此时如果有多个线程，即便业务还然在执行，过期时间到了之后，锁就会被释放，其他线程就会争抢到锁。

二个方法对比

  1. 如果设置了过期时间，就会发生执行脚本给Redis，进行占锁，设置过期时间为我们指定的时间。
  2. 未设置过期时间，就会使用看门狗的默认时间LockWatchdogTimeout 30*1000
  3. 只有没有指定过期的时间的方法才有自动续期功能
  4. 自动续期实现机制 ：只要占锁成功，就会自动启动一个定时任务【重新给锁设置过期时间，新的过期时间就是看门狗的默认时间】，每隔10s【（ internalLockLeasTime）/3】都会自动续期。
  5. 持有锁的机器宕机问题，因为来不及续期，所以锁自动被释放，当该机再次恢复时，因为其后台守护线程是ScheduleTask，所以恢复后会马上执行一次watchDog续期逻辑，执行过程中，它会感知到自己已经丢失了锁，所以不存在共同持有的问题。

读写锁 ReadWriteLock

保证一定能读到最新数据，修改期间，写锁是一个互斥锁，读锁是一个共享锁。

  1. 写+读 写锁没有释放，读锁就得等待
  2. 写+写 阻塞方式
  3. 读+写 写锁等待读锁释放才能加锁
  4. 读+读 相当于无锁，并发读
 @ResponseBody
    @GetMapping("/write")
    public String writeLock(){
        RReadWriteLock readWriteLock = redissonClient.getReadWriteLock("rw-lock");
        RLock rLock = readWriteLock.writeLock();
        String s = "";
        try {
            rLock.lock();
            System.out.println("写锁加锁成功......"+Thread.currentThread().getId());
            s = UUID.randomUUID().toString();
            stringRedisTemplate.opsForValue().set("writeLock",s);
            Thread.sleep(30000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            rLock.unlock();
            System.out.println("写锁释放成功......"+Thread.currentThread().getId());
        }
       return s;
    }

    @ResponseBody
    @GetMapping("/read")
    public String readLock(){
        RReadWriteLock readWriteLock = redissonClient.getReadWriteLock("rw-lock");
        RLock rLock = readWriteLock.readLock();
        rLock.lock();
        String s = "";
        try{
            System.out.println("读锁加锁成功......"+Thread.currentThread().getId());
            s = stringRedisTemplate.opsForValue().get("writeLock");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            System.out.println("读锁释放成功......"+Thread.currentThread().getId());
            rLock.unlock();
        }
        return s;
    }

信号量 Semaphore

使用信号量来做分布式限流

    @ResponseBody
    @GetMapping("/park")
    public String park() throws InterruptedException {
        RSemaphore park = redissonClient.getSemaphore("park");
        // 抢占一个车位
        boolean b = park.tryAcquire();
        // 如果还可以抢占到 就执行业务代码
        if (b){
            // 执行业务代码
        }else {
            return "error";
        }
        return "ok=>"+b;
    }

    @ResponseBody
    @GetMapping("/go")
    public String go() {
        RSemaphore park = redissonClient.getSemaphore("park");
        //  释放一个车位
        park.release();
        return "ok";
    }

闭锁 CountDownLatch

模拟场景：等待班级放学走了，保安关校门。

    @ResponseBody
    @GetMapping("/lockdoor")
    public String lockDoor() throws InterruptedException {
        RCountDownLatch door = redissonClient.getCountDownLatch("door");
        door.trySetCount(5);
        // 等待闭锁完成
        door.await();
        return "放假了.....";
    }

    @GetMapping("/gogogo/{id}")
    @ResponseBody
    public String gogogo(@PathVariable("id")Long id){
        RCountDownLatch door = redissonClient.getCountDownLatch("door");
        // 计数减一
        door.countDown();
        return id+"班级走了....";
    }

Redisson解决上面Redis查询问题

  /**
     * 使用Redisson分布式锁来实现多个服务共享同一缓存中的数据
     * @return
     */
    private Map<String, List<Catelog2Vo>> getCatalogJsonDBWithRedissonLock() {
        RLock lock = redissonClient.getLock("catalogJson-lock");
         // 该方法会阻塞其他线程向下执行，只有释放锁之后才会接着向下执行
        lock.lock();
        Map<String, List<Catelog2Vo>> dataFromDb = null;
        try {
            dataFromDb = getDataFromDb();
        }finally {
            lock.unlock();
        }
        return dataFromDb;
    }

相关推荐

使用 Docker 部署 Java 项目(通俗易懂)

前言：搜索镜像的网站（推荐）：DockerDocs1、下载与配置Docker1.1docker下载（这里使用的是Ubuntu，Centos命令可能有不同）以下命令，默认不是root用户操作，...

Spring Boot 3.3.5 + CRaC:从冷启动到秒级响应的架构实践与踩坑实录

去年，我们团队负责的电商订单系统因扩容需求需在10分钟内启动200个Pod实例。当运维组按下扩容按钮时，传统SpringBoot应用的冷启动耗时（平均8.7秒）直接导致流量洪峰期出现30%的请求超时...

《github精选系列》——SpringBoot 全家桶

1简单总结1SpringBoot全家桶简介2项目简介3子项目列表4环境5运行6后续计划7问题反馈gitee地址：https://gitee.com/yidao620/springbo...

Nacos简介—1.Nacos使用简介

大纲1.Nacos的在服务注册中心+配置中心中的应用2.Nacos2.x最新版本下载与目录结构3.Nacos2.x的数据库存储与日志存储4.Nacos2.x服务端的startup.sh启动脚...

spring-ai ollama小试牛刀

序本文主要展示下spring-aiollama的使用示例pom.xml<dependency><groupId>org.springframework.ai<...

SpringCloud系列——10Spring Cloud Gateway网关

学习目标Gateway是什么？它有什么作用？Gateway中的断言使用Gateway中的过滤器使用Gateway中的路由使用第1章网关1.1网关的概念简单来说，网关就是一个网络连接到另外一个网络的...

Spring Boot 自动装配原理剖析

前言在这瞬息万变的技术领域，比了解技术的使用方法更重要的是了解其原理及应用背景。以往我们使用SpringMVC来构建一个项目需要很多基础操作：添加很多jar，配置web.xml，配置Spr...

疯了!Spring 再官宣惊天大漏洞

Spring官宣高危漏洞大家好，我是栈长。前几天爆出来的Spring漏洞，刚修复完又来？今天愚人节来了，这是和大家开玩笑吗？不是的，我也是猝不及防！这个玩笑也开的太大了！！你之前看到的这个漏洞已...

「架构师必备」基于SpringCloud的SaaS型微服务脚手架

简介基于SpringCloud(Hoxton.SR1)+SpringBoot(2.2.4.RELEASE)的SaaS型微服务脚手架，具备用户管理、资源权限管理、网关统一鉴权、Xss防跨站攻击、...

SpringCloud分布式框架&amp;分布式事务&amp;分布式锁

总结本文承接上一篇SpringCloud分布式框架实践之后，进一步实践分布式事务与分布式锁，其中分布式事务主要是基于Seata的AT模式进行强一致性，基于RocketMQ事务消息进行最终一致性，分布式...

SpringBoot全家桶:23篇博客加23个可运行项目让你对它了如指掌

SpringBoot现在已经成为Java开发领域的一颗璀璨明珠，它本身是包容万象的，可以跟各种技术集成。本项目对目前Web开发中常用的各个技术，通过和SpringBoot的集成，并且对各种技术通...

开发好物推荐12之分布式锁redisson-sb

前言springboot开发现在基本都是分布式环境，分布式环境下分布式锁的使用必不可少，主流分布式锁主要包括数据库锁，redis锁，还有zookepper实现的分布式锁，其中最实用的还是Redis分...

拥抱Kubernetes,再见了Spring Cloud

相信很多开发者在熟悉微服务工作后，才发现：以为用SpringCloud已经成功打造了微服务架构帝国，殊不知引入了k8s后，却和CloudNative的生态发展脱轨。从2013年的...

Zabbix/J监控框架和Spring框架的整合方法

Zabbix/J是一个Java版本的系统监控框架，它可以完美地兼容于Zabbix监控系统，使得开发、运维等技术人员能够对整个业务系统的基础设施、应用软件/中间件和业务逻辑进行全方位的分层监控。Spri...

SpringBoot+JWT+Shiro+Mybatis实现Restful快速开发后端脚手架

作者：lywJee来源：cnblogs.com/lywJ/p/11252064.html一、背景前后端分离已经成为互联网项目开发标准，它会为以后的大型分布式架构打下基础。SpringBoot使编码配置...

取消回复欢迎 你 发表评论:

一周热门
最近发表
标签列表