分布式锁之Redis篇

程序员文章站 2022-06-17 19:07:34

分布式锁之Redis文章目录分布式锁之Redis1. 前言2. Redis实现分布式锁2.1 阶段一2.2 阶段二2.3 阶段三2.4 阶段四2.5 阶段五2.6 小总结3. Redisson实现分布式锁3.1 Redisson 简介3.2 可重入锁 Reentrant Lock3.3 读写锁 ReadWriteLock3.4 信号量 Semaphore3.5 闭锁 CountDownLatch3.6 Redisson解决上面Redis查询问题1. 前言在Java并发编程中，我们通常使用到synch...

分布式锁之Redis

文章目录

分布式锁之Redis

1. 前言

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

实现分布式锁的方案

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

2. Redis实现分布式锁

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

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

2.1 阶段一

分布式锁之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;
    }

2.2 阶段二

分布式锁之Redis篇

    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();
        }
    }

2.3 阶段三

分布式锁之Redis篇

  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();
        }
    }

2.4 阶段四

分布式锁之Redis篇

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();
        }
    }

2.5 阶段五

分布式锁之Redis篇

  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();
        }
    }

2.6 小总结

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

3. Redisson实现分布式锁

3.1 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），从而让使用者能够将精力更集中地放在处理业务逻辑上。

原理机制
分布式锁之Redis篇

文档地址

集成Spring Boot 项目

引入依赖【可引入Spring Boot 封装好的starter】

  <!-- https://mvnrepository.com/artifact/org.redisson/redisson -->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.12.0</version>
        </dependency>

添加配置类

@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;
    }
}

3.2 可重入锁 Reentrant Lock

获取一把锁 redissonClient.getLock(“my-lock”);
给业务代码加锁 lock.lock();
解锁 lock.unlock();
看门狗机制锁会自动续期

@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();
        }
    }

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

二个方法对比

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

3.3 读写锁 ReadWriteLock

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

写+读写锁没有释放，读锁就得等待
写+写阻塞方式
读+写写锁等待读锁释放才能加锁
读+读相当于无锁，并发读

 @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;
    }

3.4 信号量 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";
    }

3.5 闭锁 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+"班级走了....";
    }

3.6 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;
    }

你若盛开，清风自来！！！

本文地址：https://blog.csdn.net/qq_44209336/article/details/110876295

上一篇： Java网络编程--FTP协议模拟用户客户端登录

下一篇： Sqlserver 高并发和大数据存储方案

分布式锁之Redis篇

分布式锁之Redis

文章目录

1. 前言

2. Redis实现分布式锁

2.1 阶段一

2.2 阶段二

2.3 阶段三

2.4 阶段四

2.5 阶段五

2.6 小总结

3. Redisson实现分布式锁

3.1 Redisson 简介

3.2 可重入锁 Reentrant Lock

3.3 读写锁 ReadWriteLock

3.4 信号量 Semaphore

3.5 闭锁 CountDownLatch

3.6 Redisson解决上面Redis查询问题

redis实现分布式锁方式（redis分布式锁三个方法）

Java Redis分布式锁的正确实现方式详解

基于Redis实现分布式锁实战

死磕 java同步系列之mysql分布式锁

[PHP] 基于redis的分布式锁防止高并发重复请求

Python实现的redis分布式锁功能示例

[原创]分布式系统之缓存的微观应用经验谈（一）【设计细节篇】

[原创]分布式系统之缓存的微观应用经验谈（二）【主从和主备高可用篇】

死磕 java同步系列之zookeeper分布式锁

死磕 java同步系列之redis分布式锁进化史

分布式锁之Redis篇

分布式锁之Redis

文章目录

1. 前言

2. Redis实现分布式锁

2.1 阶段一

2.2 阶段二

2.3 阶段三

2.4 阶段四

2.5 阶段五

2.6 小总结

3. Redisson实现分布式锁

3.1 Redisson 简介

3.2 可重入锁 Reentrant Lock

3.3 读写锁 ReadWriteLock

3.4 信号量 Semaphore

3.5 闭锁 CountDownLatch

3.6 Redisson解决上面Redis查询问题

redis实现分布式锁方式（redis分布式锁三个方法）

Java Redis分布式锁的正确实现方式详解

基于Redis实现分布式锁实战

死磕 java同步系列之mysql分布式锁

[PHP] 基于redis的分布式锁防止高并发重复请求

Python实现的redis分布式锁功能示例

[原创]分布式系统之缓存的微观应用经验谈（一） 【设计细节篇】

[原创]分布式系统之缓存的微观应用经验谈（二） 【主从和主备高可用篇】

死磕 java同步系列之zookeeper分布式锁

死磕 java同步系列之redis分布式锁进化史

[原创]分布式系统之缓存的微观应用经验谈（一）【设计细节篇】

[原创]分布式系统之缓存的微观应用经验谈（二）【主从和主备高可用篇】