Redis缓存笔记

最新推荐文章于 2024-07-19 17:22:46 发布
最新推荐文章于 2024-07-19 17:22:46 发布
阅读量55 收藏
点赞数
分类专栏： Redis 文章标签： 缓存 redis 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46016309/article/details/131686025
版权

Redis缓存

缓存就是数据交换的缓冲区（Cache），是存储数据的临时地方，一般读写性能较高。使用缓存可以降低后端负载、提高读写效率、降低响应时间，但是增加了数据一致性成本、代码维护成本、运维成本。

Redis缓存的模型及流程如下图所示：

模拟查询商户的过程，将商户的数据存储在缓存中。

商户缓存1.0

根据以上流程，编写代码

public static final Long CACHE_SHOP_TTL = 30L;
public static final String CACHE_SHOP_KEY = "cache:shop:";

@Autowired
private StringRedisTemplate redisTemplate;


@Override
public Result queryById(Long id) {
    //从redis查询商户信息
    String shopJson = redisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);
    //判断是否存在
    if(StrUtil.isNotBlank(shopJson)){
        //存在对应信息，则直接返回
        Shop shop = JSONUtil.toBean(shopJson, Shop.class);
        return Result.ok(shop);
    }

    //不存在则根据id查询数据库
    Shop shop = getById(id);
    //数据库中也不存在
    if(shop == null){
        return Result.fail("用户不存在");
    }
    //数据库中存在则写入Redis
    redisTemplate.opsForValue().set(CACHE_SHOP_KEY+id,JSONUtil.toJsonStr(shop));
    return Result.ok(shop);
}
商户缓存2.0

在1.0版本已经实现了将商户数据存储在缓存中，但是缓存数据并不是一成不变的，如果商户信息发生改变，那么缓存数据也要改变，这就涉及到了缓存的更新策略。

内存淘汰超时删除主动更新
说明不需要自己维护，利用Redis的内存淘汰机制，当内存不足自动淘汰部分数据。下次查询时更新缓存。给缓存数据添加TTL时间，到期后自动删除缓存。下次查询时更新缓存。编写业务逻辑，在修改数据库的同时，更新缓存。
一致性差一般好
维护成本无低高

更新策略选择根据业务场景进行选择

  • 低一致性需求：使用内存淘汰机制，例如店铺类型的查询缓存。
  • 高一致性需求：主动更新，并以超时剔除作为兜底方案，例如店铺详情查询缓存。

主动更新策略：主动更新策略有多种，常用的是缓存调用者在更新数据库的同时更新缓存。而操作缓存和数据库又存在以下问题：

  1. 删除缓存还是更新缓存？

    • 更新缓存：每次更新数据库都更新缓存，无效的写操作较多。（不推荐）
    • 删除缓存：更新数据库时让缓存失效，查询时再更新缓存。（推荐）

  2. 如何保证缓存与数据库操作同时成功或者失败？

    • 单体系统可以将缓存与数据库操作放在一个事务内，保证同时成功或失败
    • 分布式系统利用TCC等分布式事务方案

  3. 先操作缓存还是先操作数据库？

    • 方案一：先删除缓存，再操作数据库
    • 方案二：先操作数据库，再删除缓存

    首先方案一和方案二在多线程情况下都有可能发生问题，但是方案二发生问题的可能性更低，因为缓存的操作速度是比数据库快的，而方案二发生的前提就是在更新缓存的几毫秒过程中，有另一个线程完成了更新数据库操作+删除缓存操作才会导致存入旧数据，但是这种情况发生的概率非常低。

因此最佳的方案是

  • 读操作：
    • 缓存命中直接返回
    • 缓存未命中查询数据库，并写入缓存设定超时时间
  • 写操作：
    • 先写数据库，再删除缓存
    • 确保数据库与缓存操作的原子性
@Autowired
private StringRedisTemplate redisTemplate;

@Override
public Result queryById(Long id) {
    //从redis查询商户信息
    String shopJson = redisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);
    //判断是否存在
    if(StrUtil.isNotBlank(shopJson)){
        //存在对应信息，则直接返回
        Shop shop = JSONUtil.toBean(shopJson, Shop.class);
        return Result.ok(shop);
    }

    //不存在则根据id查询数据库
    Shop shop = getById(id);
    //数据库中也不存在
    if(shop == null){
        return Result.fail("用户不存在");
    }
    //数据库中存在则写入Redis并设置有效期30分钟
    redisTemplate.opsForValue().set(CACHE_SHOP_KEY+id,JSONUtil.toJsonStr(shop),CACHE_SHOP_TTL, TimeUnit.MINUTES);
    return Result.ok(shop);
}
//单体项目使用事务控制原子性
@Override
@Transactional
public Result update(Shop shop) {
    Long id = shop.getId();
    if(id == null){
        return Result.fail("店铺Id不能为空");
    }
    //1.更新数据库
    updateById(shop);
    //2.删除缓存
    redisTemplate.delete(CACHE_SHOP_KEY + id);
    return Result.ok();
}
缓存穿透

缓存穿透是指客户端请求的数据在缓存中和数据库中都不存在，这样缓存永远都不会生效，这些请求都会直接到数据库，当不断地有这种请求就会给数据库带来巨大压力。

在这里插入图片描述

常见的解决方案分为两种：

  • 缓存空对象

    不存在的时候直接缓存null空对象（“”），这样再次请求就不会访问数据库。

    • 优点：实现简单，维护方便
    • 缺点：额外的内存消耗、可能造成短期不一致

在这里插入图片描述

public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {

    @Autowired
    private StringRedisTemplate redisTemplate;


    @Override
    public Result queryById(Long id) {
        //从redis查询商户信息
        String shopJson = redisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);
        //判断Redis是否存在商户信息，如果为设置的空值这里无法判断，在下方再写一个if判断
        if(StrUtil.isNotBlank(shopJson)){
            //存在对应信息，则直接返回
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return Result.ok(shop);
        }
        //判断命中的是否为空值，如果为""，那么shopJson就不等于null，""和null是不一样的
        if(shopJson != null){
            return Result.fail("店铺信息不存在");
        }
        //不存在则根据id查询数据库
        Shop shop = getById(id);
        //数据库中也不存在
        if(shop == null){
            //不存在则在Redis存储空值并设置有效期2min
            redisTemplate.opsForValue().set(CACHE_SHOP_KEY+id,"",CACHE_NULL_TTL,TimeUnit.MINUTES);
            return Result.fail("商户不存在");
        }
        //数据库中存在则写入Redis,并设置有效期30min
        redisTemplate.opsForValue().set(CACHE_SHOP_KEY+id,JSONUtil.toJsonStr(shop),CACHE_SHOP_TTL, TimeUnit.MINUTES);
        return Result.ok(shop);
    }
    //单体项目使用事务控制原子性
    @Override
    @Transactional
    public Result update(Shop shop) {
        Long id = shop.getId();
        if(id == null){
            return Result.fail("店铺Id不能为空");
        }
        //1.更新数据库
        updateById(shop);
        //2.删除缓存
        redisTemplate.delete(CACHE_SHOP_KEY + id);
        return Result.ok();
    }
}

  • 布隆过滤

    在访问缓存之前通过布隆过滤器来判断数据是否存在，如果不存在则直接拒绝访问，避免一直访问缓存和数据库

    • 优点：内存占用小，没有多余key
    • 缺点：实现复杂，存在误判可能

在这里插入图片描述

缓存雪崩

缓存雪崩是指同一时间段内，大量的缓存key同时失效或者Redis服务宕机，导致大量请求到达数据库，带来巨大压力。

解决方案：

  • 给不同key的TTL添加随机值，避免大量key同时失效
  • 利用Redis集群提高服务的可用性
  • 给缓存业务添加降级限流策略
  • 给业务添加多级缓存
缓存击穿

缓存击穿问题也叫热点Key问题，就是一个被高并发访问并且缓存重建业务较复杂（失效之后的重新构建数据）的key突然失效了，无数的请求访问会瞬间给数据库带来巨大的冲击。

常见的解决方案有两种

  • 互斥锁

    避免大量的请求都尝试重建数据，使用互斥锁，只有一个线程能够进行重建。也就是当一个请求查询不到缓存，就获取互斥锁，然后写入缓存之后再释放锁。其余线程只能不断地休眠重试，处于等待状态。

    • 优点：相对于逻辑过期没有额外的内存消耗、保证一致性、实现简单、
    • 缺点：线程需要等待，性能受影响、可能有死锁风险

在这里插入图片描述

public Shop queryWithMutex(Long id){
    //从redis查询商户信息
    String shopJson = redisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);
    //判断Redis是否存在商户信息，如果为设置的空值这里无法判断，在下方再写一个if判断
    if(StrUtil.isNotBlank(shopJson)){
        //存在对应信息，则直接返回
        Shop shop = JSONUtil.toBean(shopJson, Shop.class);
        return shop;
    }
    //判断命中的是否为空值，如果为""，那么shopJson就不等于null，""和null是不一样的
    if(shopJson != null){
        return null;
    }
    Shop shop = null;
    //实现缓存重建
    //获取互斥锁
    String lockKey = LOCK_SHOP_KEY + id;
    try {
        boolean isLock = tryLock(lockKey);
        //判断是否获取成功
        //如果获取锁不成功
        if(!isLock){
            //失败则休眠并重试
            Thread.sleep(1000);
            return queryWithMutex(id);
        }
        //如果获取锁成功，则查询数据库进行缓存重建
        shop = getById(id);
        //模拟重建的延迟
        Thread.sleep(200);
        //数据库中也不存在
        if(shop == null){
            //不存在则在Redis存储空值并设置有效期2min
            redisTemplate.opsForValue().set(CACHE_SHOP_KEY+id,"",CACHE_NULL_TTL,TimeUnit.MINUTES);
            return null;
        }
        //数据库中存在则写入Redis,并设置有效期30min
        redisTemplate.opsForValue().set(CACHE_SHOP_KEY+id,JSONUtil.toJsonStr(shop),CACHE_SHOP_TTL, TimeUnit.MINUTES);

    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    } finally {
        //释放锁
        unLock(lockKey);
    }
    return shop;
}
//获取锁
private boolean tryLock(String key){
    Boolean flag = redisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
    return BooleanUtil.isTrue(flag);
}
//释放锁
public void unLock(String key){
    redisTemplate.delete(key);
}

  • 逻辑过期

    不给热点数据设置一个真正的过期时间，而是逻辑上的过期，在存储数据的时候，增加一个字段存储过期时间（当前时间+期望存活的时间）这样key永远都不会过期。

    • 优点：线程无需等待，性能较好
    • 缺点：不保证一致性、有额外内存消耗、实现复杂
      在这里插入图片描述

在这里插入图片描述

首先为了在Redis中存储商户信息同时，还多出一个过期时间的字段，需要重新建一个类，来存储

public class RedisData {
    private LocalDateTime expireTime;
    private Object data;
}

创建重建代码

public void saveShop2Redis(Long id,Long expireSeconds) throws InterruptedException {
        //查询店铺信息
        Shop shop = getById(id);
        //模拟缓存重建的时间
        Thread.sleep(200);
        //封装逻辑过期时间
        RedisData redisData = new RedisData();
        redisData.setData(shop);
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));
        //写入redis
        redisTemplate.opsForValue().set(CACHE_SHOP_KEY+id,JSONUtil.toJsonStr(redisData));
    }

编写单元测试，查看重建方法是否正确的同时，导入热点数据，这样后面进行查看才不会出错，因为之前的商户缓存是没有过期时间字段的

@Test
    void test() throws InterruptedException {
        shopService.saveShop2Redis(1L,20L);
    }

测试成功则编写具体的逻辑过期代码

public Shop queryWithLogicalExpire(Long id){
        //1.从redis查询商户信息
        String shopJson = redisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);
        //2.如果为空，为空则返回
        if(StrUtil.isBlank(shopJson)){
            return null;
        }
        //3.如果存在则把json反序列化为对象
        RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);
        Shop shop = JSONUtil.toBean((JSONObject) redisData.getData(), Shop.class);
        LocalDateTime expireTime = redisData.getExpireTime();
        //4.判断是否过期
        if (expireTime.isAfter(LocalDateTime.now())){
            //4.1未过期返回店铺信息
            return shop;
        }

        //4.2已过期，则缓存重建
        //4.2.1 获取互斥锁
        String lockKey = LOCK_SHOP_KEY + id;
        boolean tryLock = tryLock(lockKey);

        //4.2.2 判断是否获取锁成功
        if(tryLock){
            //获取锁成功，需要再次检查是否过期
            // 因为可能线程a发现缓存过期，发起重建请求获取锁的时候，线程b刚刚开始判断缓存是否过期，此时线程b同样认为缓存过期需要重建
            //在b获取锁之前，线程a刚好重建完成释放锁，那么b就顺利拿到锁，再次进行重建，可是此时a已经重建过了，不需要再次重建
            //从redis查询商户信息
            shopJson = redisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);
            //如果为空，为空则返回
            if(StrUtil.isBlank(shopJson)){
                return null;
            }
            //如果存在则把json反序列化为对象
            redisData = JSONUtil.toBean(shopJson, RedisData.class);
            expireTime = redisData.getExpireTime();
            //判断是否过期
            if (expireTime.isAfter(LocalDateTime.now())){
                //未过期返回店铺信息
                return shop;
            }
            //4.2.3 过期则开启独立线程，实现缓存重建
            CACHE_REBUILD_EXECUTOR.submit(()->{
                //重建
                try {
                    this.saveShop2Redis(id,20L);
                }catch (Exception e){
                    throw new RuntimeException();
                }finally {
                    //释放锁
                    unLock(lockKey);
                }

            });
        }

        //4.2.4 如果拿不到锁就直接返回过期的商户信息
        return shop;
    }
缓存工具封装

方法一：将任意Java对象序列化为json并存储在String类型的key中，并且可以设置TTL过期时间

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

方法三：根据指定key查询缓存，并反序列化为指定类型，利用缓存空值方式，解决缓存穿透问题

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

@Component
@Slf4j
public class CacheClient {
    private final StringRedisTemplate redisTemplate;

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

    /**
     * 将任意Java对象序列化为json并存储在String类型的key中，并且可以设置TTL过期时间
     * @param key key值
     * @param value value值
     * @param time 过期时间
     * @param timeUnit 过期时间单位
     */
    public void set(String key, Object value, Long time, TimeUnit timeUnit){
        redisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value),time,timeUnit);
    }

    /**
     * 将任意Java对象序列化为json并存储在String类型的key中，并且可以设置逻辑过期时间，用于处理缓存击穿问题
     * @param key   key值
     * @param value     value值
     * @param time      过期时间
     * @param timeUnit  过期时间单位
     */
    public void setWithLogicalExpire(String key, Object value,Long time,TimeUnit timeUnit){
        //设置逻辑过期
        RedisData redisData = new RedisData();
        redisData.setData(value);
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(timeUnit.toSeconds(time)));
        //写入redis
        redisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(redisData));
    }

    /**
     * 根据指定key查询缓存，并反序列化为指定类型，利用缓存空值方式，解决缓存穿透问题
     * @param keyPrefix    String类型key值的前缀
     * @param id        唯一编码id（不限类型）
     * @param type  返回值类型
     * @param dbFallback    获取数据库内容函数
     * @param time      过期时间
     * @param timeUnit      过期时间单位
     * @return
     * @param <R>   返回值泛型
     * @param <ID>  返回值泛型
     */
    public <R,ID> R queryWithPassThrough(String keyPrefix, ID id, Class<R> type, Function<ID,R> dbFallback
            ,Long time,TimeUnit timeUnit){
        String key = keyPrefix + id;
        //从redis查询商户信息
        String json = redisTemplate.opsForValue().get(key);
        //判断Redis是否存在商户信息，如果为设置的空值这里无法判断，在下方再写一个if判断
        if(StrUtil.isNotBlank(json)){
            //存在对应信息，则直接返回
            return JSONUtil.toBean(json, type);

        }
        //判断命中的是否为空值，如果为""，那么shopJson就不等于null，""和null是不一样的
        if(json != null){
            return null;
        }
        //不存在则根据id查询数据库
        R r = dbFallback.apply(id);
        //数据库中也不存在
        if(r == null){
            //不存在则在Redis存储空值并设置有效期2min
            redisTemplate.opsForValue().set(key,"",CACHE_NULL_TTL,TimeUnit.MINUTES);
            return null;
        }
        //数据库中存在则写入Redis,并设置有效期
        this.set(key,r,time,timeUnit);
        return r;
    }


    //线程池
    private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);


    //获取锁
    private boolean tryLock(String key){
        Boolean flag = redisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
        return BooleanUtil.isTrue(flag);
    }
    //释放锁
    public void unLock(String key){
        redisTemplate.delete(key);
    }


    /**
     * 根据指定的key查询缓存，并反序列化为指定类型，需要利用逻辑过期解决缓存击穿问题
     * @param keyPrefix     Stiring类型key的前缀
     * @param id        唯一标识可以为任意类型
     * @param type      返回值类型
     * @param dbFallback    获取数据库内容函数
     * @param time      过期时间
     * @param timeUnit  过期时间单位
     * @return
     * @param <R>   返回值类型
     * @param <ID>  返回值类型
     */
    public <R,ID> R queryWithLogicalExpire(String keyPrefix,ID id,Class<R> type,Function<ID,R> dbFallback
            ,Long time,TimeUnit timeUnit){
        String key = keyPrefix +id;
        //1.从redis查询商户信息
        String json = redisTemplate.opsForValue().get(key);
        //2.如果为空，为空则返回
        if(StrUtil.isBlank(json)){
            return null;
        }
        //3.如果存在则把json反序列化为对象
        RedisData redisData = JSONUtil.toBean(json, RedisData.class);
        R r = JSONUtil.toBean((JSONObject) redisData.getData(), type);
        LocalDateTime expireTime = redisData.getExpireTime();
        //4.判断是否过期
        if (expireTime.isAfter(LocalDateTime.now())){
            //4.1未过期返回店铺信息
            return r;
        }

        //4.2已过期，则缓存重建
        //4.2.1 获取互斥锁
        String lockKey = LOCK_SHOP_KEY + id;
        boolean tryLock = tryLock(lockKey);

        //4.2.2 判断是否获取锁成功
        if(tryLock){
            //获取锁成功，需要再次检查是否过期
            // 因为可能线程a发现缓存过期，发起重建请求获取锁的时候，线程b刚刚开始判断缓存是否过期，此时线程b同样认为缓存过期需要重建
            //在b获取锁之前，线程a刚好重建完成释放锁，那么b就顺利拿到锁，再次进行重建，可是此时a已经重建过了，不需要再次重建
            //从redis查询商户信息
            json = redisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);
            //如果为空，为空则返回
            if(StrUtil.isBlank(json)){
                return null;
            }
            //如果存在则把json反序列化为对象
            redisData = JSONUtil.toBean(json, RedisData.class);
            expireTime = redisData.getExpireTime();
            //判断是否过期
            if (expireTime.isAfter(LocalDateTime.now())){
                //未过期返回店铺信息
                return r;
            }
            //4.2.3 过期则开启独立线程，实现缓存重建
            CACHE_REBUILD_EXECUTOR.submit(()->{
                //重建
                try {
                    //查询数据库
                    R r1 = dbFallback.apply(id);

                    this.setWithLogicalExpire(key,r1,time,timeUnit);

                }catch (Exception e){
                    throw new RuntimeException();
                }finally {
                    //释放锁
                    unLock(lockKey);
                }

            });
        }

        //4.2.4 如果拿不到锁就直接返回过期的商户信息
        return r;
    }

}

方法的调用方式：

//使用工具类解决缓存穿透
Shop shop = cacheClient.queryWithPassThrough(CACHE_SHOP_KEY, id, Shop.class, dataId -> getById(dataId), CACHE_SHOP_TTL, TimeUnit.MINUTES);

//使用工具类逻辑过期解决缓存击穿
Shop shop = cacheClient.queryWithLogicalExpire(CACHE_SHOP_KEY, id, Shop.class, dataId -> getById(dataId), CACHE_SHOP_TTL, TimeUnit.MINUTES);
TCChzp
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Redis缓存测试整理笔记(一)
qq_41044271的博客
07-18 361
如果遇到请求攻击，即使这个缓存有效期只有1秒，也是很有效的，能够挡住大量的请求。针对请求参数变化不大，返回的数据跟DB中存储的数据很接近的情况，适合在”里面“缓存数据，也就是在更新DB的同时更新缓存，这种情况最优的状态下，只需要读缓存就够了，不需要跟DB直接交互，能大大缓存DB压力，这种缓存有效期可以设置很长。内存缓存和数据库缓存类似，受技术栈限制，比如Java可以使用，并且非常频繁，但是PHP无法使用，内存缓存比数据库缓存更快，因为内存缓存不可能一直增加，所以限制更多，稍微不注意就会出现内存泄漏的问题.
如何使用 Redis 缓存？
热门推荐
lyl54545的博客
04-20 1万+
​ 编辑 添加图片注释，不超过 140 字（可选） 如何使用 Redis 缓存 前言 对于 Redis 来讲，作为缓存使用，是我们在业务中经常使用的，这里总结下，Redis 作为缓存在业务中的使用。 旁路缓存 Cache Aside（旁路缓存）策略以数据库中的数据为准，缓存中的数据是按需加载的。它可以分为读策略和写策略。 只读缓存 只读缓存 从缓存中读取数据；如果缓存命中，则直接返回数据；如果缓存不命中，则从数据库中查询数据；查询到数据后，将数据写入到缓存中，并且返回给..
Redis学习笔记--Redis缓存问题
weixin_50785958的博客
04-07 914
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、缓存是什么？二、Redis缓存的更新策略三.缓存穿透四、缓存雪崩五、缓存击穿 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、缓存是什么？ 缓存就是数据交换的缓冲区（cache），是存储数据的临时地方，一般读写性能较高。 缓存的作用 降低后端的.
Redis缓存篇
weixin_46353152的博客
08-29 1133
Redis缓存篇【笔记整理】
Redis缓存机制
RSDYS的博客
09-20 1099
Redis学习笔记小节
redis缓存数据库技术
sichenss的博客
03-10 3658
学习笔记
redis缓存清理
ljk15036029526的博客
06-07 171
docker exec -it 容器名 redis-cli。设置最大内存：config set maxmemory 2GB。查看：config get maxmemory。覆盖原配置文件：config rewrite。删除指定key：del xxx（key）flushall 所有数据库。查询所有key：keys *flushdb 当前库。
redis学习笔记
qq_52058512的博客
05-24 69
学习目标： 了解redis缓存问题 redis缓存穿透 redis缓存击穿 reds缓存雪崩 学习内容： redis缓存击穿的原因 redis缓存中的某一热点数据在某一时间失效 同一时刻接收到大量并发请求 此时redis缓存中的热点数据失效 大量并发请求直接打击到数据库上 导致数据库被打垮; 如何解决redis缓存击穿问题 延长热点数据过期时间; synchronized 加锁; ReentrantLock.tryLock()加锁; redis 的命令 setnx() 加锁;
黑马Redis笔记高级篇 | 分布式缓存
2301_77450803的博客
05-11 1328
RDB全称Redis Database Backup file（Redis数据备份文件），也被叫做Redis数据快照。简单来说就是把内存中的所有数据都记录到磁盘中。当Redis实例故障重启后，从磁盘读取快照文件，恢复数据。快照文件称为RDB文件，默认是保存在当前运行目录Redis停机时会执行一次RDB。（save命令由Redis主进程来执行RDB，会阻塞所有命令；bgsave命令则开启子进程执行RDB，是异步的，避免主进程受到影响）
尚硅谷 Redis 学习笔记
weixin_56042518的博客
01-14 1117
RDB 持久化 能够在指定时间间隔对数据进行快照存储AOF 持久化 记录每次服务器的写操作，当服务器重启时会重新执行 AOF 文件中的写命令来恢复原始数据AOF 命令 以 Redis 协议追加保存每次写操作到文件末尾Redis 还能对 AOF 文件进行后台重写，使得 AOF 文件的体积不至于过大如果你希望你的数据在服务器运行的时候存在，也可以不使用任何持久化方式 — 只做缓存同时开启两种持久化方式。
redis缓存笔记
10-13
这份“redis缓存笔记”很可能是针对Redis在缓存场景中的应用进行深入讲解的PPT课件。 在Redis中，缓存是提升应用程序性能的关键工具。它通过将常用数据存放在内存中，减少了对硬盘的读取，从而大大提高了数据访问...
Redis缓存老师笔记
08-29
"Redis缓存老师笔记"可能包含了关于如何利用Redis优化应用程序性能、管理数据以及解决常见问题的内容。 Redis支持多种数据结构，包括字符串(Strings)、哈希(Hashes)、列表(Lists)、集合(Sets)和有序集合(Sorted ...
Redis-笔记资料，缓存
12-01
Redis是一种高性能的键值对数据存储系统，常用于构建分布式缓存、消息队列和数据库。Redis支持多种数据结构，如字符串（Strings）、哈希（Hashes）、列表（Lists）、集合（Sets）以及有序集合（Sorted Sets），这些...
redis学习笔记.pdf
02-13
Redis学习笔记 Redis是一个开源的基于键值对（Key-Value）NoSQL数据库，使用ANSI C语言编写、支持网络、基于内存但支持持久化。性能优秀，并提供多种语言的API。Redis可以被称为KV数据库，键值对数据库，内部存储...
Redis学习笔记.zip
06-06
简单来说 redis 就是一个数据库，不过与传统数据库不同的是 redis 的数据是存在内存中的，所以存写速度非常快，因此 redis 被广泛应用于缓存方向。另外，redis 也经常用来做分布式锁。redis 提供了多种数据类型来...
自制一个指定容量缓存，并实现最近使用的最后删除
ZHUSHANGLIN的博客
07-17 661
【代码】自制一个指定容量缓存，并实现最近使用的最后删除。
npm下载包-更改默认缓存目录
最新发布
kjl536566的博客
07-19 597
npm（Node Package Manager）的缓存目录是npm用于存储已下载包的本地位置，以便在后续安装相同包时能够快速复用，从而节省时间和带宽。npm缓存目录的具体位置会根据操作系统的不同而有所差异。
高性能内存对象缓存Memcached原理与部署
潇的博客
07-18 401
Memcached 是一个高性能、分布式内存对象缓存系统，主要用于减轻数据库负载、提高Web应用的响应速度和性能。其核心思想是利用内存存储数据，并通过键值对的方式快速读取。
memcached 高性能内存对象缓存
Q7758521adc的博客
07-18 718
当web服务器接收到请求需要处理动态页面元素时，通常要去数据库调用数据，但是通过memcached-api接口程序不去直接访问数据库，而去访问mamcached，再由memcached去访问数据库获取数据，获得到数据后自己缓存一分，在发送给web服务器一份，下次再进行通向的访问就不需要访问数据库，从而实现降低数据库的io压力。按组分配：每次先分配一个slab，大小相当于一个1M，在1M的这个大小内划分出等大小的chunk，该方法有效的解决了内存碎片问题，但也会因为不满足chunk的大小而造成空间浪费。
"Redis缓存老师笔记第二部分：redis数据类型详解和操作命令
Redis缓存老师笔记第二部分是关于Redis数据类型的介绍。其中第二十四天的课堂笔记首先介绍了hash数据类型。在Redis中，hash数据类型类似于Java中的HashMap，每个数据类型都由多个键值对组成，相当于在Redis中的类型...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值