redis缓存更新策略，缓存穿透，缓存雪崩，缓存击穿。封装redis工具类

已于 2023-10-29 16:37:24 修改
阅读量100 收藏 2
点赞数 2
分类专栏： redis 文章标签： 缓存 redis 数据库 java spring boot
于 2023-10-28 16:18:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/PiggyOne123/article/details/134092576
版权

redis缓存


缓存是存储数据的临时地方，一般读写性能高

1. 给商铺添加缓存

先实现基本功能

思路：
用店铺id先查询redis，命中直接返回店铺信息，不命中则查询数据库，并将查到的信息写入redis,数据库也查不到就返回错误信息image.png在对应的serviceImpl里写逻辑

@Override
public Result queryById(Long id) {
    String key = CACHE_SHOP_KEY + id;
    //1.从redis查询商铺缓存
    String shopJSON = stringRedisTemplate.opsForValue().get(key);

    if (StrUtil.isNotEmpty(shopJSON)) {
        Shop shop = BeanUtil.toBean(shopJSON, Shop.class);
        return Result.ok(shop);
    }
    //2. 未查到，查询数据库
    Shop shop2 = shopMapper.selectById(id);
    //3.判断商铺是否存在
    if (shop2 == null) {
        //4.不存在，返回404
        Result.fail("商铺不存在！");
    }
    //5. 存在，将商铺数据写入redis
    String jsonStr = JSONUtil.toJsonStr(shop2);
    stringRedisTemplate.opsForValue().set(key,jsonStr);

    //6. 返回商铺信息
    return Result.ok(shop2);
}

可以看到查询的时间比原来小了很多
image.png

2. 给商铺类型添加缓存

和查询商铺信息逻辑差不多
在对应的serviceImpl中写处理逻辑

@Override
public Result queryType() {
    //1. redis中查询商铺类型
    Long size = stringRedisTemplate.opsForList().size(CACHE_SHOP_TYPE);
    List<String> range = stringRedisTemplate.opsForList().range(CACHE_SHOP_TYPE, 0, size);
    ArrayList<ShopType> list = new ArrayList<>();
    if (range.size() > 0) {
        //2.查到直接返回
        for (String typeJSON : range) {
            if (StrUtil.isNotEmpty(typeJSON)) {
                ShopType shopType = JSONUtil.toBean(typeJSON, ShopType.class);
                list.add(shopType);
            }
        }
        return Result.ok(list);
    }

    //3. 未查到，查询数据库
    List<ShopType> shopTypes = shopTypeMapper.selectList(null);
    if (shopTypes == null) {
        Result.fail("未找到商铺类型");
    }
    //4. 存在，将商铺类型数据写入redis

    for (ShopType shopType : shopTypes) {
        String jsonStr = JSONUtil.toJsonStr(shopType);
        stringRedisTemplate.opsForList().rightPush(CACHE_SHOP_TYPE, jsonStr);
    }

    return Result.ok(shopTypes);
}

加入缓存前后时间对比：
image.png
image.png

3. 缓存更新策略

image.png
业务场景：

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

3.1 更新策略

有三种策略，推荐第一种：
也就是由缓存的调用者，在更新数据库的同时更新缓存

image.png

3.2 问题

有三个问题需要考虑：

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

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

推荐删除缓存

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

  • 单体系统，将缓存与数据库操作放在一个事务
  • 分布式系统，利用TCC等分布式事务方案

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

  • 先删除缓存，再操作数据库
  • 先操作数据库，再删除缓存

第一种

正常情况：

image.png
出现错误，即删除完缓存而数据库没更新之前就查询·生成缓存：
image.png

第二种：

正常情况：

image.png
出现错误，即缓存因未知原因被删除，查询数据库的时候数据库更新，因为没有生成缓存而无法删除缓存，用先前查到的数据库旧数据生成了缓存，导致缓存和数据库数据不匹配
image.png

第一种方案可能会导致缓存和数据库数据不匹配的情况，第二种在低概率的情况下也可能出现（发生这种情况可以加超时时间解决），所以推荐第二种

3.3 总结

缓存更新策略的最佳实践方案：
image.png

3.4 实现商铺缓存与数据库的双写一致

超时删除,在查询商铺的逻辑里添加了定时删除商铺缓存的功能

@Override
public Result queryById(Long id) {
String key = CACHE_SHOP_KEY + id;
//1.从redis查询商铺缓存
String shopJSON = stringRedisTemplate.opsForValue().get(key);

if (StrUtil.isNotEmpty(shopJSON)) {
    Shop shop = JSONUtil.toBean(shopJSON, Shop.class);
    System.err.println(shop);
    return Result.ok(shop);
}
//2. 未查到，查询数据库
Shop shop2 = shopMapper.selectById(id);
//3.判断商铺是否存在
if (shop2 == null) {
    //4.不存在，返回404
    Result.fail("商铺不存在！");
}
//5. 存在，将商铺数据写入redis
String jsonStr = JSONUtil.toJsonStr(shop2);
stringRedisTemplate.opsForValue().set(key,jsonStr,CACHE_SHOP_TTL, TimeUnit.MINUTES);

//6. 返回商铺信息
return Result.ok(shop2);
}

修改商铺时先操作数据库，再删除缓存

@Override
@Transactional
public Result updateShop(Shop shop) {
Long id = shop.getId();
if (id == null) {
    return Result.fail("商铺id不能为空！");
}
//1.操作数据库
shopMapper.updateById(shop);
//2.删除缓存
String key = CACHE_SHOP_KEY + id;
stringRedisTemplate.delete(key);
return Result.ok();
}

效果：
更新商铺信息后
image.png
可以看到，原来id为1的102茶餐厅在被我改为下北泽茶餐厅后，因为数据库更新而删除了缓存
image.png
image.png
网页刷新后，我们实现了缓存与数据库的双写一致
image.png
image.png

4. 缓存穿透

缓存穿透是指客户端请求的数据在缓存和数据库中都不存在，所以每次查询都会查询数据库，增加数据库的压力

4.1 解决方案

4.1.1 设置空对象

当客户端请求的id对象在缓存和数据库中都不存在，会在缓存中缓存一个该id的空对象，并设置一个ttl时间，以减少内存消耗，下次客户端再次请求该id时，直接在缓存中查询，但是如果在生成空对象且并未删除之后，数据库有了该id的对象，可能会造成数据短期的不一致
image.png

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

4.1.2 布隆过滤

在查询缓存之前，设置一个布隆过滤器，如果请求的id不存在，直接拒绝访问。布隆过滤器中的数据是基于哈希算法求出的二进制数据，并不是把数据库中的数据全存储在里面，相对来说内存消耗较少，但是存在误判的可能
image.png

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

推荐缓存空对象的方式

4.2 编写实现

需要改两个地方：

  1. 在数据库中查不到，要将空值写入redis
  2. 在缓存中命中，要判断是否为空，空的话直接结束，不为空再返回商铺信息

image.png

@Override
public Result queryById(Long id) {
String key = CACHE_SHOP_KEY + id;
//1.从redis查询商铺缓存
String shopJSON = stringRedisTemplate.opsForValue().get(key);

if (StrUtil.isNotBlank(shopJSON)) {
    Shop shop = JSONUtil.toBean(shopJSON, Shop.class);

    return Result.ok(shop);
}

//1.2 判断商铺数据是否为空
if (Objects.equals(shopJSON, "")) {
    return Result.fail("商铺不存在！");
}
//2. 未查到，查询数据库
Shop shop2 = shopMapper.selectById(id);
System.err.println(shop2);
//3.判断商铺是否存在
if (shop2 == null) {
    //4.在缓存中设置空值
    stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
    //5.返回错误信息
    Result.fail("商铺不存在！");
}
//5. 存在，将商铺数据写入redis
String jsonStr = JSONUtil.toJsonStr(shop2);
stringRedisTemplate.opsForValue().set(key, jsonStr, CACHE_SHOP_TTL, TimeUnit.MINUTES);

//6. 返回商铺信息
return Result.ok(shop2);
}

当我们传入一个不存在的id，缓存中会储存一个空对象
image.pngimage.png

4.3 总结

缓存穿透的解决方案

  1. 缓存空值
  2. 布隆过滤
  3. 增强id的复杂度，避免被猜到id规律
  4. 做好数据的基础格式校验
  5. 加强用户权限校验
  6. 做好热点参数的限流

5.缓存雪崩

缓存雪崩是指同一时间大量的key同时失效或者redis宕机，导致大量的请求到达数据库，带来巨大的压力
image.png
解决方案：

  • 给不同的key的TTL添加随机值
  • 利用Redis集群提高服务的可用性
  • 给缓存业务添加降级限流策略
  • 给业务添加多级缓存

6.缓存击穿

缓存击穿也叫热点key问题，与缓存雪崩不同，缓存击穿是一个高并发访问或者缓存业务复杂的key突然失效，导致无数的请求对数据库造成了巨大的冲击

解决方案：

  1. 互斥锁

image.png
查询缓存未命中的情况下，获取互斥锁，然后查询数据库重建缓存数据，再写入缓存之前如果又有请求来查询缓存，就会获取互斥锁失败，为了防止他一直重试，会让他休眠一会再重试，直到写入缓存成功释放了锁，才能缓存命中

  1. 逻辑删除

image.png
在存入缓存时不设置ttl，而是假如一个字段表示过期时间
查询缓存发现逻辑时间已经过期时。获取互斥锁并开启一个全新的线程，去查询数据库并写入缓存和重置过期时间，原线程直接返回过期数据，再写入缓存之前来查询的的其他线程，发现获取互斥锁失败会直接返回过期数据，写入缓存并释放锁之后，来查询的线程才能命中

优缺点：
image.png

互斥锁，大量的请求会一直等待，影响性能，并且有死锁的风险，牺牲可用性

逻辑过期，无需等待直接返回过期时间，并且有额外的内存消耗，牺牲一致性

6.1 基于互斥锁方式解决缓存击穿问题

image.png

按照流程图，缓存未命中时尝试获取互斥锁，获取不到就休眠并重新查询，能获取到就查数据库，写缓存，最后释放互斥锁

private Shop queryWithMutex(Long id) {
Shop shop2 = null;

String key = CACHE_SHOP_KEY + id;
//1.从redis查询商铺缓存
String shopJSON = stringRedisTemplate.opsForValue().get(key);

if (StrUtil.isNotBlank(shopJSON)) {
    Shop shop = JSONUtil.toBean(shopJSON, Shop.class);
    return shop;
}

//1.2 判断商铺数据是否为空
if (Objects.equals(shopJSON, "")) {
    return null;
}

//2.获取互斥锁
String lockKey = LOCK_SHOP_KEY + id;

try {
    boolean flag = tryLock(lockKey);
    //3.判断是否获取锁
    if (!flag) {
        //没获取到就休眠
        Thread.sleep(50);
        //递归，直到获取到锁
        return queryWithMutex(id);
    }
    //4. 未查到，查询数据库
    shop2 = shopMapper.selectById(id);
    //模拟重建的延时
    Thread.sleep(200);
    //5.判断商铺是否存在
    if (shop2 == null) {
        //5.1 在缓存中设置空值
        stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
        //5.2 返回错误信息
        return null;
    }
    //6. 存在，将商铺数据写入redis
    String jsonStr = JSONUtil.toJsonStr(shop2);
    stringRedisTemplate.opsForValue().set(key, jsonStr, CACHE_SHOP_TTL, TimeUnit.MINUTES);


} catch (InterruptedException e) {
    throw new RuntimeException(e);
} finally {
    //7.释放互斥锁
    destroyLock(lockKey);

}
//8. 返回商铺信息
return shop2;

}

使用jmeter测试工具测试，分别对商铺1和商铺2请求查询1000次：
image.png
可以看到请求全部通过了
image.png
吞吐量
image.png
只执行了两次查询数据库的操作，商铺1一次，商铺2一次
image.png
redis中有对应的数据

6.2 基于逻辑过期方式解决缓存击穿问题

image.png
如果缓存命中，要判断缓存是否过期，不过期直接返回数据，过期要尝试获取互斥锁，没获取到返回旧数据，获取到要开启独立线程，在新线程中写入缓存并设置逻辑过期时间，释放互斥锁，最后返回商铺信息

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



private Shop queryWithLogicalExpire(Long id) {

String key = CACHE_SHOP_KEY + id;
//1.从redis查询商铺缓存
String shopJSON = stringRedisTemplate.opsForValue().get(key);

if (StrUtil.isBlank(shopJSON)) {

    return null;
}

//2.命中，需要把json反序列化为对象
RedisData redisData = JSONUtil.toBean(shopJSON, RedisData.class);
Shop shop = JSONUtil.toBean((JSONObject) redisData.getData(), Shop.class);
LocalDateTime expireTime = redisData.getExpireTime();
//3.判断是否过期
if (expireTime.isAfter(LocalDateTime.now())) {
    //3.1 未过期，直接返回商铺信息
    return shop;
}

//5.2 已过期，需要缓存重建
//6.缓存重建
//6.1 获取互斥锁
String lockKey = LOCK_SHOP_KEY + id;
boolean flag = tryLock(lockKey);
//6.2 判断是否获取锁成功
if (flag) {
    if (expireTime.isAfter(LocalDateTime.now())) {
        //3.1 未过期，直接返回商铺信息
        return shop;
    }
    //6.3 商铺信息过期，获取锁成功，开启独立线程，实现缓存重建
    CACHE_REBUILD_EXECUTOR.submit(() -> {
        try {
            //重建缓存
            this.saveShop2Redis(id, 20L);
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            //释放锁
            destroyLock(lockKey);
        }

    });
}
//6.4 返回过期的商铺信息
return shop;
}

事先将数据库中的id为1的商铺名字改为下北泽2餐厅
使用jmeter测试工具测试，对商铺1请求查询100次：
image.png
image.png
可以看到，刚开始查的还是旧数据，后面才变成新数据
image.png
只发送了一次请求

7.封装redis工具类

image.png
难点：使用了java中的函数式编程思想

package com.hmdp.utils;

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

    /**
     * 加入缓存并设置ttl过期时间
     * 
     * @param key
     * @param value
     * @param time
     * @param unit
     */
    public void set(String key, Object value, Long time, TimeUnit unit) {
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value), time, unit);
    }


    /**
     * 热点key缓存重建
     * 
     * @param key
     * @param value
     * @param time
     * @param 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));
    }

    /**
     * 解决缓存穿透
     * @param keyPrefix
     * @param id
     * @param type
     * @param dbFallback
     * @param time
     * @param unit
     * @return
     * @param <R>
     * @param <ID>
     */
    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;
    }

    /**
     * 逻辑过期解决缓存击穿
     * @param keyPrefix
     * @param id
     * @param type
     * @param dbFallback
     * @param time
     * @param unit
     * @return
     * @param <R>
     * @param <ID>
     */
    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;
    }

    /**
     * 互斥锁解决缓存击穿
     * 
     * @param keyPrefix
     * @param id
     * @param type
     * @param dbFallback
     * @param time
     * @param unit
     * @return
     * @param <R>
     * @param <ID>
     */
    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;
    }

    /**
     * 获取互斥锁
     * @param key
     * @return
     */
    private boolean tryLock(String key) {
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
        return BooleanUtil.isTrue(flag);
    }

    /**
     * 释放互斥锁
     * @param key
     */
    private void unlock(String key) {
        stringRedisTemplate.delete(key);
    }
}
PiggyOne123
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Redis 缓存穿透、缓存击穿工具类资源
09-07
Redis 缓存穿透的处理（缓存空值） Redis缓存击穿处理（互斥锁与逻辑删除方案） 封装为工具类，并适用于所有需要进行缓存穿透、击穿的方案，采用了泛型以及Lambda 函数式编程来完成编码
封装好的 Redis 工具类
03-18
老师传授的 Redis 工具类，配备中文文档注释，搭配对 Redis 的理解和业务需求，在 Java 中灵活使用 Redis 作缓存中间件开发。 若资源存在问题，请私信我。
SpringBoot 整合 Redis、mybatis 完整项目源码下载
05-26
SpringBoot整合Redis源码 mybatis实战源码 封装RedisUtils工具类源码 redis缓存mybatis数据源码
XCYN：记录了常用的工具类和一些的Demo
02-01
简要概述电子书读书笔记XCYN.Common封装了SQLServer工具类，redis / mongoDB的常用接口，缓存，农历，加密/解密，邮件，JSON，XML，请求，验证，串行转换等工具类XCYN.MVC ASP.NET MVC中路由，布局，应用控制反转...
springboot+redis+mybatis事务和引擎模板
09-27
springboot项目集合了mybatis分页查询和dbcp数据源配置，使用redis缓存都有详细的配置测试方法，封装的工具类常用的集合、对象、设置超时时间和判断key是否存在等详细方法
【优化】强缓存和协商缓存
m0_61049675的博客
05-14 291
总结来说，强缓存和协商缓存各有优缺点。强缓存可以在缓存未过期的情况下直接使用本地缓存，减少网络传输开销；而协商缓存则需要与服务器进行验证以确定是否使用缓存。在实际应用中，可以根据具体需求和场景选择适合的缓存策略。
redis试题按知识点归类(三)
u012728971的博客
05-13 144
十一、发布/订阅 1.Redis 的发布/订阅模型是如何工作的？ 2.如何使用 Redis 作为消息队列？ 3.发布/订阅在实际应用中有哪些用例？ 十二、缓存策略 1.如何确定 Redis 的缓存策略？ 2.Redis 的缓存替换策略有哪些？ 3.如何使用 Redis 作为缓存层？ 十三、客户端与生态系统 1.Redis 支持哪些编程语言的客户端？ 2.Redisson 和 Jedis 有什么不同？ 3.如何使用 Redis 模块？ 十四、运维与管理 1.如何监控和管理 Redis
【Linux】Centos7安装Redis
m0_72166275的博客
05-17 314
Reid 官网下载 Redis 7.2。
Redis-集群方案
A的博客
05-14 868
Cluster分片集群 : 多主多从 , 解决高并发写的问题, , Cluster 它将数据分片存储到多个节点上，并通过集群间的消息通信(PING命令)来实现数据的自动迁移和故障转移。哨兵（Sentinel）集群 : 主从集群的结构之上 , 加入了哨兵用于监控集群状态 , 主节点出现故障, 执行主从切换 , 解决高可用问题，每个 Sentinel 进程都会监控一组 Redis 实例，并通过投票选举出新的主节点。解决高并发读的问题，主节点负责写操作，从节点复制主节点的数据，并提供读服务。
Redis04持久化操作
a12jggfdd的博客
05-15 313
Redis持久化操作内容的学习。
windows设置Redis服务后台自启动
m0_73774439的博客
05-15 632
windows设置Redis服务后台自启动
基于Redis实现的一个编码生成器
weixin_53390884的博客
05-17 199
【代码】基于Redis实现的一个编码生成器。
安装docker版redis并挂载配置文件redis.conf
最新发布
小杰玩编程
05-17 199
默认情况下，启动docker redis容器没有redis.conf配置文件。因此这里用docker compose来启动容器，下面以redis5.0为例。
Redis笔记 -- 持久化之RDB
Kaiser__的博客
05-17 528
RDB个人理解就是每隔一定的时间就将目前Redis中的数据写到磁盘上，这样，即使Redis宕机，在重连后也可以继续加载数据。无法保证将所有的数据都进行备份。假如每分钟备份一次，那么如果在半分钟的时候宕机，这时，磁盘数据中就只有上个分钟的数据，最近的这半分钟数据还没有来得及备份。RDB在进行持久化时，需要调用fork()。虽然fork同步速度比较快，但是当数据量比较大的时候，也会对Redis的性能产生影响。
【从零开始学习Redis | 第十一篇】快速介绍Redis持久化策略
fckbb的博客
05-14 1015
Redis 作为一种快速、高效的内存数据库，被广泛应用于缓存、消息队列、会话存储等场景。然而，由于其特性是基于内存的，一旦服务器进程退出，内存中的数据就会丢失。为了解决这一问题，Redis 提供了持久化功能，可以将内存中的数据保存到硬盘上，以便在服务器重启时恢复数据。持久化是 Redis 的关键特性之一，对于确保数据的安全性和可靠性至关重要。本文将深入探讨 Redis 的持久化策略，包括常用的持久化方式以及各自的优缺点。
Redis详解（二）
软软的铲屎官的博客
05-13 1073
原子性（Atomicity）原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。一致性（Consistency）事务前后数据的完整性必须保持一致。隔离性（Isolation）多个事务并发执行时，一个事务的执行不应影响其他事务的执行持久性（Durability）持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来即使数据库发生故障也不应该对其有任何影响Redis的事务总是具有ACID中的一致性和隔离性，其他特性是不支持的。
【Redis7】10大数据类型之Bitfield类型
云泽野の编程日记
05-14 623
Bitfield(位域)命令可以将一个 Redis 字符串看作是一个由二进制位组成的数组， 并对这个数组中任意偏移进行访问。BITFIELD 命令的作用在于它能够将很多小的整数储存到一个长度较大的位图中，又或者将一个非常庞大的键分割为多个较小的键来进行储存，从而非常高效地使用内存，使得 Redis 能够得到更多不同的应用 --特别是在实时分析领域:BITFIELD 能够以指定的方式对计算溢出进行控制的能力，使得它可以被应用于这一领域。Bitfield功能就是: 位域修改+溢出控制。
Redis日常维护流程及技巧：确保稳定性与性能
weixin_42132035的博客
05-13 655
在数字世界中，数据是宝贵的资产。尤其对于Redis这样的高性能数据库，确保数据的安全性和访问控制的有效性是维护数据价值的关键。通过上述的数据加密、访问控制、审计日志、数据持久化和备份等措施，可以建立起一道坚固的防线，保护Redis数据库中的数据安全，防止未授权访问和潜在的数据泄露风险。记住，强大的访问控制和数据安全机制，是保障Redis数据库持久稳定运行的基石。日志管理是Redis运维中不可或缺的一环。通过合理配置日志级别、输出、轮转和分析，我们可以确保Redis实例的健康运行，及时发现并解决问题。
Redis Cluster 集群搭建
weixin_44512485的博客
05-17 312
依此类推，为每个实例创建配置文件，并修改相应的端口号和目录。此命令会输出所有节点的状态及其角色。在运行该命令后，会有提示确认，输入。
java redis缓存工具类_redis工具类-JedisUtil
05-18
JedisUtil是一个Java Redis缓存工具类，它封装了Jedis客户端的基本操作，使得使用Redis缓存更加简单方便。 以下是JedisUtil的示例代码： ``` import redis.clients.jedis.Jedis; import redis.clients.jedis.Jedis...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值