Redis分布式锁的正确实现方式（Java版）

已于 2022-06-23 15:52:09 修改
阅读量3.4k 收藏 32
点赞数 10
分类专栏： Redis 面试 文章标签： redis
于 2022-05-18 19:17:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38568503/article/details/124849072
版权
面试 同时被 2 个专栏收录
56 篇文章 5 订阅
订阅专栏
Redis
16 篇文章 4 订阅
订阅专栏

目录

一、为什么需要分布式锁：

为了保证一个方法在高并发情况下的同一时间只能被同一个线程执行，在传统单体应用单机部署的情况下，可以使用Java并发处理相关的API(如ReentrantLcok或synchronized)进行互斥控制。

但是，随着业务发展的需要，原单体单机部署的系统被演化成分布式系统后，由于分布式系统多线程、多进程并且分布在不同机器上，这将使原单机部署情况下的并发控制锁策略失效，即synchronized在分布式系统中失效了。 为了解决这个问题就需要一种跨JVM的互斥机制来控制共享资源的访问，这就是分布式锁要解决的问题。

二、什么是分布式锁：

分布式锁其实就是，控制分布式系统不同进程共同访问共享资源的一种锁的实现。如果不同的系统或同一个系统的不同主机之间共享了某个临界资源，往往需要互斥来防止彼此干扰，以保证一致性。

我们先来看下，一把靠谱的分布式锁应该有哪些特征：

在这里插入图片描述

三、主流实现分布式锁的技术：

  1. 基于关系型数据库实现的分布式锁：
    利用mysql的乐观锁实现分布式锁（版本号），但是性能完全基于mysql本身，在高并发会直接打垮mysql，用的时候一定要三思！！（由于性能太差，不推荐，也不做后续的对比）
  2. 基于单机redis实现分布式锁：
    redis2.6后 SET指令已经支持nx/px/expire,实现加锁非常简单，也是目前99%中小型公司分布式锁的选择。
  3. 基于redis集群实现的分布式锁：
    为了解决单机redis分布式锁的单点故障及可重入性问题，redis推出了红锁。
  4. 基于zk集群实现的分布式锁：
    利用zk有序的临时节点加上它的watch机制实现分布式锁，它的可靠性最高。

对于以上分布式锁实现的对比：
1. 基于关系数据库的分布式锁，一定要在没有大流量的业务且没有其他资源下才会去选择它；
2. 实现复杂度：2，3，4都有对应的客户端，相应的功能已经都封装好，都非常简单；
3. 可靠性（高–低）：zk集群 > 红锁 > 单机redis；
4. 性能（高–低）：单机redis > 红锁 > zk集群;
5. 成本（高–低）：红锁 > zk集群 > 单机redis；

基于以上的对比，也不难发现为什么99%中小型公司的分布式锁要选择 单机redis。

总结：
在这里插入图片描述

四、Redis分布式锁实现原理：

加锁过程：
redis的加锁就是给Key键设置一个值，且key存在时则不能设置成功，为避免死锁，并给定一个过期时间，
且在redis 2.6 后SET指令已经支持nx/px/expire，它能保证设置key和给key加过期时间的原子性。

具体实现：
SET(key,value,NX,PX,time)
其中 key 就是要锁定的资源；value 可以是客户端唯一标识；NX代表只在键不存在时，
才对键进行设置操作；PX 表示对这个key要设置过期时间 ；time 表示key过期的具体时间。

解锁过程：
就是删除掉key来释放资源，但是不能乱删除，需要通过判断key中的value和当前客户端标识一致时才能删除，且整个过程要保证它的原子性。

1.为什么解锁过程要保证原子性呢？
举例说明一下如果解锁过程没有保证原子性的问题，当v1客户端进来拿到锁了，当它准备解锁时在判断客户端标识时拿到value是v1即客户端标识一致，
此时刚好它加锁的key过期了，同时v2客户端加锁成功了，则v1会删除属于v2的key，这种情况下就属于误删，则解锁的过程必须要保证原子性。

2.那么如何保证加锁过程保证原子性？
使用lua脚本，在lua脚本中的指令可以保证它的原子性执行。（lua脚本也不支持回滚，但可以手动回滚）

解锁的lua脚本如下：
-------------------------------------------------------
if redis.call('get',KEYS[1]) == ARGV[1] then 
   return redis.call('del',KEYS[1]) 
else
   return 0 
end
-------------------------------------------------------

五、Redis分布式锁的演化升级：

redis分布式锁的实现原理图：
在这里插入图片描述

在这里插入图片描述

redis分布式锁的使用场景：

多个服务间+保证同一时刻+同一个用户只能有一个请求（防止关键业务出现数据冲突和并发错误）

代码演示redis分布式锁：
在这里插入图片描述
创建一个空项目名字叫redis:

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

1.在空项目创建两个子springboot模块：

boot_redis01
boot_redis02：boot_redis02是完全复制的模块一

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

2.改pom:

common-pool2的对象池依赖：这个依赖必须有，因为RedisCong配置类需要用到：

我们在服务器开发的过程中，往往会有一些对象，它的创建和初始化需要的时间比较长，比如数据库连接，网络IO，大数据对象等。在大量使用这些对象时，如果不采用一些技术优化，就会造成一些不可忽略的性能影响。一种办法就是使用对象池，每次创建的对象并不实际销毁，而是缓存在对象池中，下次使用的时候，不用再重新创建，直接从对象池的缓存中取即可。为了避免重新造轮子，我们可以使用优秀的开源对象池化组件apache-common-pool2，它对对象池化操作进行了很好的封装，我们只需要根据自己的业务需求重写或实现部分接口即可，使用它可以快速的创建一个方便，简单，强大对象连接池管理类。

使用common-pool2的对象池技术的一个完美例子就是redis的Java客户端JedisPool。

综上所述，使用common-pool2可以快速的创建一个安全，强大，简单的对象池管理类。它的开源性使它的功能得到了众多项目的检测，是非常安全的。在我们的业务中，如果有需要使用对象池化的操作，可以使用common-pool2快速实现。

jedis依赖：
Jedis是一个jar包，是Redis官方推荐的用于java访问redis的客户端，主要是用来帮助连接使用数据库。Java项目使用Redis数据库，新版的默认是lettuce客户端，如果要使用jedis客户端，需要先排除lettuce，然后添加jedis客户端。
如果是Maven项目，在pom.xml文件中添加下面两种支持：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <exclusions>
        <exclusion>
            <groupId>io.lettuce</groupId>
            <artifactId>lettuce-core</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.9.0</version>
</dependency>

引入redisson依赖,此依赖先暂时不添加，后边测试redisson的时候再添加。
由于我们是springboot整合redisson，所以我们只需引入springboot-redisson-starter就可以了，
不过这里需要注意springboot与redisson的版本，因为官方推荐redisson版本与springboot版本配合使用。

将 Redisson 与 Spring Boot 库集成。取决于Spring Data Redis模块，支持 Spring Boot 1.3.x - 2.4.x

这句话是官方说的，不过现在的2.5.x也是支持的，只需要注意springboot最低版本不要低于1.3.x即可。

     <dependency>
         <groupId>org.redisson</groupId>
         <artifactId>redisson-spring-boot-starter</artifactId>
         <version>3.15.6</version>
     </dependency>

也可以添加这个依赖：

<!--redisson本次测试用的这个依赖-->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.12.0</version>
        </dependency>

总的pom:
这里注意：common-pool2不要写自己规定的版本号。springboot会进行自动版本协调的。
这里使用最新的springboot2.7

<dependencies>
        <!--web+actuator-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--spring-boot-starter-actuator
        自动配置模块用于支持 SpringBoot 应用的监控-->
        <!--spring-boot-starter-actuator
        可以用于检测系统的健康情况、当前的Beans、系统的缓存等-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

        <!--redis-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <!--新版的默认是lettuce客户端，如果要使用旧的jedis客户端，就排除lettuce-->
            <!--<exclusions>
                <exclusion>
                    <groupId>io.lettuce</groupId>
                    <artifactId>lettuce-core</artifactId>
                </exclusion>
            </exclusions>-->
        </dependency>
        <!--jedis客户端，jedis版本不能太高-->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.7.3</version>
        </dependency>
        <!-- spring2.X集成redis所需common-pool2-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
            <!--这里注意，千万不能自己写版本号，会出现冲突-->
        </dependency>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

3.写yml:

这里使用Lettuce 客户端的连接池：
在这里插入图片描述

server.port=1111

#redis
#Redis服务器地址
spring.redis.host=192.168.211.210

#Redis数据库索引（默认为0）
spring.redis.dataabase=0

#Redis服务器连接端口
spring.redis.port=6379

# Redis服务器连接密码（默认为空）
spring.redis.password=
# 连接池最大连接数（使用负值表示没有限制） 默认 8
spring.redis.lettuce.pool.max-active=500
# 连接池最大阻塞等待时间（使用负值表示没有限制） 默认 -1
spring.redis.lettuce.pool.max-wait=-1
# 连接池中的最大空闲连接 默认 8
spring.redis.lettuce.pool.max-idle=8
# 连接池中的最小空闲连接 默认 0
spring.redis.lettuce.pool.min-idle=0
#连接超时时间（毫秒）
spring.redis.timeout=1800000

4.主启动类：自动生成的

在这里插入图片描述

5.配置类conf.RedisConfig：
**添加redis配置类:**如果出现报错，也可以启动运行的话，不用管爆红。

package com.csdn.springboot_redis.conf;
 
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
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 {
 
 //这里也可以使用RedisConnectionFactory factory
    @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.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;
    }
}

在这里插入图片描述

redis1.0版本：不使用锁

6.controller:

package com.fan.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

@RestController
public class GoodsController {
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Value("${server.port}")
    private String serverPort;

    @GetMapping("/buy")
    public String buy_Goods(){
        System.out.println("test");
        String result = stringRedisTemplate.opsForValue().get("goods:001");
        int goodsNum = result == null ? 0 : Integer.parseInt(result);
        if(goodsNum > 0){
            int realNum = goodsNum - 1;//卖出一个商品
            stringRedisTemplate.opsForValue().set("goods:001",String.valueOf(realNum));
            System.out.println("成功买到商品，库存还剩下："
                    +realNum+"件，\t 服务提供的端口:"+ serverPort);
            return "成功买到商品，库存还剩下："
                    +realNum+"件，\t 服务提供的端口:"+ serverPort;
        }else{
            System.out.println("商品卖完了！！！\t 服务提供的端口:"+ serverPort);
        }

        return "商品卖完了！！！\t 服务提供的端口:"+ serverPort;
    }

    @GetMapping("/redis")
    public String test01(){
        stringRedisTemplate.opsForValue().set("name","tom");
        String name = (String)stringRedisTemplate.opsForValue().get("name");
        return name;
    }


}

同样，创建第二个微服务，在父工程下包含两个微服务模块；

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

package com.fan.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

@RestController
public class GoodsController {
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Value("${server.port}")
    private String serverPort;

    @GetMapping("/buy")
    public String buy_Goods() {
        System.out.println("test");
        String result = stringRedisTemplate.opsForValue().get("goods:001");
        int goodsNum = result == null ? 0 : Integer.parseInt(result);
        if (goodsNum > 0) {
            int realNum = goodsNum - 1;//卖出一个商品
            stringRedisTemplate.opsForValue().set("goods:001", String.valueOf(realNum));
            System.out.println("成功买到商品，库存还剩下："
                    + realNum + "件，\t 服务提供的端口:" + serverPort);
            return "成功买到商品，库存还剩下："
                    + realNum + "件，\t 服务提供的端口:" + serverPort;
        } else {
            System.out.println("商品卖完了！！！\t 服务提供的端口:" + serverPort);
        }

        return "商品卖完了！！！\t 服务提供的端口:" + serverPort;
    }

    @GetMapping("/redis")
    public String test01() {
        stringRedisTemplate.opsForValue().set("name", "tom");
        String name = (String) stringRedisTemplate.opsForValue().get("name");
        return name;
    }


}

后台启动redis;
同时启动两个微服务：view—>Tool Windows -->Servers 调动微服务同时运行的窗口。
在这里插入图片描述

然后点击加号运行选择springboot 类型。然后运行项目；

启动两个微服务，并测试：

在这里插入图片描述

在这里插入图片描述
单机版的2种锁的主要区别：sync和Lock,
sync容易造成线程的积压，而Lock可以进行tryLock的判断，并且可以约定等待时间，到时间后放弃抢锁。

在这里插入图片描述

redis2.0版本：使用单机版锁

其他配置 不变。这里修改controller即可：
这里2.0版本我们增加了锁来防止高并发，但是是单机锁synchronized或者是Lock。

代码：

package com.fan.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

@RestController
public class BuyController {
    @Value("${server.port}")
    private String serverPort;
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @GetMapping("/buy")
    public String buy(){
        synchronized (this){

            String s = stringRedisTemplate.opsForValue().get("goods:001");
            int count = s == null? 0 :Integer.parseInt(s);
            if(count > 0){
                int realCount = count - 1;
                stringRedisTemplate.opsForValue().set("goods:001",String.valueOf(realCount ));
                System.out.println("剩余商品为："+realCount +",提供服务的端口号："+serverPort);
                return "剩余商品为："+realCount +",提供服务的端口号："+serverPort;
            }else{
                System.out.println("商品售罄！！");
            }
            return "商品售罄！！";
        }
    }
}

在这里插入图片描述

在这里插入图片描述

这里为了演示抢锁和超卖的问题，我们设置了nginx来进行负载均衡：
在这里插入图片描述

修改nginx的配置文件：

cd /usr/local/nginx/conf
ll
vim nginx.conf
启动：cd /usr/local/nginx/sbin --> ./nginx
重启：cd /usr/local/nginx/sbin --> ./nginx -s reload

在这里插入图片描述

在这里插入图片描述

192.168.211.210 是nginx所在的linux机器的ip地址；

在这里插入图片描述

使用Jmeter来进行压测，测试高并发问题：

在这里插入图片描述

在这里插入图片描述
发现出现了超卖和重票的并发问题；所以说单机版的锁不能解决分布式的高并发问题的。

redis3.0版本：使用redis的setnx

stringRedisTemplate.opsForValue().setIfAbsent相当于setnx

在这里插入图片描述

package com.fan.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.UUID;

@RestController
public class BuyController {
    @Value("${server.port}")
    private String serverPort;
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @GetMapping("/buy")
    public String buy(){

        String key = "redis_lock";
        String value = UUID.randomUUID().toString()+Thread.currentThread().getName();
        //设置锁
        Boolean flagLock = stringRedisTemplate.opsForValue().setIfAbsent(key, value);
        if(!flagLock){
            return "抢锁失败";
        }
        //抢锁成功后的业务操作：
        String s = stringRedisTemplate.opsForValue().get("goods:001");
        int count = s == null? 0 :Integer.parseInt(s);
        if(count > 0){
            int realCount = count - 1;
            stringRedisTemplate.opsForValue().set("goods:001",String.valueOf(realCount ));
            System.out.println("剩余商品为："+realCount +",提供服务的端口号："+serverPort);
            //操作完毕，释放锁,在return前释放
            stringRedisTemplate.delete(key);
            return "剩余商品为："+realCount +",提供服务的端口号："+serverPort;
        }else{
            System.out.println("商品售罄！！");
        }
        return "商品售罄！！";

    }
}

3.0版本的问题：
在这里插入图片描述
使用try-finally封装代码：
在这里插入图片描述

在这里插入图片描述

redis4.0版本：使用try-finally来释放锁：

4.0版本存在的问题：

在这里插入图片描述

package com.fan.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.UUID;

@RestController
public class BuyController {
    @Value("${server.port}")
    private String serverPort;
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @GetMapping("/buy")
    public String buy(){

        String key = "redis_lock";
        String value = UUID.randomUUID().toString()+Thread.currentThread().getName();
        //设置锁
        try {
            Boolean flagLock = stringRedisTemplate.opsForValue().setIfAbsent(key, value);
            if(!flagLock){
                return "抢锁失败";
            }
            //抢锁成功后的业务操作：
            String s = stringRedisTemplate.opsForValue().get("goods:001");
            int count = s == null? 0 :Integer.parseInt(s);
            if(count > 0){
                int realCount = count - 1;
                stringRedisTemplate.opsForValue().set("goods:001",String.valueOf(realCount ));
                System.out.println("剩余商品为："+realCount +",提供服务的端口号："+serverPort);
                //操作完毕，释放锁,在return前释放
                return "剩余商品为："+realCount +",提供服务的端口号："+serverPort;
            }else{
                System.out.println("商品售罄！！");
            }
            return "商品售罄！！";
        } finally {
            stringRedisTemplate.delete(key);
        }

    }
}

redis5.0版本：对redis的锁有过期时间的设定：

注意，此处的是单独一行设置过期时间：
在这里插入图片描述

 @GetMapping("/buy")
    public String buy(){

        String key = "redis_lock";
        String value = UUID.randomUUID().toString()+Thread.currentThread().getName();
        //设置锁
        try {
            Boolean flagLock = stringRedisTemplate.opsForValue().setIfAbsent(key, value);
            //单独一行设置过期时间
            stringRedisTemplate.expire(key,10L, TimeUnit.SECONDS);
            if(!flagLock){
                return "抢锁失败";
            }
            //抢锁成功后的业务操作：
            String s = stringRedisTemplate.opsForValue().get("goods:001");
            int count = s == null? 0 :Integer.parseInt(s);
            if(count > 0){
                int realCount = count - 1;
                stringRedisTemplate.opsForValue().set("goods:001",String.valueOf(realCount ));
                System.out.println("剩余商品为："+realCount +",提供服务的端口号："+serverPort);
                //操作完毕，释放锁,在return前释放
                return "剩余商品为："+realCount +",提供服务的端口号："+serverPort;
            }else{
                System.out.println("商品售罄！！");
            }
            return "商品售罄！！";
        } finally {
            stringRedisTemplate.delete(key);
        }

    }

在这里插入图片描述

5.0存在的问题：设置key+过期时间分开了，不具备原子性；

redis6.0版本：对redis的锁有过期时间的设定具有原子性：

在这里插入图片描述
将过期时间和锁的设置放在一行：

@GetMapping("/buy")
    public String buy(){

        String key = "redis_lock";
        String value = UUID.randomUUID().toString()+Thread.currentThread().getName();
        //设置锁
        try {
            Boolean flagLock = stringRedisTemplate.opsForValue().
                    setIfAbsent(key, value,10L,TimeUnit.SECONDS);
            //单独一行设置过期时间
            //stringRedisTemplate.expire(key,10L, TimeUnit.SECONDS);
            if(!flagLock){
                return "抢锁失败";
            }
            //抢锁成功后的业务操作：
            String s = stringRedisTemplate.opsForValue().get("goods:001");
            int count = s == null? 0 :Integer.parseInt(s);
            if(count > 0){
                int realCount = count - 1;
                stringRedisTemplate.opsForValue().set("goods:001",String.valueOf(realCount ));
                System.out.println("剩余商品为："+realCount +",提供服务的端口号："+serverPort);
                //操作完毕，释放锁,在return前释放
                return "剩余商品为："+realCount +",提供服务的端口号："+serverPort;
            }else{
                System.out.println("商品售罄！！");
            }
            return "商品售罄！！";
        } finally {
            stringRedisTemplate.delete(key);
        }

    }

在这里插入图片描述
6.0版本存在的问题：锁的误删除

在这里插入图片描述

在这里插入图片描述

redis7.0版本：对redis的锁删除不进行误删

在这里插入图片描述

 @GetMapping("/buy")
    public String buy(){

        String key = "redis_lock";
        String value = UUID.randomUUID().toString()+Thread.currentThread().getName();
        //设置锁
        try {
            Boolean flagLock = stringRedisTemplate.opsForValue().
                    setIfAbsent(key, value,10L,TimeUnit.SECONDS);
            //单独一行设置过期时间
            //stringRedisTemplate.expire(key,10L, TimeUnit.SECONDS);
            if(!flagLock){
                return "抢锁失败";
            }
            //抢锁成功后的业务操作：
            String s = stringRedisTemplate.opsForValue().get("goods:001");
            int count = s == null? 0 :Integer.parseInt(s);
            if(count > 0){
                int realCount = count - 1;
                stringRedisTemplate.opsForValue().set("goods:001",String.valueOf(realCount ));
                System.out.println("剩余商品为："+realCount +",提供服务的端口号："+serverPort);
                //操作完毕，释放锁,在return前释放
                return "剩余商品为："+realCount +",提供服务的端口号："+serverPort;
            }else{
                System.out.println("商品售罄！！");
            }
            return "商品售罄！！";
        } finally {
            //防止锁的误删除，这里进行判断,后删除锁
            if(stringRedisTemplate.opsForValue().get(key).equals(value)){
                stringRedisTemplate.delete(key);
            }
        }

    }

redis8.0版本：lua脚本保证原子性：

在Redis的set命令介绍中，最后推荐Lua脚本进行锁的删除:

lua脚本：https://redis.io/commands/set/

if redis.call("get",KEYS[1]) == ARGV[1]
then
    return redis.call("del",KEYS[1])
else
    return 0
end

工具类RedisUtil ：
在这里插入图片描述

package com.fan.utils;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import java.util.Set;

public class RedisUtil {
	//实例

	//得到jedisPool
	private static JedisPool jedisPool;

	static {
		JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
		jedisPoolConfig.setMaxTotal(20);//最大连接数
		jedisPoolConfig.setMaxIdle(10);//空闲连接数

		//创建一个jedis，连接redis服务器
		jedisPool = new JedisPool(jedisPoolConfig,"192.168.211.210",6379,2*1000);
	}

	//得到jedis对象
	public static Jedis getJedis() throws Exception {
		if(null != jedisPool){
			return jedisPool.getResource();
		}
		throw new Exception("jedisPool is not ok");
	}

	//关闭jedis对象
	public void closeJedis(Jedis jedis){
		if (jedis != null){
			jedis.close();
		}
	}
	//获取某个键的值
	public String get(String key) throws Exception {
		Jedis jedis = getJedis();
		String value = jedis.get(key);
		closeJedis(jedis);
		return value;
	}
	//拿到所有键的集合
	public Set<String> keys(String key) throws Exception {
		Jedis jedis = getJedis();
		Set<String> keys = jedis.keys(key);
		closeJedis(jedis);
		return keys;

	}

}

脚本代码：
在这里插入图片描述

package com.fan.controller;

import com.fan.config.RedisUtil;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import redis.clients.jedis.Jedis;

import javax.annotation.Resource;
import java.util.Collections;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
@RestController
public class buyController {

    @Resource
    private StringRedisTemplate stringRedisTemplate;
    @Value("${server.port}")
    private String serverPort;
    @GetMapping("/buy")
    public String buy() throws Exception {

        String key = "redis_lock";
        String value = UUID.randomUUID().toString()+Thread.currentThread().getName();
        //设置锁
        try {
            Boolean flagLock = stringRedisTemplate.opsForValue().
                    setIfAbsent(key, value,10L, TimeUnit.SECONDS);
            if(!flagLock){
                return "抢锁失败";
            }
            //抢锁成功后的业务操作：
            String s = stringRedisTemplate.opsForValue().get("goods:001");
            int count = s == null? 0 :Integer.parseInt(s);
            if(count > 0){
                int realCount = count - 1;
                stringRedisTemplate.opsForValue().set("goods:001",String.valueOf(realCount));
                System.out.println("剩余商品为："+realCount+",提供服务的端口号："+serverPort);
                //操作完毕，释放锁,在return前释放
                return "剩余商品为："+realCount+",提供服务的端口号："+serverPort;
            }else{
                System.out.println("商品售罄！！");
            }
            return "商品售罄！！";
        } finally {

            Jedis jedis = null;
            try{
                //获取jedis实例
                jedis = RedisUtil.getJedis();

                String script = "if redis.call('get',KEYS[1]) == ARGV[1] " +
                        "then " +
                        "return redis.call('del',KEYS[1]) " +
                        "else " +
                        "   return 0 " +
                        "end";

                Object eval = jedis.eval(script,
                        Collections.singletonList(key),
                        Collections.singletonList(value));
                if("1".equals(eval.toString())){
                    System.out.println("-----del redis lock ok....");
                }else{
                    System.out.println("-----del redis lock error ....");
                }
            }finally {
                if(null != jedis){
                    jedis.close();
                }
            }
        }

    }

}

测试：发现不出出现超卖和重复。

8.1版本：redis事务操作：

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

在这里插入图片描述

redis事务来完成判断删除锁：
在这里插入图片描述

9.0版本：redlock+redisson

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

//注册RedissonClient对象:此bean放到RedisConfig类中：

  //注册RedissonClient对象
    @Bean(destroyMethod="shutdown")
    RedissonClient redisson() throws IOException {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://192.168.211.210:6379");
        RedissonClient redissonClient = Redisson.create(config);
        return redissonClient;
    }

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

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

redisson代码：


import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

@RestController
public class BuyController {
    @Resource
    private StringRedisTemplate stringRedisTemplate;
    @Value("${server.port}")
    private String serverPort;
    @Resource
    private RedissonClient redissonClient;//客户端

    @GetMapping("/buy")
    public String buy(){
        String key = "redis_lock";
        RLock lock = redissonClient.getLock(key);//获取锁
        lock.lock();//加锁
        try {
            //业务放到try中
            String res = stringRedisTemplate.opsForValue().get("goods:001");
            int count = res == null ? 0 :Integer.parseInt(res);
            if(count > 0){
                int realCount = count - 1;//减库存
                //将库存设置到数据库
                stringRedisTemplate.opsForValue().set("goods:001",String.valueOf(realCount));
                System.out.println("剩余库存："+realCount+",服务的端口："+serverPort);
                return "剩余库存："+realCount+",服务的端口："+serverPort;
            }else{
                System.out.println("库存没有了");
            }
            return "库存没有了";
        } finally {
            if(lock.isLocked() && lock.isHeldByCurrentThread()){
                lock.unlock();//解锁
            }
        }
    }

}
这个名字先用着
关注
  • 10
    点赞
  • 踩
  • 32
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
java实现redis分布式锁(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-07 334
java实现redis分布式锁(附完整源码)
C#实操控制并发之Lock和Redis分布式锁
01-21
以下是一个简单的C# Redis分布式锁实现： ```csharp public bool TryAcquireLock(string lockKey, int lockTimeout) { var redis = ConnectionMultiplexer.Connect("localhost:6379"); var db = redis.Get...
redis分布式锁
ycy白米饭的博客
06-24 369
/** * 基于redis分布式锁 */ @Slf4j public class RedisLockUtils { /** * 默认轮休获取锁间隔时间， 单位：毫秒 */ private static final int DEFAULT_ACQUIRE_RESOLUTION_MILLIS = 100; private static final String UNLOCK_LUA; static { StringBuilder...
Java项目对接redis，客户端是选Redisson、Lettuce还是Jedis？
战斧的博客
05-31 5556
在实际的项目开发中，对于一个需要对接Redis的项目来说，就面临着选择合适的Redis客户端。目前比较常用的Redis客户端有Redisson、Lettuce和Jedis，两者都有各自的优点和适用场景，本文将对三者进行比较，并给出选择的建议
Java版基于Redis分布式锁的实现方式
人生若只初相见@的博客
11-26 2万+
一、什么是分布式锁？ 要介绍分布式锁，首先要提到分布式锁相对应的线程锁和进程锁， 线程锁：组要是给方法、代码块加锁，当方法或者代码块使用锁时，在同一时刻只有一个线程可以执行该方法或者代码块，线程锁只在同一个JVM中有效果，因为线程锁实现的根本上是基于线程之间共享内存实现的，比如synchronized是共享对象头，显示锁Lock是共享某个变量（state）。 进程锁：为了控制同一操作系统中多个进程访问某个共享资源，因为进程具有独立性，各个进程无法访问其他进程的资源，因此无法通过synchronized等线程
分布式锁其实很简单，6行代码教你实现redis分布式锁，千万不要再用redisTemplate写redis分布式锁代码实现
小小鱼儿小小林的博客
10-29 6527
分布式锁是一种用于协调分布式系统中多个节点之间对共享资源进行访问控制的机制。它可以确保在分布式环境下，同一时间只有一个节点能够获取到锁，并且其他节点需要等待释放锁后才能获取。以下是使用分布式锁的几个常见场景和原因：避免资源冲突：当多个节点需要同时对共享资源进行读写操作时，使用分布式锁可以确保同一时间只有一个节点能够执行写操作，避免数据冲突和一致性问题。防止重复处理：在某些业务场景中，可能会出现重复处理的问题，例如订单支付、秒杀等。
浅谈Redis分布式锁的正确实现方式
ftfy123的博客
03-24 201
浅谈Redis分布式锁的正确实现方式 这篇文章主要介绍了浅谈Redis分布式锁的正确实现方式，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧 前言 分布式锁一般有三种实现方式：1. 数据库乐观锁；2. 基于Redis的分布式锁；3. 基于ZooKeeper的分布式锁。本篇博客将介绍第二种方式，基于Redis实现分布式锁。虽然网上已经有各种介绍Redis分布式锁实现的博客，然而他们的实现却有着各种各样的问题，为了避免误人子弟，本篇博客将详细介绍如何正确地实现Redis分布式锁
【分布式锁】Redis实现分布式锁
最新发布
qq_39666711的博客
07-23 792
线程1休息的时间超过了过期时间，此时锁会自动释放。此时就会发生蝴蝶效应，线程1删除了线程2的锁，线程2删除了线程3的锁，直到最后一个"哥们：wc，我锁了?最后删除锁的时候，我这里使用了先判断是否是当前处理的服务的本次处理设置的分布式锁，如果是，才删除，否则不让删除其他线程的服务处理产生的锁，这里一定需要注意，否则会产生锁误删的情况，会让分布式锁失效！我们发现，这两个服务虽然单独的看，销售的商品都是正确的，但是放在一起看，就会发现有相同的库存，这就说明，同一个库存被卖了两次，我们上文提到的超卖问题仍然存在！
Redis分布式锁的正确实现方式
OceanSky的专栏
03-19 2065
1.前言 分布式锁一般有三种实现方式： 数据库乐观锁 基于Redis的分布式锁 基于Zookeeper的分布式锁 本文介绍的是基于Redis的分布式锁； 2.可靠性 首先，为了确保分布式锁可用，需要锁至少满足以下四个条件： 互斥性，在任意时刻，只有一个客户端能持有锁。 不会发生死锁，即使有一个客户端在持有锁的期间崩溃而没有主动释放锁，也能保证后续其它客户端能加锁。 具有容错性。只要大部分Re...
Redis分布式锁的实现方式及底层原理
青山师
04-13 1175
在加锁方法中，我们首先生成了一个随机字符串nonce作为锁的值，并在每个Redis实例上进行原子性的set操作，返回成功加锁的实例数。如果获取到锁的实例数大于等于quorum（即多数节点），并且加锁操作完成的时间小于锁的过期时间expireTime，则表示加锁成功，否则认为加锁失败，触发重试机制。Redlock算法采用多个节点之间互斥的方式获取分布式锁，可以保证在大部分节点正常情况下分布式锁的可靠性，并允许在某些更繁忙或网络质量较差的节点上失败，从而确保分布式锁的稳定性。
Redis实现分布式锁
热门推荐
07-27 3万+
分布式锁及实现方案
Java Redis分布式锁的正确实现方式详解
08-25
Java Redis分布式锁的正确实现方式详解 Java Redis分布式锁是指使用Redis实现的分布式锁机制，旨在解决分布式系统中的并发问题。分布式锁有三种实现方式：数据库乐观锁、基于Redis的分布式锁和基于ZooKeeper的...
Redis分布式锁的实现方式(redis面试题)
09-08
以下我们将详细讨论Redis分布式锁的正确实现方式以及常见的错误实践。 正确实现Redis分布式锁需要考虑以下几个关键点： 1. **互斥性**：同一时刻，只有一个客户端能够持有锁。Redis提供了`SETNX`（Set if Not ...
java语言描述Redis分布式锁的正确实现方式
08-28
主要介绍了java语言描述Redis分布式锁的正确实现方式，具有一定借鉴价值，需要的朋友可以参考下。
谈谈Redis分布式锁的正确实现方法
09-09
本文将深入探讨Redis分布式锁的正确实现方法，以及如何避免潜在的问题。 首先，传统的基于`setnx`命令的简单实现存在缺陷。`setnx`命令用于设置键值对，如果键不存在则设置成功，否则失败。这种实现方式可能会导致...
redis分布式锁实现抢单秒杀
07-10
在IT行业中，尤其是在高并发的电子商务系统中，"redis分布式锁实现抢单秒杀"是一个常见的挑战。这个场景模拟了多个用户同时参与秒杀活动，系统需要确保库存的准确性和抢单的公平性，避免超卖和数据不一致的问题。...
Redis分布式锁的正确实现方法总结
12-14
【Redis分布式锁的正确实现方法】 在分布式系统中，数据一致性是至关重要的，而分布式锁作为解决这一问题的关键工具，被广泛应用于并发控制。在众多的分布式锁实现方案中，基于Redis的分布式锁因其简单高效而备受...
Java实现redis分布式锁
07-27
Java实现Redis分布式锁可以通过使用Redis的SETNX命令来实现。SETNX命令可以在Redis中设置一个键值对，但只有在键不存在的情况下才会设置成功。因此，可以将某个键作为锁的标识，当某个线程成功执行SETNX命令并获得锁时，其他线程执行SETNX命令时会失败，从而实现了分布式锁的效果。在释放锁时，可以使用Redis的DEL命令来删除对应的键。 另外，Java中也可以使用显式锁（Lock）来实现分布式锁。通过使用ReentrantLock类，可以在代码中显式地加锁和解锁。在同一个线程中，当外层方法获取锁后，再进入内层方法时会自动获取锁，不会因为之前已经获取过锁而阻塞。这种可重入锁的特性可以一定程度上避免死锁的发生。 总结起来，Java实现Redis分布式锁可以通过使用Redis的SETNX命令或者使用显式锁（Lock）来实现。具体的实现方式可以根据实际需求和场景选择。\[2\]\[3\] #### 引用[.reference_title] - *1* *3* [Java --- redis7实现分布式锁](https://blog.csdn.net/qq_46093575/article/details/130661856)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^koosearch_v1,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* [Redis分布式锁的正确实现方式（Java版）](https://blog.csdn.net/zth_killer/article/details/106853052)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^koosearch_v1,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值