Redis 黑马点评笔记

最新推荐文章于 2026-06-22 21:37:27 发布

原创最新推荐文章于 2026-06-22 21:37:27 发布 · 636 阅读

16 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#redis #笔记 #数据库 #java

JAVA 专栏收录该内容

17 篇文章

订阅专栏

基于内存的key-value结构数据库

基于内存存储，读写性能高

启动方式

默认启动

在任意目录下输入即可启动

redis-server

启动之后再次启动会报错，6379端口已经被占用，此时需要

ps aux | grep redis

查看一下正在监听6379的pid，然后杀死他

sudo kill 89689//普通终止
sudo kill -9 89689//强行终止

指定配置启动

先进入redis安装目录

cd /usr/local/redis-7.0.0
redis-server redis.conf

开机自启

//新建文件并进入编辑
vi /etc/systemd/system/redis.service

[Unit]
Description=redis-server
After=network.target
[Service]
Type=forking
#前面是redis-server的路径，后面是redis.conf的路径，填错了会无效
ExecStart=/usr/local/redis-7.0.0/src/redis-server /usr/local/redis-7.0.0/redis.conf
PrivateTmp=true
[Install]
WantedBy=multi-user.target
//启动redis
systemctl start redis
//查看是否启动成功
systemctl status redis

开放端口并重启防火墙
firewall-cmd --permanent --add-port=6379/tcp
firewall-cmd --reload

Spring Data Redis

引入依赖

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

配置redis数据源

  redis:
    host: 虚拟机的ip地址
    port: 6379
    password: 123456
    database: 0  #移除此项默认为0

hosthome -I 可查看虚拟机ip地址

配置类

@Configuration
@Slf4j
public class RedisConfiguration {
    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate redisTemplate = new RedisTemplate();
        //设置redis的连接工厂对象
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        //设置redis的key的序列化器
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        return redisTemplate;
    }
}

三种常见客户端

Jedis

以Redis命令作为方法名称，学习成本低，但是线程不安全，多线程下需要使用连接池

Lettuce

基于Netty实现，线程安全，支持同步、异步、响应式编程方式，支持Redis的哨兵模式、集群模式和管道模式

Redisson

基于Redis实现的分布式、可伸缩的Java数据结构集合

Spring DataRedis

对前两种客户端进行了整合

RedisTemplate统一API

哨兵和集群

基于Lettuce的响应式编程

支持json、string、spring对象的序列化和反序列化

快速入门

引入依赖

配置文件

注入RedisTemplate

编写测试

RedisTemplate

接受的任何值都视为java对象，使用jdk默认序列化方式，序列化为字节形式

也可以自己改造

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory){
        // 创建RedisTemplate对象
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        // 设置连接工厂
        template.setConnectionFactory(connectionFactory);
        // 创建JSON序列化工具
        GenericJackson2JsonRedisSerializer jsonRedisSerializer = 
            							new GenericJackson2JsonRedisSerializer();
        // 设置Key的序列化
        template.setKeySerializer(RedisSerializer.string());
        template.setHashKeySerializer(RedisSerializer.string());
        // 设置Value的序列化
        template.setValueSerializer(jsonRedisSerializer);
        template.setHashValueSerializer(jsonRedisSerializer);
        // 返回
        return template;
    }
}

为了节省内存空间，统一使用string序列化器，不使用json。要存储对象时，手动完成序列化和反序列化

短信登录

发送验证码

@Override
    public Result sendCode(String phone, HttpSession session) {
        if(RegexUtils.isPhoneInvalid(phone)){
            return Result.fail("手机号格式错误");
        }
        String code= RandomUtil.randomNumbers(6);
        //session.setAttribute("code",code);
        stringRedisTemplate.opsForValue().set(LOGIN_CODE_KEY
        +phone,code,LOGIN_CODE_TTL, TimeUnit.MINUTES);
        log.debug("发送验证码成功,{}",code);
        return Result.ok();
    }

@Override
    public Result login(LoginFormDTO loginForm, HttpSession session) {
        // 1.校验手机号
        String phone = loginForm.getPhone();
        if (RegexUtils.isPhoneInvalid(phone)) {
            // 2.如果不符合，返回错误信息
            return Result.fail("手机号格式错误！");
        }
        // 3.校验验证码
        Object cacheCode = session.getAttribute("code");
        String code = loginForm.getCode();
        if(cacheCode == null || !cacheCode.toString().equals(code)){
             //3.不一致，报错
            return Result.fail("验证码错误");
        }
        //一致，根据手机号查询用户
        User user = query().eq("phone", phone).one();

        //5.判断用户是否存在
        if(user == null){
            //不存在，则创建
            user =  createUserWithPhone(phone);
        }
        //7.保存用户信息到session中
        session.setAttribute("user",user);

        return Result.ok();
    }

拦截器

双层拦截器，Refresh负责拦截一切，但拦截后只为刷新token，即便未登录也会放行，登录用户则会刷新token，Login负责拦截需要登录的路径，查看Refresh中保存的用户信息，存在则放行，不存在拦截

public class LoginInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
       if(UserHolder.getUser()==null){

           response.setStatus(401);
           return false;
       }
        return true;
    }

 
}

private StringRedisTemplate stringRedisTemplate;

    public RefreshInterceptor(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String token = request.getHeader("authorization");
        if (StrUtil.isBlank(token)) {
            return true;
        }
        Map<Object,Object> usermap=stringRedisTemplate.opsForHash().entries(LOGIN_USER_KEY + token);
        if(usermap.isEmpty()){
            return true;
        }
        UserDTO userDTO = BeanUtil.fillBeanWithMap(usermap, new UserDTO(), false);
        UserHolder.saveUser((UserDTO) userDTO);
        stringRedisTemplate.expire(LOGIN_USER_KEY + token, LOGIN_USER_TTL, TimeUnit.MINUTES);
        return true;
    }

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

    }

public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoginInterceptor())
                .excludePathPatterns(
                        "/shop/**",
                        "/voucher/**",
                        "/shop-type/**",
                        "/upload/**",
                        "/blog/hot",
                        "/user/code",
                        "/user/login"
                ).order(1);
    registry.addInterceptor(new RefreshInterceptor(stringRedisTemplate)).order(0);
    }//优先级，默认拦截一切路径

商户缓存

 @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public Result queryById(Long id) {
        String key = "cache:shop" + id;
        String shopJson=stringRedisTemplate.opsForValue().get(key);
        if(StrUtil.isNotBlank(shopJson)){
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return Result.ok(shop);
        }
        Shop shop=getById( id);
        if(shop==null){
            return Result.fail("店铺不存在");
        }
        stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop));
        return  Result.ok(shop);
    }

缓存更新

内存淘汰：redis内存淘汰机制，内存不足时自动淘汰部分数据，下次查询时更新缓存

超时剔除：设置TTL，到期自动删除

主动更新：编写业务逻辑，修改数据库的同时，更新缓存

数据库缓存不一致通常使用的方案：

Cache Aside Pattern 人工编码方式：缓存调用者在更新完数据库后再去更新缓存，也称之为双写方案

先操作数据库再删除缓存

根据id查询店铺时，如果缓存未命中，则查询数据库，将数据库结果写入缓存，并设置超时时间

根据id修改店铺时，先修改数据库，再删除缓存

@Transactional
    @Override
    public Result updata(Shop shop) {
        Long id = shop.getId();
        if(id==null){
            return Result.fail("店铺id不能为空");
        }
        updateById( shop);
        stringRedisTemplate.delete(CACHE_SHOP_KEY + id);
        return Result.ok();
    }

缓存穿透

请求数据在数据库和缓存中都不存在，缓存永远不会生效

两种解决方案：

缓存空对象

- 优点：实现简单，维护方便
- 缺点：
    * 额外的内存消耗
    * 可能造成短期的不一致，要等""的ttl到期

布隆过滤

Redis的布隆过滤器底层是一个大型位数组（二进制数组）+多个无偏hash函数

在布隆过滤器增加元素之前，首先需要初始化布隆过滤器的空间，也就是上面说的二进制数组，除此之外还需要计算无偏hash函数的个数。布隆过滤器提供了两个参数，分别是预计加入元素的大小n，运行的错误率f。布隆过滤器中有算法根据这两个参数会计算出二进制数组的大小l，以及无偏hash函数的个数k。

- 优点：内存占用较少，没有多余key
- 缺点：
    * 实现复杂
    * 存在误判可能

缓存雪崩

大量key同时失效或者redis宕机，导致请求直击数据库

解决方案：

给不同的Key的TTL添加随机值
利用Redis集群提高服务的可用性：哨兵机制，监测结点，故障转移
给缓存业务添加降级限流策略
给业务添加多级缓存

缓存击穿

也叫热点key问题，一个被高并发访问并且缓存重建任务较复杂的key失效了

常见的解决方案有两种：

互斥锁：

查询缓存未命中，要获取互斥锁，之后再查询数据库，缓存数据，然后释放锁

缺点在于要等并且可能死锁，你要获取的锁已经被其他业务获取

setnx：无key时可写，有则不能写，删除来释放锁

核心思路就是利用redis的setnx方法来表示获取锁，该方法含义是redis中如果没有这个key，则插入成功，返回1，在stringRedisTemplate中返回true，如果有这个key则插入失败，则返回0，在stringRedisTemplate返回false，我们可以通过true，或者是false，来表示是否有线程成功插入key，成功插入的key的线程我们认为他就是获得到锁的线程。

private boolean tryLock(String key) {
    Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
    return BooleanUtil.isTrue(flag);//直接返回可能存在空指针
}

private void unlock(String key) {
    stringRedisTemplate.delete(key);
}

 public Shop queryWithMutex(Long id)  {
        String key = CACHE_SHOP_KEY + id;
        // 1、从redis中查询商铺缓存
        String shopJson = stringRedisTemplate.opsForValue().get("key");
        // 2、判断是否存在
        if (StrUtil.isNotBlank(shopJson)) {
            // 存在,直接返回
            return JSONUtil.toBean(shopJson, Shop.class);
        }
        //判断命中的值是否是空值
        if (shopJson.equals("")) {
            //返回一个错误信息
            return null;
        }
        // 4.实现缓存重构
        //4.1 获取互斥锁
        String lockKey = "lock:shop:" + id;
        Shop shop = null;
        try {
            boolean isLock = tryLock(lockKey);
            // 4.2 判断否获取成功
            if(!isLock){
                //4.3 失败，则休眠重试
                Thread.sleep(50);
                return queryWithMutex(id);
            }
            //4.4 成功，根据id查询数据库
            shop = getById(id);
            // 5.不存在，返回错误
            if(shop == null){
                //将空值写入redis
                stringRedisTemplate.opsForValue().set(key,"",CACHE_NULL_TTL,TimeUnit.MINUTES);
                //返回错误信息
                return null;
            }
            //6.写入redis
            stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop),CACHE_NULL_TTL,TimeUnit.MINUTES);

        }catch (Exception e){
            throw new RuntimeException(e);
        }
        finally {
            //7.释放互斥锁
            unlock(lockKey);
        }
        return shop;
    }

逻辑过期：

把过期时间设置在redis的value中，通过逻辑处理判断是否过期，缓存未命中直接返回空（未命中说明不是热点商品）

注意需要先预缓存

缺点在于在构建完缓存之前，返回的都是脏数据。

 private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);
    public Shop queryWithLogicalExpire(Long id)  {
        String key = CACHE_SHOP_KEY + id;
        // 1、从redis中查询商铺缓存
        String shopJson = stringRedisTemplate.opsForValue().get("key");
        // 2、判断是否存在
        if (StrUtil.isBlank(shopJson)) {
            // 未命中，直接返回，说明并非高并发商品
            return null;
        }
        RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);
        Shop shop = JSONUtil.toBean((JSONObject) redisData.getData(), Shop.class);
        LocalDateTime expireTime = redisData.getExpireTime();
        if(expireTime.isAfter(LocalDateTime.now())){
            // 命中，返回店铺信息
            return shop;
        }
        // 4.实现缓存重构
        //4.1 获取互斥锁
        String lockKey = LOCK_SHOP_KEY + id;
        boolean isLock = tryLock(lockKey);
        if(isLock){
            if(expireTime.isAfter(LocalDateTime.now())) {
                return shop;//doublecheck，存在则无需重建缓存
            }
    CACHE_REBUILD_EXECUTOR.submit(() -> {
        try {//重建缓存
            this.saveShopToRedis(id, 20L);//正常应该长一点，30分钟
        } catch (Exception e) {
            throw new RuntimeException(e);
        }finally {
            unlock(lockKey);
        }

        });
     }

        return shop;
    }

封装Redis工具类

基于StringRedisTemplate封装一个缓存工具类，满足下列需求：

方法1：将任意Java对象序列化为json并存储在string类型的key中，并且可以设置TTL过期时间
方法2：将任意Java对象序列化为json并存储在string类型的key中，并且可以设置逻辑过期时间，用于处理缓

存击穿问题

方法3：根据指定的key查询缓存，并反序列化为指定类型，利用缓存空值的方式解决缓存穿透问题
方法4：根据指定的key查询缓存，并反序列化为指定类型，需要利用逻辑过期解决缓存击穿问题

 public <R,ID> R queryWithPassThrough(
            String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit){//运行时保留泛型信息
        String key = keyPrefix + id;
        // 1.从redis查询商铺缓存
        String json = stringredisTemplate.opsForValue().get(key);
        // 2.判断是否存在
        if (StrUtil.isNotBlank(json)) {
            // 3.存在，直接返回
            return JSONUtil.toBean(json, type);
        }
        // 判断命中的是否是空值
        assert json != null;
        if (json.equals("")) {
            // 返回一个错误信息
            return null;
        }

        // 4.不存在，根据id查询数据库
        R r = dbFallback.apply(id);
        // 5.不存在，返回错误
        if (r == null) {
            // 将空值写入redis
            stringredisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
            // 返回错误信息
            return null;
        }
        // 6.存在，写入redis
        this.set(key, r, time, unit);
        return r;
    }

参数 `Function<ID, R> dbFallback`

这是一个函数式接口，表示“当缓存未命中时，从数据库加载数据的回调函数”。

输入类型是 ID（和方法的 id 参数类型一致）
输出类型是 R（和返回值类型一致）

泛型方法声明：`<R, ID>`

在方法返回类型 R 前面写的 <R, ID> 表示这是一个泛型方法，它引入了两个类型参数（type parameters）：

R：代表返回值的类型（Result 的缩写）
ID：代表传入的 ID 的类型（可以是 Long, String, UUID 等）

参数 `Class<R> type`

这是 Java 中常见的类型令牌（Type Token）模式，用于在运行时保留泛型类型信息。

因为 Java 泛型在编译后会被类型擦除（Type Erasure），运行时无法知道 R 到底是什么类型。
通过传入 Class<R>（如 User.class），可以在运行时使用反射（如 type.newInstance() 或 JSON 反序列化）来创建或转换对象。

优惠券秒杀

全局唯一id

uuid

雪花算法

redis自增

public  long nextId(String keyPrefix){
        //1.生成时间戳
        LocalDateTime now = LocalDateTime.now();
        long nowSecond = now.toEpochSecond(ZoneOffset.UTC);
        long timestamp = nowSecond - BEGIN_TIMESTAMP;
        //2.生成序列号
        String date = now.format(DateTimeFormatter.ofPattern("yyyy:MM:dd"));
        long count=stringRedisTemplate.opsForValue().increment("icr:" + keyPrefix + ":"+ date);
        return timestamp<<COUNT_BITS | count;
    }

 @Test
    void testyouhuiquan() throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(300);
        Runnable task=()->{
            for (int i = 0; i < 100; i++) {
                long id= redisIdWorker.nextId("order");
                System.out.println("id:"+id);
            }
            latch.countDown();

        };
        long start=System.currentTimeMillis();
        for (int i = 0; i < 300; i++){
            executorService.submit( task);
        }
        latch.await();//等待计数结束
       long end=System.currentTimeMillis();
        System.out.println("耗时："+(end-start));
    }
}

优惠券

  @Autowired
    private RedisIdWorker redisIdWorker;
    @Autowired
    private ISeckillVoucherService seckillVoucherService;
    @Override
    public Result seckillVoucher(Long voucherId) {
        //查询
        SeckillVoucher seckillVoucher = seckillVoucherService.getById(voucherId);
        //判断秒杀时间
        if (seckillVoucher.getBeginTime().isAfter(LocalDateTime.now())) {
            return Result.fail("秒杀尚未开始");
        }
        if (seckillVoucher.getEndTime().isBefore(LocalDateTime.now())){
            return Result.fail("秒杀已经结束");
        }
        //检查库存
        if (seckillVoucher.getStock() < 1) {
            return Result.fail("库存不足");
        }
        //扣减库存
        boolean success = seckillVoucherService.update()
                .setSql("stock = stock - 1")
                .eq("voucher_id", voucherId).update();
        if (!success) {
            //扣减库存
            return Result.fail("库存不足！");
        }
        //创建订单
        VoucherOrder voucherOrder = new VoucherOrder();
        long orderId= redisIdWorker.nextId("order");
        voucherOrder.setId(orderId);
        Long userId= UserHolder.getUser().getId();
        voucherOrder.setUserId(userId);
        voucherOrder.setVoucherId(voucherId);
        save(voucherOrder);
        return Result.ok(orderId);
    }

很明显会有并发问题

解决超卖

悲观锁：认为线程安全问题一定会发生，操作前先获取锁，sychronized、lock都属于悲观锁
乐观锁：在更新数据时判断有没有有没有其他线程对数据做修改，被修改了可以重试或异常

CAS：我认为内存值V应该为A，如果为A，将其修改为B，否则什么都不做

自旋锁：基于cas的一种锁策略，获取锁失败后不断循环（自旋），直至成功

//扣减库存
        boolean success = seckillVoucherService.update()
                .setSql("stock = stock - 1")
                .eq("voucher_id", voucherId)
                .gt("stock", 0)
                .update();

一人一单

一人一单是一个插入问题，只能使用悲观锁synchornized

 Long userId = UserHolder.getUser().getId();
        synchronized (userId.toString().intern()) {
            IVoucherOrderService proxy=(IVoucherOrderService) AopContext.currentProxy();
            return proxy.createVoucherOrder(voucherId);
        }

userId.toString().intern()：Long对象值相等并不一定是同一个对象，转换为字符串，再intern从常量池获取字符串引用

Long 是包装类，在自动装箱/拆箱时，JVM 对 -128 到 127 范围内的 Long 值做了缓存（类似 Integer 缓存），但超出这个范围的 Long 每次都会创建新对象。

.intern() 确保：相同内容的字符串在 JVM 字符串常量池中是同一个对象

@EnableAspectJAutoProxy(exposeProxy = true)

在启动类上加入暴露代理注解

分布式锁

Redis利用setnx互斥命令实现互斥锁

public class SimpleRedisLock implements ILock{
    private String name;
    private StringRedisTemplate stringRedisTemplate;
    private final static String KEY_PREFIX = "lock:";
    public SimpleRedisLock(String name, StringRedisTemplate stringRedisTemplate) {
        this.name = name;
        this.stringRedisTemplate = stringRedisTemplate;
    }
    @Override
    public boolean tryLock(long timeoutSec) {
        long id = Thread.currentThread().getId();
        Boolean success=stringRedisTemplate.opsForValue().setIfAbsent(KEY_PREFIX+name,id+"",timeoutSec, TimeUnit.SECONDS);
        //避免自动拆箱返回空指针，null也为false
        return Boolean.TRUE.equals(success);
    }

    @Override
    public void unlock() {
        stringRedisTemplate.delete(KEY_PREFIX+name);
    }
}

误删问题及解决

持有锁的线程在锁的内部出现了阻塞或者超时，导致他的锁自动释放，这时其他线程，线程2来尝试获得锁，就拿到了这把锁，然后线程2在持有锁执行过程中，线程1反应过来，继续执行，而线程1执行过程中，走到了删除锁逻辑，此时就会把本应该属于线程2的锁进行删除

 private String name;
    private StringRedisTemplate stringRedisTemplate;
    private final static String KEY_PREFIX = "lock:";
    private final static String ID_PREFIX = UUID.randomUUID().toString();

    public SimpleRedisLock(String name, StringRedisTemplate stringRedisTemplate) {
        this.name = name;
        this.stringRedisTemplate = stringRedisTemplate;
    }

    @Override
    public boolean tryLock(long timeoutSec) {
        String id = ID_PREFIX + Thread.currentThread().getId();
        Boolean success = stringRedisTemplate.opsForValue().setIfAbsent(KEY_PREFIX + name, id + "", timeoutSec, TimeUnit.SECONDS);
        //避免自动拆箱返回空指针，null也为false
        return Boolean.TRUE.equals(success);
    }

    @Override
    public void unlock() {
        String id = ID_PREFIX + Thread.currentThread().getId();
        if (id.equals(stringRedisTemplate.opsForValue().get(KEY_PREFIX + name))) {
            stringRedisTemplate.delete(KEY_PREFIX + name);
        }
    }

原子性问题及解决

线程1现在持有锁之后，在执行业务逻辑过程中，他正准备删除锁，而且已经走到了条件判断的过程中，比如他已经拿到了当前这把锁确实是属于他自己的，正准备删除锁，但是此时他的锁到期了，那么此时线程2进来，但是线程1他会接着往后执行，当他卡顿结束后，他直接就会执行删除锁那行代码，相当于条件判断并没有起到作用，这就是删锁时的原子性问题，之所以有这个问题，是因为线程1的拿锁，比锁，删锁，实际上并不是原子性的，我们要防止刚才的情况发生

Redission分布式锁

配置类

此处自己写配置类，没有导入相关依赖，会覆盖redis配置

@Configuration
public class RedissonConfig {
    @Bean
    public RedissonClient redissonClient(){
        // 配置
        Config config = new Config();
        //单点模式

        config.useSingleServer().setAddress("redis://192.168.100.128:6379")
                .setPassword("123456");
        // 创建RedissonClient对象
        return Redisson.create(config);
    }
}

修改后的逻辑部分

 //创建锁对象
       // SimpleRedisLock simpleRedisLock = new SimpleRedisLock("order:" + userId, stringRedisTemplate);
        RLock lock=redissonClient.getLock("lock:order:" + userId);
        boolean isLock = lock.tryLock();//参数：锁的超时时间（过时之后就返回false），锁的自动释放时间，时间单位
        if(!isLock){
        return Result.fail("不允许重复下单");
        }
        try {

        IVoucherOrderService proxy=(IVoucherOrderService) AopContext.currentProxy();
        return proxy.createVoucherOrder(voucherId); }
        finally {
            lock.unlock();
        }

先加锁再加事务，再开始事务

可重入

用hash实现锁

key：锁名称

field：线程标识

value：记录当前线程重复次数

释放锁不是直接删除，而是value减1

"if (redis.call('exists', KEYS[1]) == 0) then " +
"redis.call('hset', KEYS[1], ARGV[2], 1); " +
"redis.call('pexpire', KEYS[1], ARGV[1]); " +
"return nil; " +
"end; " +
"if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " +
"redis.call('hincrby', KEYS[1], ARGV[2], 1); " +
"redis.call('pexpire', KEYS[1], ARGV[1]); " +
"return nil; " +
"end; " +
"return redis.call('pttl', KEYS[1]);"

Lua脚本保证原子性，判断是否有锁，有锁再判断是否是自己的，不是则获取失败，是则锁计数+1，设置锁有效期后执行任务。无锁则获取锁，再锁计数+1.。。。

Watchdog

Watchdog：你使用无参 **lock()** 或只指定等待时间的 **tryLock(waitTime)** 时，Redisson 会启动一个后台线程（Watchdog），自动为即将到期的锁续期。

默认行为：

锁的初始过期时间：30 秒
Watchdog 每隔 10 秒（即 30/3 = leaseTime / 3）检查一次
如果锁仍然被当前线程持有，就将过期时间 重置为 30 秒
只要你的业务没执行完，锁就不会过期！

注意！只有参数中没有leasetime时才会有看门狗机制

重试

重试逻辑

boolean isLocked = lock.tryLock(3, 10, TimeUnit.SECONDS);

最多等待 3 秒 尝试获取锁
在这 3 秒内，Redisson 会 每隔一段时间重试一次（内部使用 pub/sub 监听锁释放事件）
一旦锁被释放，会立即唤醒等待线程去抢锁（不是轮询！）

主从一致MultLock锁

以主从为例

此时我们去写命令，写在主机上，主机会将数据同步给从机，但是假设在主机还没有来得及把数据写入到从机去的时候，此时主机宕机，哨兵会发现主机宕机，并且选举一个slave变成master，而此时新的master中实际上并没有锁信息，此时锁信息就已经丢掉了。

MultLock保证所有结点都加锁成功，才算成功、

基本使用方式

1. 创建多个 RLock

RLock lock1 = redissonClient.getLock("lock:user:1001");
RLock lock2 = redissonClient.getLock("lock:user:1002");
RLock lock3 = redissonClient.getLock("lock:voucher:2001");

2. 组合成 MultiLock

RLock multiLock = redissonClient.getMultiLock(lock1, lock2, lock3);

3. 加锁 & 释放

try {
    // 尝试加锁（支持自动续期）
    multiLock.lock(); // 或 tryLock()

    // 执行业务逻辑（例如：用户1001向1002转账）
    // 此时其他人无法操作 user:1001、user:1002、voucher:2001

} finally {
    multiLock.unlock(); // 自动释放所有子锁
}

秒杀优化

核心逻辑：之前下了单之后才返回成功，现在判断有秒杀资格之后，直接给用户返回成功，在消息队列中慢慢下单

操作流程：

新增秒杀优惠券时，将优惠券id和库存信息保存到Redis中

基于Lua脚本，判断秒杀库存、一人一单，判断用户是否能抢购成功

抢购成功后，将优惠券id和用户id封装后存入阻塞队列

-- 1.参数列表
-- 1.1.优惠券id
local voucherId = ARGV[1]
-- 1.2.用户id
local userId = ARGV[2]
-- 1.3.订单id
local orderId = ARGV[3]

-- 2.数据key
-- 2.1.库存key
local stockKey = 'seckill:stock:' .. voucherId//value为库存数量
-- 2.2.订单key
local orderKey = 'seckill:order:' .. voucherId//value为用户id

-- 3.脚本业务
-- 3.1.判断库存是否充足 get stockKey
if(tonumber(redis.call('get', stockKey)) <= 0) then
    -- 3.2.库存不足，返回1
    return 1
end
-- 3.2.判断用户是否下单 SISMEMBER orderKey userId
if(redis.call('sismember', orderKey, userId) == 1) then
    -- 3.3.存在，说明是重复下单，返回2
    return 2
end
-- 3.4.扣库存 incrby stockKey -1
redis.call('incrby', stockKey, -1)
-- 3.5.下单（保存用户）sadd orderKey userId
redis.call('sadd', orderKey, userId)
-- 3.6.发送消息到队列中， XADD stream.orders * k1 v1 k2 v2 ...
redis.call('xadd', 'stream.orders', '*', 'userId', userId, 'voucherId', voucherId, 'id', orderId)
return 0

阻塞队列

在队列中获取元素时，这个队列中没有元素，这个线程就会被阻塞

消息队列

Stream

消息可回溯：消息读完不消失

可以被多个消费者读取

XADD key [队列不存在是否自动创建，默认是][消息队列的最大消息数量]
XADD uesr * key jack age 21//创建一个名为user的队列，并向其中发送消息{name=jack,age=21}
"数字u"会返回一个redis自动生成的id
XREDAD COUNT 1 [BLOCK x 指定阻塞时间]streams user 0/$
0是第一条，$是最后一条

XREAD读取之后，连发多条消息，只能接受到第一条

消费者组

消息分流：消息会分给组内不同的消费者，不会重复消费，提高速率

消息标识：消费者组会记录最后一个被处理的消息，消费者宕机之后，仍然会从标识之后读取消息，既保证不会漏读

消息确认：获取消息后存入pending-list，消费者处理完之后通过XACK确认消息，之后从pending-list中移除

XGroup create key groupname id [MKSTREAM]

起始id:$代表队列中最新消息，0代表队列中第一个消息

删除指定的消费者组

XGROUP DESTORY key groupName

给指定的消费者组添加消费者

XGROUP CREATECONSUMER key groupname consumername

删除消费者组中的指定消费者

XGROUP DELCONSUMER key groupname consumername

从消费者组读取消息：

XREADGROUP GROUP group consumer [COUNT count] [BLOCK milliseconds] [NOACK] STREAMS key [key ...] ID [ID ...]

[NOACK]:消息自动确认，不进pending-list，一般不用
ID：获取消息的起始ID：

“>”：从下一个未消费的消息开始其它：根据指定id从pending-list中获取已消费但未确认的消息，例如0，是从pending-list中的第一个消息开始

实现

创建一个Stream类型的消息队列，名为stream.orders
修改之前的秒杀下单Lua脚本，在认定有抢购资格后，直接向stream.orders中添加消息，内容包含voucherId、userId、orderId
项目启动时，开启一个线程任务，尝试获取stream.orders中的消息，完成下单

Blog中isLIke字段判断是否被当前用户点赞过，一个用户只能点赞一次（Redis set实现），再次点击取消

@TableField(exist = false)//告诉mp数据库中不存在这个字段
private Boolean isLike;