Redis学习总结

文章目录

Redis学习总结
- Radis基本介绍
- docker的安装
- 基本数据结构
- - 通用命令
  - 字符型
  - key的层次结构
  - Hash类型
  - List
  - set
- sortedset集合
- - redis的java客户端
  - - jedis的使用
    - jedis连接池的配置
  - SpringDataRedis
  - 自定义redistemplate的序列化与反序列化方式
  - stringtemplate的使用
- redis实战开发
- - 短信登录
- 缓存
- - 什么是缓存
  - 缓存更新策略
  - 缓存穿透的解决方案
  - 缓存雪崩的问题
  - 缓存击穿
  - 优惠券秒杀
  - 超卖问题
  - 一人一单的问题
  - 分布式锁
  - Redisson操作

Radis基本介绍

Radis是非关系型数据库，常被用作缓存使用。

docker的安装

docker安装redis

基本数据结构

在这里插入图片描述

通用命令

字符型

在这里插入图片描述

key的层次结构

在这里插入图片描述

Hash类型

在这里插入图片描述

List

在这里插入图片描述

set

在这里插入图片描述

案例练习

sortedset集合

在这里插入图片描述

常见命令
zrank默认是升序，其他的也是如此，如果想要降序在z后面添加rev
zrevrank是降序
案例

redis的java客户端

在这里插入图片描述

jedis的使用

引入依赖

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.6.1</version>
</dependency>

建立连接

//         创建jedis对象
        jedis = new Jedis("192.168.253.129",6379);
//         输入连接密码
        jedis.auth("123456");
//        选择数据库
        jedis.select(0);

使用jedis的api，提供的api函数与redis客户端命令一致

//        插入字符串
        jedis.set("name","wangwu");
        System.out.println("name="+jedis.get("name"));

关闭连接

    @AfterEach
    public void after(){
        if (jedis!=null){
            jedis.close();
        }
    }

完整代码

package com.example.dockerfile;

import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;
import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
import org.springframework.boot.test.context.SpringBootTest;
import redis.clients.jedis.Jedis;

@SpringBootTest
class DockerfileApplicationTests {


    private Jedis jedis;
    @Test
    void contextLoads() {
//         创建jedis对象
        jedis = new Jedis("192.168.253.129",6379);
//         输入连接密码
        jedis.auth("123456");
//        选择数据库
        jedis.select(0);
//        插入字符串
        jedis.set("name","wangwu");
        System.out.println("name="+jedis.get("name"));

    }

    @AfterEach
    public void after(){
        if (jedis!=null){
            jedis.close();
        }
    }

}

jedis连接池的配置

public class JedisPoolFactory {
    private static final JedisPool jdedisppool ;

    static {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
//        设置最大连接数
        jedisPoolConfig.setMaxTotal(8);
//设置最大空闲连接数
        jedisPoolConfig.setMaxIdle(8);
//        设置最小空闲连接数
        jedisPoolConfig.setMinIdle(0);
//        如果长时间空闲，连接池中的对象会被清理
//        设置等待时间
//        Duration duration = new Duration(1000);
        jedisPoolConfig.setMaxWaitMillis(1000);
        jdedisppool=new JedisPool(jedisPoolConfig,"192.168.253.129",6379,1000,"123456");

    }

//    获取资源
    public static Jedis getjedis(){
        return jdedisppool.getResource();
    }

}

SpringDataRedis

引入依赖

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

        <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-pool2 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
<!--            <version>2.7.0</version>-->
        </dependency>

配置文件

spring:
  redis:
    host: 192.168.253.129
    port: 6379
    password: 123456
    lettuce:
      pool:
        max-active: 8
        min-idle: 0
        max-idle: 8
        max-wait: 1000

基本使用

@SpringBootTest
public class SpringRedisTest {

    @Resource
    private RedisTemplate redisTemplate;


    @Test
    public void test01(){
        redisTemplate.opsForValue().set("name","lmx");
        System.out.println(redisTemplate.opsForValue().get("name"));
    }
}

自定义redistemplate的序列化与反序列化方式

如果不设置序列化方式，使用原生的redistemplate添加的对象，无法在控制台上获取到，自动实现java对象的序列化与反序列化

@Configuration
public class RedisConfigure {

    @Bean
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory connectionFactory){
//        创建redistemplate对象
        RedisTemplate<String, Object> stringObjectRedisTemplate = new RedisTemplate<>();

//        设置连接工厂
        stringObjectRedisTemplate.setConnectionFactory(connectionFactory);
//        设置json序列化工具
        GenericJackson2JsonRedisSerializer jackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();

//        设置key的序列化方式
        stringObjectRedisTemplate.setKeySerializer(RedisSerializer.string());
        stringObjectRedisTemplate.setHashKeySerializer(RedisSerializer.string());
//        设置值的序列化方式
        stringObjectRedisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        stringObjectRedisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);

        return stringObjectRedisTemplate;
    }
}

stringtemplate的使用

在这里插入图片描述

stringredistemplete使用案例

@SpringBootTest
public class SpringRedisStringTest {

    @Resource
    private StringRedisTemplate stringRedisTemplate;


    @Test
    public void test01(){
        Person person = new Person("李满祥", 18);
        String s = JSONObject.toJSONString(person);

        stringRedisTemplate.opsForValue().set("person",s);
        String person1 = stringRedisTemplate.opsForValue().get("person");
        System.out.println(person1);
        Person person2 = JSONObject.parseObject(person1, Person.class);
        System.out.println(person2);
    }
}

redis实战开发

短信登录

基于session完成
- 流程图
向手机发送验证码功能

@Override
    public Result SendPhone(String phone, HttpSession session) {
        // 校验手机验证码
        if (RegexUtils.isPhoneInvalid(phone)) {
            return Result.fail("手机号格式错误");
        }
        //生成验证码
        String s = RandomUtil.randomNumbers(4);
        log.info("生成的验证码是:" + s);


//        验证码保存在session中
        session.setAttribute(SavePattern.PHONECODE, s);

        return Result.ok();
    }

登录功能

 @Override
    public Result LoginService(LoginFormDTO loginForm, HttpSession session) {


//        校验手机号
        if (RegexUtils.isPhoneInvalid(loginForm.getPhone())){
            return Result.fail("手机号格式错误");
        }
//        校验验证码
        Object sessioncode = session.getAttribute(SavePattern.PHONECODE);
        if (loginForm.getCode()==null || !loginForm.getCode().equals(sessioncode)){
            return Result.fail("验证码错误");
        }
//        数据库中查询用户
        User user = query().eq("phone", loginForm.getPhone()).one();

//        如果没有该用户,插入数据库
        if (user==null){
            user=new User();
            user.setPhone(loginForm.getPhone());
//            随机生成昵称
            String s = RandomUtil.randomString(10);
            user.setNickName("user_"+s);
            save(user);
        }
//        用户信息保存到session中
        UserDTO userDTO = new UserDTO();
        userDTO.setId(user.getId());
        userDTO.setNickName(user.getNickName());
        session.setAttribute(SavePattern.LOGINUSER,userDTO);
        log.info("登录用户的信息已存入session中");
        return  Result.ok();
    }

在拦截器中拦截获取登录状态请求

@Component
public class LoginInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//        return HandlerInterceptor.super.preHandle(request, response, handler);
        HttpSession session = request.getSession();

        UserDTO attribute = (UserDTO) session.getAttribute(SavePattern.LOGINUSER);

//        将用户的信息存入thradlocal中
        if (attribute==null){
            response.setStatus(401);

            return false;
        }
//        不放行;
//        身份不通过
        UserHolder.saveUser(attribute);
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        UserHolder.removeUser();

        //        HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
    }
}

注册拦截器

package com.hmdp.config;

import com.hmdp.controller.interceptor.LoginInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import java.util.ArrayList;

@Configuration
public class Webconfigure implements WebMvcConfigurer {
    @Autowired
    private LoginInterceptor loginInterceptor;
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        ArrayList<String> patterns = new ArrayList<>();
        patterns.add("/user/code");
        patterns.add("/user/login");
        patterns.add("/user/logout");
//        patterns.add("/user/me");
        patterns.add("/shop/**");
        patterns.add("/shop-type/**");
        patterns.add("/upload/**");

        registry.addInterceptor(loginInterceptor).addPathPatterns("/**").excludePathPatterns(patterns);

    }
}

- 集群的session共享问题
使用redis代替session，只要将项目中出现session的地方替换成redis即可，但又以下问题需要注意
- session的过期时间的30分钟，每次访问session都会重置它的过期时间，但是redis中无法自动更新，所以需要手动进行过期时间的更新，例如在前端请求登录状态的时候，后端进行redis的ttl更新操作
- 需要给前端返回在redis中存取值的key，再次选择使用phone存取验证码，后端生成的token存取用户的信息

缓存

什么是缓存

在这里插入图片描述

添加商户缓存

@Override
    public Result queryByid(Long id) {

        String o = "shop:" + id;
        String s = stringRedisTemplate.opsForValue().get(o);

        if (s!=null){
//            缓存有商铺信息
            Shop shop = JSONObject.parseObject(s, Shop.class);
            return Result.ok(shop);
        }

//        如果不存在，数据库中查询
        Shop shop = query().eq("id", id).one();
        if (shop==null){
            return Result.fail("无此商铺信息");
        }

        String shopstring = JSONObject.toJSONString(shop);

        stringRedisTemplate.opsForValue().set(o,shopstring);

        return Result.ok(shop);


    }

缓存更新策略

内存淘汰超时剔除，主动更新

    @Override
    @Transactional
    public Result updateByid(Shop shop) {
//        先做校验
        if (shop == null && shop.getId() == 0L) {
            return Result.fail("商铺信息或商铺id不能为空");
        }
//  更新数据库操作
        updateByid(shop);

//        删除缓存
        stringRedisTemplate.delete(pre+shop.getId());
        
        
        return Result.ok();

    }

缓存穿透的解决方案

在这里插入图片描述

 @Override
    public Result queryByid(Long id) {


        String o = pre + id;
        String s = stringRedisTemplate.opsForValue().get(o);

//        if (s!=null && ){
//            return Result.fail("d店铺不存在");
//        }

        if (s != null) {
//            解决缓存穿透的问题
            if ("".equals(s)){
                return Result.fail("店铺不存在");
            }
//            缓存有商铺信息
            Shop shop = JSONObject.parseObject(s, Shop.class);
            return Result.ok(shop);
        }

//        如果不存在，数据库中查询
        Shop shop = query().eq("id", id).one();
        if (shop == null) {
//            将空对象写入缓存中,解决缓存穿透的问题
            stringRedisTemplate.opsForValue().set(o,"",2L,TimeUnit.MINUTES);// 有效时间是两分钟
            return Result.fail("无此商铺信息");
        }

        String shopstring = JSONObject.toJSONString(shop);

        stringRedisTemplate.opsForValue().set(o, shopstring);
        stringRedisTemplate.expire(o, 30L, TimeUnit.MINUTES);//设置过期时间为30 分钟

        return Result.ok(shop);


    }

缓存雪崩的问题

在这里插入图片描述

缓存击穿

在这里插入图片描述

基于互斥锁的方式

    @Override
    public Result queryByid(Long id) {

//        使用缓存穿透的方法解决
//        Shop shop=getshopWithCatchThrouw(id);
//       解决缓存击穿的问题，使用互斥锁
        String o = pre + id;
        String s = stringRedisTemplate.opsForValue().get(o);

//        if (s!=null && ){
//            return Result.fail("d店铺不存在");
//        }

        if (s != null) {
//            解决缓存穿透的问题
            if ("".equals(s)) {
                return Result.fail("店铺不存在");
            }
//            缓存有商铺信息
            Shop shop = JSONObject.parseObject(s, Shop.class);
            return Result.ok(shop);
        }


        Shop shop = null;

        try {
            boolean getlock = getlock();
            if (!getlock) {
//            进行等待
                Thread.sleep(50);
//            进行重试
                queryByid(id);

            }

            shop = query().eq("id", id).one();

            if (shop == null) {
//            将空对象写入缓存中,解决缓存穿透的问题
                stringRedisTemplate.opsForValue().set(o, "", 2L, TimeUnit.MINUTES);// 有效时间是两分钟
                return Result.fail("店铺不存在");
            }



            String shopstring = JSONObject.toJSONString(shop);
            stringRedisTemplate.opsForValue().set(o, shopstring);
            stringRedisTemplate.expire(o, 30L, TimeUnit.MINUTES);//设置过期时间为30 分钟
        } catch (Exception e) {
            throw new RuntimeException(e.getMessage());
        }finally {
            unlock();
        }

        
        return Result.ok(shop);


    }

    //    得到锁,使用redis的sentnx方法，如果redis中有key，则不会创建，返回false
    public boolean getlock() {
        Boolean aBoolean = stringRedisTemplate.opsForValue().setIfAbsent("lock:shop", "1", 10, TimeUnit.SECONDS);
        return aBoolean;
    }

    //    释放锁
    public void unlock() {
        stringRedisTemplate.delete("lock:shop");

    }

在这里插入图片描述

 private final ExecutorService executorService = Executors.newFixedThreadPool(10);
//    解决缓存击穿的问题，使用逻辑过期的方法
    private Shop getshopWithLogicLock(Long id) {
//        查询缓存中是否有数据
//        如果有数据，则判断是否过期，如果没有过期，直接返回
//        如果已过期，进行缓存重建，返回旧数据

        String o = pre + id;
        String s = stringRedisTemplate.opsForValue().get(o);
//        如果未命中，返回空
        if (s == null) {
            return null;
        }

        RedisData redisData = JSONObject.parseObject(s, RedisData.class);
        LocalDateTime ecpiretime = redisData.getEcpiretime();//过期时间
        JSONObject data = (JSONObject) redisData.getData();
        Shop shop = JSON.toJavaObject(data, Shop.class);
//        过期时间在现在时间之前，说明过期
        if (ecpiretime.isBefore(LocalDateTime.now())) {
//            如果获取到锁进行缓存重建，如果没有则，将其他进程在进行缓存重建，直接放回旧数据
            boolean getlock = getlock();
            if (getlock) {
                executorService.submit(() -> {
                    try {
                        saveshopwithlogic(id, 2L);// 设置过期时间是2秒
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e.getMessage());
                    } finally {
                        unlock();
                    }

                });
            }

        }

        return shop;
    }

注：java中的线程池方法：

 private final ExecutorService executorService = Executors.newFixedThreadPool(10);
 executorService.submit(() -> {
                    try {
                        saveshopwithlogic(id, 2L);// 设置过期时间是2秒
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e.getMessage());
                    } finally {
                        unlock();
                    }

                });

优惠券秒杀

在这里插入图片描述

全局唯一id格式
在这里插入图片描述

@Component
public class RedisOneID {
    //     生成全局唯一id，生成的id 符号位+时间戳+序列号
    private final static long starttime = 1286064000L;

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    public  long getLongId(String pre) {
//         获取当前的时间戳
        long l = LocalDateTime.now().toEpochSecond(ZoneOffset.UTC);
//        long l1 = LocalDateTime.of(2010, 10, 3, 0, 0, 0).toEpochSecond(ZoneOffset.UTC);
//        System.out.println(l1);

//
        long time = l - starttime;

        time=time<<32; //时间戳向左移32=位，空出位置

        String format = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy:MM:dd"));

        Long increment = stringRedisTemplate.opsForValue().increment("ice" + pre + format);// 拼接的字符串

        long l1 = time | increment;
        return l1;
    }



}

超卖问题

在这里插入图片描述

boolean voucher_id = update().setSql(“stock=stock-1”).eq(“voucher_id”, voucherId).eq(“stock”,seckillVoucher.getStock())
通过在更新时判断此时的库存是否与开始查询到的库存一致，如果一致说明未被修改，可以更新

package com.hmdp.service.impl;

import com.hmdp.dto.Result;
import com.hmdp.entity.SeckillVoucher;
import com.hmdp.entity.VoucherOrder;
import com.hmdp.mapper.SeckillVoucherMapper;
import com.hmdp.mapper.VoucherOrderMapper;
import com.hmdp.service.ISeckillVoucherService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hmdp.utils.RedisOneID;
import com.hmdp.utils.UserHolder;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.time.LocalDateTime;

/**
 * <p>
 * 秒杀优惠券表，与优惠券是一对一关系 服务实现类
 * </p>
 *
 * @author 虎哥
 * @since 2022-01-04
 */
@Service
public class SeckillVoucherServiceImpl extends ServiceImpl<SeckillVoucherMapper, SeckillVoucher> implements ISeckillVoucherService {


    @Resource
    private VoucherOrderMapper voucherOrderMapper;
    @Resource
    private RedisOneID redisOneID;

    @Override
    public Result getseckill(Long voucherId) {
//        查询优惠券
        SeckillVoucher seckillVoucher = query().eq("voucher_id", voucherId).one();
//         判断时间是否开始
        boolean after = seckillVoucher.getBeginTime().isAfter(LocalDateTime.now());
        if (after) {
            return Result.fail("抢购时间未开始");

        }
//         查询库存是否够
        if (seckillVoucher.getStock() < 1) {
            return Result.fail("库存不足");
        }


//         更新库存数据 ，判断向前查到的库存与是否发生改变
        boolean voucher_id = update().setSql("stock=stock-1").eq("voucher_id", voucherId).eq("stock",seckillVoucher.getStock())
                .update();
        if (!voucher_id) {
            return Result.fail("库存扣减失败");
        }

        //        插入订单数据
        VoucherOrder voucherOrder = new VoucherOrder();


        long order = redisOneID.getLongId("order");
        voucherOrder.setId(order);

        voucherOrder.setVoucherId(voucherId);

        voucherOrder.setUserId(UserHolder.getUser().getId());

//         插入订单
        voucherOrderMapper.insert(voucherOrder);


        return Result.ok(order);


    }
}

一人一单的问题

在这里插入图片描述

使用添加悲观锁的方法解决
@Transactional
// 给该方法添加事务，事务的提交时机是在方法结束之后才提交，
// 所以需要将synchronized控制块添加当方法的外围，确保在锁中的代码事务提交之后在释放锁
如果不使用intern方法，那么每次synchronized 中的值就是新的string对象，通过intern方法可以获取到常量池中的唯一备份，确保不同线程的同一用户，synchronized中的值相同
使用@transactional注解进行事务管理时，在类内部调用方法时需要通过当前类的代理对象来获取，不能使用this对象直接调用
需要在启动类上添加@EnableAspectJAutoProxy(exposeProxy = true)注解，暴露代理类

//      intern可以获取string常量池中的对象,确保synchronized中锁定的同一个用户
    synchronized (UserHolder.getUser().getId().toString().intern()) {
        ISeckillVoucherService o = (ISeckillVoucherService)AopContext.currentProxy();// @Transactional 对象的原理其实是通过aop代理实现的，
        // 所以在调用方法时需要获取带当前对象的代理对象
        return o.createorder(voucherId,seckillVoucher);
    }

~~~java
@Service
public class SeckillVoucherServiceImpl extends ServiceImpl<SeckillVoucherMapper, SeckillVoucher> implements ISeckillVoucherService {


    @Resource
    private VoucherOrderMapper voucherOrderMapper;
    @Resource
    private RedisOneID redisOneID;

    @Override
    @Transactional
    public Result getseckill(Long voucherId) {

        //        查询优惠券
        SeckillVoucher seckillVoucher = query().eq("voucher_id", voucherId).one();
//         判断时间是否开始
        boolean after = seckillVoucher.getBeginTime().isAfter(LocalDateTime.now());
        if (after) {
            return Result.fail("抢购时间未开始");

        }
//         查询库存是否够
        if (seckillVoucher.getStock() < 1) {
            return Result.fail("库存不足");
        }



//      intern可以获取string常量池中的对象,确保synchronized中锁定的同一个用户
        synchronized (UserHolder.getUser().getId().toString().intern()) {
            ISeckillVoucherService o = (ISeckillVoucherService)AopContext.currentProxy();// @Transactional 对象的原理其实是通过aop代理实现的，
            // 所以在调用方法时需要获取带当前对象的代理对象
            return o.createorder(voucherId,seckillVoucher);
        }


    }


    @Transactional
    // 给该方法添加事务，事务的提交时机是在方法结束之后才提交，
    // 所以需要将synchronized控制块添加当方法的外围，确保在锁中的代码事务提交之后在释放锁

    public Result createorder(Long voucherId,SeckillVoucher seckillVoucher){

        LambdaQueryWrapper<VoucherOrder> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(VoucherOrder::getUserId, UserHolder.getUser().getId()).eq(VoucherOrder::getVoucherId, voucherId);
        List<VoucherOrder> voucherOrders = voucherOrderMapper.selectList(queryWrapper);
        if (voucherOrders == null) {
            return Result.fail("请勿重复抢购");
        }

//         更新库存数据 ，判断向前查到的库存与是否发生改变
        boolean voucher_id = update().setSql("stock=stock-1").eq("voucher_id", voucherId).eq("stock", seckillVoucher.getStock())
                .update();
        if (!voucher_id) {
            return Result.fail("库存扣减失败");
        }

        //        插入订单数据
        VoucherOrder voucherOrder = new VoucherOrder();


        long order = redisOneID.getLongId("order");
        voucherOrder.setId(order);

        voucherOrder.setVoucherId(voucherId);

        voucherOrder.setUserId(UserHolder.getUser().getId());
//        voucherOrder.setUserId(1011L);

//         插入订单
        voucherOrderMapper.insert(voucherOrder);


        return Result.ok(order);
    }
}

分布式锁

在这里插入图片描述

分布式锁方案
基于Redis的分布式锁
其他的线程将不属于自己的锁释放了，造成并发执行，此时的解决方案
在释放锁时通过判断是否是当前线程的标识
解决方案流程图

public class SimpleRedisLock implements Ilock {


    private String name; // 给哪个对象加锁，的名字
    private StringRedisTemplate redisTemplate;
    private final String KEY_PRE = "lock:";
    private final String ID_PRE= UUID.randomUUID().toString().replace("-","")+"-";
    public SimpleRedisLock(String name, StringRedisTemplate redisTemplate) {
        this.name = name;
        this.redisTemplate = redisTemplate;
    }

    /*
     *
     * @Pgrm 尝试获取锁
     * */
    @Override
    public boolean trylocak(Long timeoustSecond) {


        long id = Thread.currentThread().getId(); // 获取当前线程的id值，充当sentnx的vlaue
        String ids=ID_PRE+id;
        Boolean aBoolean = redisTemplate.opsForValue().setIfAbsent(KEY_PRE + name, ids + "", timeoustSecond, TimeUnit.SECONDS);


//        在进行自动拆箱的过程中，可能会返回null对象，导致发生异常
        return Boolean.TRUE.equals(aBoolean);
    }

    @Override
    public void unlock() {
//        判断当前的id值，是否与缓存内存取的id值相等
        long id = Thread.currentThread().getId();
        String ids= ID_PRE+id;
        String s = redisTemplate.opsForValue().get(KEY_PRE + name);

        if (ids.equals(s)){
            redisTemplate.delete(KEY_PRE + name);
        }

    }
}

存在一种极端情况，当判断锁标识是否相等后，这时，线程发生阻塞（由于垃圾回收的原因），这时在阻塞结束后，因为已经判断过，所以不再判断直接删除，安全隐患发生的时机在于判断之后，未删除之前，所以需要将该操作变为原子操作

if (ids.equals(s)){
            redisTemplate.delete(KEY_PRE + name);
        }

在这里插入图片描述

Redisson操作

在这里插入图片描述

引入依赖

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