Redis 分布式锁

已于 2022-05-20 15:57:10 修改
阅读量429 收藏 1
点赞数
文章标签： 分布式 redis java
于 2022-05-16 15:33:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_37351027/article/details/124800463
版权

分布式锁

在分布式环境下，多个程序/线程都需要对某一份(或有限制)的数据进行修改时，针对程序进行控制，保证同一时间节点下，只有一个程序/线程对数据进行操作的技术。

简单来讲 就是在分布式项目 保证 多个线程 对某一份数据 同一个时间 节点下 ，只有一个线程进行操作

1、 使用redis实现分布式锁

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

操作顺序

在这里插入图片描述

java代码

spring boot 整合 Redis 需要的依赖

    <!-- redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

        <!-- spring2.X集成redis所需common-pool2-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
            <version>2.6.0</version>
        </dependency>

RedisConfig配置类

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;

@EnableCaching
@Configuration
public class RedisConfig extends CachingConfigurerSupport {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setConnectionFactory(factory);
//key序列化方式
        template.setKeySerializer(redisSerializer);
//value序列化
        template.setValueSerializer(jackson2JsonRedisSerializer);
//value hashmap序列化
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        return template;
    }

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        //解决查询缓存转换异常的问题
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);

        om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,
                ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);

        // om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // 配置序列化（解决乱码的问题）,过期时间600秒
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofSeconds(600))
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
                .disableCachingNullValues();
        RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                .cacheDefaults(config)
                .build();
        return cacheManager;
    }
}

spring boot 配置文件

#Redis服务器地址
spring.redis.host=192.168.44.168
#Redis服务器连接端口
spring.redis.port=6379
#Redis数据库索引（默认为0）
spring.redis.database= 0
#连接超时时间（毫秒）
spring.redis.timeout=1800000
#连接池最大连接数（使用负值表示没有限制）
spring.redis.lettuce.pool.max-active=20
#最大阻塞等待时间(负数表示没限制)
spring.redis.lettuce.pool.max-wait=-1
#连接池中的最大空闲连接
spring.redis.lettuce.pool.max-idle=5
#连接池中的最小空闲连接
spring.redis.lettuce.pool.min-idle=0

测试

  @GetMapping
    public String testRedis() {
        //设置值到redis
        redisTemplate.opsForValue().set("name","lucy");
        //从redis获取值
        String name = (String)redisTemplate.opsForValue().get("name");
        return name;
    }
使用java 来实现Redis分布式锁
@GetMapping("testLock")
public void testLock(){
    //1获取锁，setne
    Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", "111");
    //2获取锁成功、查询num的值
    if(lock){
        Object value = redisTemplate.opsForValue().get("num");
        //2.1判断num为空return
        if(StringUtils.isEmpty(value)){
            return;
        }
        //2.2有值就转成成int
        int num = Integer.parseInt(value+"");
        //2.3把redis的num加1
        redisTemplate.opsForValue().set("num", ++num);
        //2.4释放锁，del
        redisTemplate.delete("lock");

    }else{
        //3获取锁失败、每隔0.1秒再获取
        try {
            Thread.sleep(100);
            testLock();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

模拟并发 使用Apifox工具

在这里插入图片描述
在这里插入图片描述

如果线程数 超过1 则结果可能会与下面不一致 （该问题下面会解决）

测试1000次访问后

在这里插入图片描述

在这里插入图片描述
问题 使用该方法 设置key 时并未设置key的过期时间 ，如果出现 业务异常 则可能导致锁无法被释放

解决 设置key的过期时间

优化之设置锁的过期时间

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

假设 a 先操作，进行一个上锁操作，然后进行业务处理，但此时突然服务器被卡顿了，导致 a 设置锁的时间到了，被自动释放，此时 b比c 恰巧先进行操作了上锁，然后 b 进行业务操作，此时服务器反应过来，继续进行操作， a 执行到最后手动释放锁，导致 b 的锁会被释放

优化之UUID防误删

在这里插入图片描述

    @GetMapping("testLock")
    public void testLock(){
        String uuid = UUID.randomUUID().toString();
        //1获取锁，setne
        Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", uuid,3, TimeUnit.SECONDS);
        //2获取锁成功、查询num的值
        if(lock){
            Object value = redisTemplate.opsForValue().get("num");
            //2.1判断num为空return
            if(StringUtils.isEmpty(value)){
                return;
            }
            //2.2有值就转成成int
            int num = Integer.parseInt(value+"");
            //2.3把redis的num加1
            redisTemplate.opsForValue().set("num", ++num);
            //2.4释放锁，del
            //判断比较uuid值是否一样
            String lockUuid = (String)redisTemplate.opsForValue().get("lock");
            if(lockUuid.equals(uuid)) {
                redisTemplate.delete("lock");
            }
        }else{
            //3获取锁失败、每隔0.1秒再获取
            try {
                Thread.sleep(100);
                testLock();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

问题：删除操作缺乏原子性。

在这里插入图片描述

在这里插入图片描述
假设a先抢到资源进行上锁操作，然后进行业务处理，当业务处理完以后， a 进行释放锁， a 先比较 uuid 是否相等，如果相等，但此时 a 设置锁的时间过期了， b 会抢到资源进行上锁，处理业务，这时候 a 会释放 b 的锁

什么是lua脚本 在这里插入图片描述

https://www.w3cschool.cn/lua/

优化之LUA脚本保证删除的原子性

@GetMapping("testLockLua")
public void testLockLua() {
    //1 声明一个uuid ,将做为一个value 放入我们的key所对应的值中
    String uuid = UUID.randomUUID().toString();
    //2 定义一个锁：lua 脚本可以使用同一把锁，来实现删除！
    String skuId = "25"; // 访问skuId 为25号的商品 100008348542
    String locKey = "lock:" + skuId; // 锁住的是每个商品的数据

    // 3 获取锁
    Boolean lock = redisTemplate.opsForValue().setIfAbsent(locKey, uuid, 3, TimeUnit.SECONDS);

    // 第一种： lock 与过期时间中间不写任何的代码。
    // redisTemplate.expire("lock",10, TimeUnit.SECONDS);//设置过期时间
    // 如果true
    if (lock) {
        // 执行的业务逻辑开始
        // 获取缓存中的num 数据
        Object value = redisTemplate.opsForValue().get("num");
        // 如果是空直接返回
        if (StringUtils.isEmpty(value)) {
            return;
        }
        // 不是空 如果说在这出现了异常！ 那么delete 就删除失败！ 也就是说锁永远存在！
        int num = Integer.parseInt(value + "");
        // 使num 每次+1 放入缓存
        redisTemplate.opsForValue().set("num", String.valueOf(++num));
        /*使用lua脚本来锁*/
        // 定义lua 脚本
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
        // 使用redis执行lua执行
        DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
        redisScript.setScriptText(script);
        // 设置一下返回值类型 为Long
        // 因为删除判断的时候，返回的0,给其封装为数据类型。如果不封装那么默认返回String 类型，
        // 那么返回字符串与0 会有发生错误。
        redisScript.setResultType(Long.class);
        // 第一个要是script 脚本 ，第二个需要判断的key，第三个就是key所对应的值。
        redisTemplate.execute(redisScript, Arrays.asList(locKey), uuid);
    } else {
        // 其他线程等待
        try {
            // 睡眠
            Thread.sleep(1000);
            // 睡醒了之后，调用方法。
            testLockLua();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Lua 脚本详解：

在这里插入图片描述

项目中正确使用：
在这里插入图片描述

在这里插入图片描述

总结

在这里插入图片描述
在这里插入图片描述

一些有名气的博客

三种实现分布式锁的方式

https://blog.youkuaiyun.com/wuzhiwei549/article/details/80692278?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522165268614116782388084541%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=165268614116782388084541&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2allfirst_rank_ecpm_v1~hot_rank-2-80692278-null-null.142v9control,157v4control&utm_term=Java%E5%88%86%E5%B8%83%E5%BC%8F%E9%94%81&spm=1018.2226.3001.4187

Java分布式锁（一行代码搞定） 里面有模板方法

https://blog.youkuaiyun.com/mayongzhan_csdn/article/details/80748914?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522165268614116782388084541%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=165268614116782388084541&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2allfirst_rank_ecpm_v1~hot_rank-12-80748914-null-null.142v9control,157v4control&utm_term=Java%E5%88%86%E5%B8%83%E5%BC%8F%E9%94%81&spm=1018.2226.3001.4187

Java分布式锁

https://blog.youkuaiyun.com/qq_42891281/article/details/107729595

Java分布式锁（6种实现方法）

https://blog.youkuaiyun.com/qq_40873718/article/details/105888915

Java实现分布式锁的三种方式

https://blog.youkuaiyun.com/qq_43640119/article/details/123778284?spm=1001.2101.3001.6650.6&utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromBaidu%7Edefault-6-123778284-blog-107729595.pc_relevant_default&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromBaidu%7Edefault-6-123778284-blog-107729595.pc_relevant_default&utm_relevant_index=8

Java分布式锁,搞懂分布式锁实现看这篇文章就对了

https://www.cnblogs.com/toutou/p/java_lock.html

Zookeeper 分布式锁 - 图解 - 秒懂

https://blog.youkuaiyun.com/crazymakercircle/article/details/85956246?spm=1001.2014.3001.5506

什么是分布式锁？实现分布式锁的三种方式

https://www.cnblogs.com/liuqingzheng/p/11080501.html#!comments

Java分布式锁

https://blog.youkuaiyun.com/qq_35549286/article/details/119948699

妃宫千早
关注
基于Redis方式实现分布式锁
09-24
基于Redis方式实现分布式锁
C#实操控制并发之Lock和Redis分布式锁
01-21
本文将深入探讨C#中如何使用Lock和Redis分布式锁来解决并发问题，以秒杀系统为例进行阐述。 首先，让我们理解什么是并发控制。并发控制是指在多线程环境下确保数据的一致性和完整性，防止多个线程同时访问同一资源...
redis 分布式锁
qiyue683209的博客
12-19 293
最近抽空优化了之前已有的redis分布式锁，主要用于解决高并发的问题，比如抢红包，多个人同时操作红包库存，当在库存只剩下1个的时候，一个人的减库存的操作事务没提交，另一个人的查库存操作刚好同步执行，这样就会出现很尴尬的事情，1个红包会被2个人抢走，这个时候，我们就要依托锁，将请求入口锁住，当然锁有很多种方式，这边就记录一下比较好用的redis分布式锁。  方式有很多setNX 、set、incr...
Redis如何实现分布式锁
最新发布
m0_62960816的博客
04-18 1082
在单体应用中，如果我们对共享数据不进行加锁操作，会出现数据一致性问题，我们的解决办法通常是加锁。在分布式架构中，我们同样会遇到数据共享操作问题，本文章使用Redis来解决分布式架构中的数据一致性问题。
【Redis】分布式锁
qq_39921135的博客
08-06 1673
经过上节课的演示，可以发现在集群模式下synchronized锁失效了，synchronized只能保证单个JVM内部的多个线程之间的互斥，而没有办法让我们集群下的多个JVM进程之间互斥，要想解决这个问题，我们必须使用分布式锁。
redis中的分布式锁
2401_86218127的博客
10-16 656
分布式锁是一个多节点共享的同步机制，通过在多个节点之间协调访问资源，只有获取了分布式锁的节点才能访问和操作关键数据，避免了多节点同时访问操作。如果单纯只是通过setnx的添加和delete的删除来完成分布式锁的获取和释放，那可能存在一个问题就是业务逻辑中出现异常，导致无法执行释放锁的逻辑，就会造成死锁。在上述逻辑中，如果节点刚获取到锁，还没来得及给添加的键值对设定有效期就发生了异常，那么上述的解决方案仍无法解决因无法执行释放锁的逻辑造成死锁的问题。
Redis(九) - Redis之分布式锁
及时当勉励，岁月不待人
07-27 9866
Redis(九) - Redis之分布式锁
redis分布式锁工具包，提供纯Java方式调用，支持传统Spring工程.zip
02-08
综上所述，这个压缩包提供的Redis分布式锁工具包为Java开发者提供了一种简单、高效的方法来解决分布式环境下的锁问题，特别适合于处理高并发的快应用和企业级应用。通过集成到Spring工程中，开发人员可以利用Redis的...
Java Redis分布式锁的正确实现方式详解
08-25
Java Redis分布式锁的正确实现方式详解 Java Redis分布式锁是指使用Redis实现的分布式锁机制，旨在解决分布式系统中的并发问题。分布式锁有三种实现方式：数据库乐观锁、基于Redis的分布式锁和基于ZooKeeper的...
浅析Redis分布式锁
12-16
前期考虑的方案有采用ZooKeeper分布式任务,Quartz分布式任务调度,但是由于Zookeeper需要增加额外组件,Quartz需要增加表,并且项目中现在已经有Redis这一组件存在,所以考虑采用Redis分布式锁的情况来完成分布式任务...
Redis分布式锁的实现方式(redis面试题)
09-08
以下我们将详细讨论Redis分布式锁的正确实现方式以及常见的错误实践。 正确实现Redis分布式锁需要考虑以下几个关键点： 1. **互斥性**：同一时刻，只有一个客户端能够持有锁。Redis提供了`SETNX`（Set if Not ...
Redis之分布式锁
猎户星座
10-31 927
# 基于 Redis 实现分布式锁的三种方案 用 Redis 实现分布式锁的正确姿势（实现一） 用 Redisson 实现分布式可重入锁（RedissonLock）（实现二） 用 Redisson 实现分布式锁(红锁 RedissonRedLock)（实现三） 本文主要探讨基于 Redis 实现分布式锁的方案，主要分析并对比了以上三种方案，并大致分析了 Redisson 的 Redisson...
redis的分布式锁
qiulinsama的博客
12-28 623
Distributed locks with Redis   Distributed locks are a very useful primitive in many environments where different processes must operate with shared resources in a mutually exclusive way.   分布式锁在很多场...
Redis——分布式锁
qq_61350148的博客
12-30 1628
从互斥锁的必要性开始，讲解了Redis如何实现分布式锁，以及如何使用Redisson提供的分布式锁和它的优点。此外，还介绍了对于Redis集群应该如何保证分布式锁的正确性。
Redis的分布式锁
m0_58524181的博客
09-22 756
Redis的分布式锁
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值