【11/19-12/02（第七次）学习总结】

已于 2022-12-02 16:48:20 修改
阅读量240 收藏
点赞数
文章标签： 学习 java redis
于 2022-11-21 15:43:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45190838/article/details/127958446
版权

【11/19-12/02（第七次）学习总结】

缓存击穿

部分key或者少数key过期，高并发访问redis，大量请求同时访问数据库。
在这里插入图片描述
解决方案

  1. 互斥锁
    查询未命中加锁然后查询数据库构建缓存数据，写入缓存，释放锁。但是其他线程也会执行相同的操作，线程会一直阻塞。

    可以借助redis中的setnx命令达成一个锁的功能。

  2. 逻辑过期
    不设置过期时间，单独设置一个属性过期时间，第一个线程发现其过期之后，就加锁，开启一个新的线程，查询数据库构建缓存数据，写入缓存，然后直接返回旧的数据，其他线程同样获得不到锁，直接返回旧数据。
    在这里插入图片描述
    在这里插入图片描述

Apache JMeter

高并发测试工具

封装redis工具

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

import cn.hutool.core.util.BooleanUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;

import static com.hmdp.utils.RedisConstants.CACHE_NULL_TTL;
import static com.hmdp.utils.RedisConstants.LOCK_SHOP_KEY;

@Slf4j
@Component
public class CacheClient {

    private final StringRedisTemplate stringRedisTemplate;

    private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);

    public CacheClient(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

    public void set(String key, Object value, Long time, TimeUnit unit) {
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value), time, unit);
    }

    public void setWithLogicalExpire(String key, Object value, Long time, TimeUnit unit) {
        // 设置逻辑过期
        RedisData redisData = new RedisData();
        redisData.setData(value);
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(unit.toSeconds(time)));
        // 写入Redis
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
    }

    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);
        }
        // 判断命中的是否是空值
        if (json != null) {
            // 返回一个错误信息
            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;
    }

    public <R, ID> R queryWithLogicalExpire(
            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.isBlank(json)) {
            // 3.存在，直接返回
            return null;
        }
        // 4.命中，需要先把json反序列化为对象
        RedisData redisData = JSONUtil.toBean(json, RedisData.class);
        R r = JSONUtil.toBean((JSONObject) redisData.getData(), type);
        LocalDateTime expireTime = redisData.getExpireTime();
        // 5.判断是否过期
        if(expireTime.isAfter(LocalDateTime.now())) {
            // 5.1.未过期，直接返回店铺信息
            return r;
        }
        // 5.2.已过期，需要缓存重建
        // 6.缓存重建
        // 6.1.获取互斥锁
        String lockKey = LOCK_SHOP_KEY + id;
        boolean isLock = tryLock(lockKey);
        // 6.2.判断是否获取锁成功
        if (isLock){
            // 6.3.成功，开启独立线程，实现缓存重建
            CACHE_REBUILD_EXECUTOR.submit(() -> {
                try {
                    // 查询数据库
                    R newR = dbFallback.apply(id);
                    // 重建缓存
                    this.setWithLogicalExpire(key, newR, time, unit);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }finally {
                    // 释放锁
                    unlock(lockKey);
                }
            });
        }
        // 6.4.返回过期的商铺信息
        return r;
    }

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

        // 4.实现缓存重建
        // 4.1.获取互斥锁
        String lockKey = LOCK_SHOP_KEY + id;
        R r = null;
        try {
            boolean isLock = tryLock(lockKey);
            // 4.2.判断是否获取成功
            if (!isLock) {
                // 4.3.获取锁失败，休眠并重试
                Thread.sleep(50);
                return queryWithMutex(keyPrefix, id, type, dbFallback, time, unit);
            }
            // 4.4.获取锁成功，根据id查询数据库
            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);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }finally {
            // 7.释放锁
            unlock(lockKey);
        }
        // 8.返回
        return r;
    }

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

分布式锁

原因

不同机器上的JVM不一样的，所以集群部署的时候，依然存在线程安全问题。
在这里插入图片描述
在这里插入图片描述

redis实现分布式锁

在这里插入图片描述

自动拆箱会出现空指针，需要这样来写

success = null ，也应该返回false

@Override
    public boolean tryLock(long timeoutSec) {
        // 获取线程标示
        String threadId = ID_PREFIX + Thread.currentThread().getId();
        // 获取锁
        Boolean success = stringRedisTemplate.opsForValue()
                .setIfAbsent(KEY_PREFIX + name, threadId, timeoutSec, TimeUnit.SECONDS);
        return Boolean.TRUE.equals(success);
    }

在这里插入图片描述

redis 设置10s,如果业务时间超过10s,那么就会误删锁。

在这里插入图片描述
改进方式：
value 改成uuid + 线程id
在这里插入图片描述

不能保证原子性

在这里插入图片描述

Lua脚本实现

Lua脚本，以前也了解过一点，但是不明白原理，执行脚本能够确保多条命令执行时的原子性。
视频里说以前是两行代码（1. 获得锁 2. 释放锁） 现在变成了一行代码。所以能把保持原子性。
Lua 下标从1开始

-- 比较线程标示与锁中的标示是否一致
if(redis.call('get', KEYS[1]) ==  ARGV[1]) then
    -- 释放锁 del key
    return redis.call('del', KEYS[1])
end
return 0

private static final DefaultRedisScript<Long> SECKILL_SCRIPT;

    static {
        SECKILL_SCRIPT = new DefaultRedisScript<>();
        SECKILL_SCRIPT.setLocation(new ClassPathResource("seckill.lua"));
        SECKILL_SCRIPT.setResultType(Long.class);
    }

package com.hmdp.utils;

import cn.hutool.core.lang.UUID;
import org.springframework.core.io.ClassPathResource;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;

import java.util.Collections;
import java.util.concurrent.TimeUnit;

public class SimpleRedisLock implements ILock {

   private String name;
   private StringRedisTemplate stringRedisTemplate;

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

   private static final String KEY_PREFIX = "lock:";
   private static final String ID_PREFIX = UUID.randomUUID().toString(true) + "-";
   private static final DefaultRedisScript<Long> UNLOCK_SCRIPT;
   static {
       UNLOCK_SCRIPT = new DefaultRedisScript<>();
       UNLOCK_SCRIPT.setLocation(new ClassPathResource("unlock.lua"));
       UNLOCK_SCRIPT.setResultType(Long.class);
   }

   @Override
   public boolean tryLock(long timeoutSec) {
       // 获取线程标示
       String threadId = ID_PREFIX + Thread.currentThread().getId();
       // 获取锁
       Boolean success = stringRedisTemplate.opsForValue()
               .setIfAbsent(KEY_PREFIX + name, threadId, timeoutSec, TimeUnit.SECONDS);
       return Boolean.TRUE.equals(success);
   }

   @Override
   public void unlock() {
       // 调用lua脚本
       stringRedisTemplate.execute(
               UNLOCK_SCRIPT,
               Collections.singletonList(KEY_PREFIX + name),
               ID_PREFIX + Thread.currentThread().getId());
   }
   /*@Override
   public void unlock() {
       // 获取线程标示
       String threadId = ID_PREFIX + Thread.currentThread().getId();
       // 获取锁中的标示
       String id = stringRedisTemplate.opsForValue().get(KEY_PREFIX + name);
       // 判断标示是否一致
       if(threadId.equals(id)) {
           // 释放锁
           stringRedisTemplate.delete(KEY_PREFIX + name);
       }
   }*/
}

Lua的问题

在这里插入图片描述

  1. 线程拿到锁之后调用方法B，但是B需要获得锁，B会等锁释放，导致思索
  2. 04说的是读操作的时候访问从节点，写的时候访问主节点。

解决Lua缺点的问题的方案 —Redisson

Redisson简介

在这里插入图片描述

配置实现

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

重入锁概念

在这里插入图片描述

Redisson分布式锁主从一致性问题

  • Master 负责写
  • Slave 负责读

当Java发送一个请求锁成功之后，需要把锁的状态分发到副节点当中，这是有延迟的，但是恰恰这时候主节点宕机时，由于哨兵模式的存在，会挑一个副节点来充当主节点，但是锁没有分发到副节点上，锁已经失效了，新的matser节点没有锁，其他请求就可以来请求锁，存在安全问题。

在这里插入图片描述

解决方案 联锁

进行集群的分片，在多个master上建立多个锁。只有每个节点都拿到锁之后，才能够获取成功。所以安全性比较高。

在这里插入图片描述

redisson锁的配置

@Configuration
public class RedissonConfig {

    @Bean
    public RedissonClient redissonClient(){
        // 配置
        Config config = new Config();
        config.useSingleServer().setAddress("redis://192.168.150.101:6379").setPassword("123321");
        // 创建RedissonClient对象
        return Redisson.create(config);
    }
}

在这里插入图片描述

异步执行

定义一个线程池，提交任务，需要添加@PostConstruct注解在类加载之后进行初始化。


    private static final ExecutorService SECKILL_ORDER_EXECUTOR = Executors.newSingleThreadExecutor();

    @PostConstruct
    private void init() {
        SECKILL_ORDER_EXECUTOR.submit(new VoucherOrderHandler());
    }

基于Stream的消息队列

能够永久存在，可以持久化。

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

缺点

在阻塞状态下读取队列的消息，存在消费漏读的情况，只能够读取最新的，而不是所有的。
在这里插入图片描述
解决方法：消费者组

在这里插入图片描述

redis主从架构

全量同步

在这里插入图片描述

读写分离，在副节点上只能读，

数据同步，全量同步

在这里插入图片描述
如何判断是否是副节点是否第一次来主节点进行同步数据

  1. ReplicationId，数据集Id，每个master有一个唯一的id，slave继承master的id，比较id即可
  2. offset ，偏移量，同步了多少数据，用来判断slave的数据状态是否小于master
  3. master 持续将RDB期间的命令记录在repl_baklog文件中，并持续将log中的命令发送给slave节点，slave执行命令即可。

增量同步

slave在重启之后执行增量同步，master中的log是一个环形数组，
在这里插入图片描述

类似于循环队列中的front和rear指针，如果master超过了slave，那么就需要做全量同步。

性能优化

repl-diskless-sync yes

采取无磁盘复制，不是将数据写入到磁盘当中，而是直接通过网络发送，适合于磁盘读写比较慢，但是网络比较快的时候。

redis单节点上的内存不要占用太大，减少RDB的磁盘IO

提高log日志的大小

主—从—从链式结构

在这里插入图片描述
执行slaveof命令时只需要改变ip和port即可。

redis 哨兵模式

哨兵作用

在这里插入图片描述

  1. 监控master和slave的状态
  2. master故障之后会将某个slave升级为master
  3. 一旦发生故障，通知RedisClient的redis的ip变化

哨兵监控

在这里插入图片描述
单个哨兵每隔1s发送ping命令，ping不通的话认为master主观下线（可能有网络延迟之类的），超过半数的哨兵发现master下线即认为时客观下线（宕机）。

哨兵挑选新的slave

在这里插入图片描述
首先排除断开时间过久的，再去看slave-priority值，越小优先级越高，再去判断offst，数据的完整性，如果还相同的话随机选。

在这里插入图片描述

  1. 首先将新的master节点执行slave of no one
  2. 向其他节点广播新的master节点，同步新的mster上的数据
  3. 将故障节点标记为slave，以后一直是slave.

RedisTemplate哨兵模式

在这里插入图片描述
配置读写分离

在这里插入图片描述

在这里插入图片描述

redis分片集群结构

在这里插入图片描述

主从哨兵模式：单个master节点不能设置的内存过大，是为了保证RDB的效率

  • 能解决高并发读
  • 不能解决高并发写和海量数据存储问题

散列插槽

在这里插入图片描述
每个master节点平均分配16384个插槽，根据插槽值去找数据

在这里插入图片描述

JVM本地缓存

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

在本地查询不到数据，默认去数据库查

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

key名字规范

起名建议

在这里插入图片描述

避免Bigkey

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

clearlove_0520
关注
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值