【Redis】Redis 的学习教程（六）Redis 的缓存问题

最新推荐文章于 2024-05-08 13:21:41 发布
最新推荐文章于 2024-05-08 13:21:41 发布
阅读量540 收藏
点赞数
分类专栏： Redis 文章标签： redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sco5282/article/details/132534722
版权

在服务端中，数据库通常是业务上的瓶颈，为了提高并发量和响应速度，我们通常会采用 Redis 来作为缓存，让尽量多的数据走 Redis 查询，不直接访问数据库。

同时 Redis 在使用过程中（高并发场景下）也会出现各种各样的问题，面对这些问题我们该如何处理：

  • 缓存穿透
  • 缓存击穿
  • 缓存雪崩
  • 缓存污染
  • 数据一致性

1. 缓存穿透

缓存穿透：当缓存和数据中都没有对应记录，但是客户端却一直在查询，导致所有的查询压力全部给到了数据库。

比如：黑客攻击系统，不断的去查询系统中不存在的用户，查询时先走缓存，缓存中没有，再去查数据库；或者电商系统中，用户搜索某类商品，但是这类商品再系统中根本不存在，这次的搜索应该直接返回空

解决方案：

  1. 网关层增加校验，进行用户鉴权，黑名单控制，接口流量控制
  2. 对于同一类查询，如果缓存和数据库都没有获取到数据，那么可用用一个空缓存记录下来，设置过期时间（如：5s），下次遇到同类查询，直接取出缓存中的空数据返回即可

比如：查询一个用户：先查询缓存中是否存在该用户，如果存在则直接返回。否则，再查询数据库，并将查询结果进行缓存

@GetMapping("/queryById")
public User queryById(Integer id) {
    String userKey = "user:" + id;
    Object obj = redisUtil.get(userKey);
    if (Objects.nonNull(obj)) {
        return (User)obj;
    }
    User user = userService.getById(id);
    if (Objects.isNull(user)) {
        throw new RuntimeException("该用户不存在");
    }
    redisUtil.set(userKey, user);
    return user;
}

如果项目的并发量不大，这样写的话几乎没啥问题。

如果项目的并发量很大，那么这就存在一个隐藏问题：如果在访问了一个不存在的用户（这个用户已经在后台可能是被删除)，那么就会导致所有的请求全部需要到数据库中进行查询，从而给数据库造成压力,甚至造成宕机

解决方案：缓存空对象

针对缓存穿透问题缓存空对象可以有效避免所产生的影响，当查询一条不存在的数据时，在缓存中存储一个空对象并设置一个过期时间(设置过期时间是为了避免出现数据库中存在了数据但是缓存中仍然是空数据现象)，这样可以避免所有请求全部查询数据库的情况

@GetMapping("/queryById")
public User queryById(Integer id) {
    String key = "user::" + id;
    Object obj = redisUtil.get(userKey);
    if (Objects.nonNull(obj)) {
        return (User)obj;
    }
    User user = userService.getById(id);
    if (Objects.isNull(user)) {
        // 缓存空对象
        redisUtil.set(userKey, "", 5L);
    } else {
        redisUtil.set(userKey, user);
    }
    return user;
}

缺点：在于无论数据存不存在都需要查询一次数据库，并且 Redis 中存储了大量的空数据。

这个时候可以采用布隆过滤器来解决

  1. 使用布隆过滤器，布隆过滤器可以用来判断某个元素是否存在于集合中，利用布隆过滤器可以过滤掉一大部分无效请求

布隆过滤器（Bloom Filter）是一种数据结构，用于快速检查一个元素是否属于某个集合中。它可以快速判断一个元素是否在一个大型集合中，且判断速度很快且不占用太多内存空间

布隆过滤器的主要原理：

使用一组哈希函数，将元素映射成一组位数组中的索引位置。当要检查一个元素是否在集合中时，将该元素进行哈希处理，然后查看哈希值对应的位数组的值是否为1。如果哈希值对应的位数组的值都为1，那么这个元素可能在集合中，否则这个元素肯定不在集合中。由于哈希函数的映射可能会发生冲突，因此布隆过滤器可能会出现误判

布隆过滤器的实现：

在使用布隆过滤器时有两个核心参数，分别是预估的数据量size以及期望的误判率fpp，这两个参数我们可以根据自己的业务场景和数据量进行自主设置

在实现布隆过滤器时，有两个核心问题，分别是 hash 函数的选取个数 n 、确定 bit 数组的大小 len：

  1. 根据预估数据量 size 和误判率 fpp，可以计算出 bit 数组的大小 len
    在这里插入图片描述

  2. 根据预估数据量 size 和 bit 数组的长度大小 len，可以计算出所需要的 hash 函数个数 n
    在这里插入图片描述

1. 单机版布隆过滤器

目前单机版的布隆过滤器实现方式有很多：Guava 提供的 BloomFilter，Hutool 工具包中提供的 BitMapBloomFilter 等

这里以 Guava 为例，引入依赖：

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>21.0</version>
</dependency>

布隆过滤器工具类：闯将布隆过滤器

public class BloomFilterUtil {

    public static BloomFilter<Integer> localBloomFilter =  BloomFilter.create(Funnels.integerFunnel(),10000L,0.01);

}

将需要筛选的数据同步到过滤器中

// 单机版布隆过滤器数据初始化
@PostConstruct
public void initUserDataLocal(){
    List<User> users = userService.lambdaQuery().select(User::getId).list();
    if(!CollectionUtils.isEmpty(users)){
        users.stream().map(User::getId).forEach(id -> BloomFilterUtil.localBloomFilter.put(id));
    }
}

使用布隆过滤器：

@GetMapping("/queryById")
public User queryById(Integer id) {
    boolean mightContain = BloomFilterUtil.localBloomFilter.mightContain(id);
    //是否有可能存在于布隆过滤器中
    if(!mightContain) {
        log.info("==== select from bloomFilter , data not available ====");
        return null;
    }
    String userKey = "user:" + id;
    // ...
}
2. 自定义分布式版布隆过滤器

自定义分布式布隆过滤器的存储依赖于 Redis 的 Bitmap 数据结构来实现，另外还需要定义四个参数，分别为预估数据量 size,误判率 fpp,数组大小 bitNum 以及 hash 函数个数 hashNum。其中，预估数据量和误判率需要配置在 yml 文件中。

application.yml

bloom:
  filter:
    size: 10000
    fpp: 0.01

布隆过滤器工具类：

@Component
public class BloomFilterUtil {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 预估数据量
     */
    @Value("${bloom.filter.size}")
    private long size;

    /**
     * 误判率
     */
    @Value("${bloom.filter.fpp}")
    private double fpp;

    /**
     * 数组大小len
     */
    private long bitNum;

    /**
     * hash函数个数size
     */
    private int hashNum;

    @PostConstruct
    private void initBloom() {
        this.bitNum = getNumOfBits(size, fpp);
        this.hashNum = getNumOfHashFun(size, bitNum);
        //借助 Redis 的 Bitmap 来实现二进制数组
        redisTemplate.opsForValue().setBit("bloom::filter", bitNum, false);
    }
    
    /**
     * 计算bit数组大小
     * 
     * @author zzc
     * @date 2023/8/30 15:15 
     * @param size
     * @param fpp 
     * @return long
     */
    private long getNumOfBits(long size, double fpp) {
        return (long) (-size * Math.log(fpp) / (Math.log(2) * Math.log(2)));
    }
    
    /**
     * 计算所需的hash个数
     * 
     * @author zzc
     * @date 2023/8/30 15:15 
     * @param size
     * @param numOfBits 
     * @return int
     */
    private int getNumOfHashFun(long size, long numOfBits) {
        return Math.max(1, (int) Math.round((double) numOfBits / size * Math.log(2)));
    }

    /**
     * 向自定义布隆过滤器中添加元素
     *
     * @author zzc
     * @date 2023/8/30 15:17
     * @param key
     */
    public void putBloomFilterRedis(String key) {
        long hash64 = HashUtil.metroHash64(key.getBytes());
        int hash1 = (int) hash64;
        int hash2 = (int) (hash64 >>> 32);
        for (int i = 1; i <= hashNum; i++) {
            /**
             *   上面不是说，要使用n个hash函数吗？？为啥这里直接用一个动态变量取乘积了呢？？？
             *  不用担心，请看《Less Hashing, Same Performance: Building a Better Bloom Filter》，
             *  里面论述了这种操作不会影响布隆过滤器的性能，毕竟hash的代价还是很大的，这算是个有效的优化手段吧：
             *    A standard technique from the hashing literature is to use two hash
             *    functions h(x) and h(x) to simulate additional hash functions of the form g(x) = h(x) + ih(x) .
             */
            int combinedHash = hash1 + i * hash2;
            if (combinedHash < 0) {
                //如果为负数，则取反（保证结果为正数）
                combinedHash = ~combinedHash;
            }
            // 计算出数组下标，并将下标值置为1
            int bitIdx = (int) (combinedHash % bitNum);
            redisTemplate.opsForValue().setBit("bloom::filter", bitIdx, true);
        }
    }

    /**
     * 判断自定义布隆过滤器中元素是否有可能存在
     *
     * @author zzc
     * @date 2023/8/30 15:16
     * @param key
     * @return boolean
     */
    public boolean existBloomFilterRedis(String key) {
        long hash64 = HashUtil.metroHash64(key.getBytes());
        int hash1 = (int) hash64;
        int hash2 = (int) (hash64 >>> 32);
        for (int i = 1; i <= hashNum; i++) {
            int combinedHash = hash1 + i * hash2;
            if (combinedHash < 0) {
                combinedHash = ~combinedHash;
            }
            int bitIdx = (int) (combinedHash % bitNum);
            //判断下标值是否为1，如果不为1直接返回false
            Boolean bit = redisTemplate.opsForValue().getBit("bloom::filter", bitIdx);
            if (!bit) {
                return false;
            }
        }
        return true;
    }

}

使用布隆过滤器：

@Slf4j
@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;

    @Autowired
    private RedisUtil redisUtil;

    @Autowired
    private BloomFilterUtil bloomFilterUtil;

    @GetMapping("/queryById")
    public User queryById(Integer id) {
        String key = "user::" + id;
        boolean mightContain = bloomFilterUtil.existBloomFilterRedis(key);
        //是否有可能存在于布隆过滤器中
        if(!mightContain) {
            log.info("==== select from bloomFilter , data not available ====");
            return null;
        }
        Object obj = redisUtil.get(key);
        // ...
    }


    /**
     * 单机版布隆过滤器数据初始化
     * 
     * @author zzc
     * @date 2023/8/30 14:44  
     */
    @PostConstruct
    public void initUserDataLocal(){
        List<User> users = userService.lambdaQuery().select(User::getId).list();
        if (!CollectionUtils.isEmpty(users)) {
            users.stream().map(user -> "user::" + user.getId()).forEach(id -> bloomFilterUtil.putBloomFilterRedis(id));
        }
    }

}

不存在的数据成功被拦截掉了，避免再去查询数据库,即使存在一定的误判率，也几乎不会有啥影响，最多就是查询一次数据库

虽然布隆过滤器可以有效的解决缓存穿透问题，并且实现的算法查找效率也很快。但是，也存在一定的缺点，由于存在 hash 冲突的原因，一方面存在一定的误判率(某个在过滤器中并不存在的 key，但是通过 hash 计算出来的下标值都为 1)。另一方面，删除比较困难(如果将一个数组位置为0，那么这个位置有可能也代表其他 key 的值，会影响到其他的 key)

2. 缓存击穿

缓存击穿：缓存中某个热点数据失效，在高并发情况下，所有用户的请求全部都打到数据库上，短时间造成数据库压力过大

解决方案：

  1. 接口限流、熔断
  2. 热点数据不设置过期时间：适用于不严格要求缓存一致性的场景
  3. 互斥锁，当第一个用户请求到时，如果缓存中没有，其他用户的请求先锁住，第一个用户查询数据库后立即缓存到 Redis，然后释放锁，这时候其他用户就可以直接查询缓存

如果是单机部署的环境下可以使用 synchronized 或 lock 来处理，保证同时只能有一个线程来查询数据库，其他线程可以等待数据缓存成功后在被唤醒，从而直接查询缓存即可。如果是分布式部署，可以采用分布式锁来实现互斥

互斥锁工具类：

@Component
public class RedisLockUtil {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 模拟互斥锁
     * @author zzc
     * @date 2023/8/30 16:29 
     * @param key
     * @param value
     * @param exp 
    * @return boolean
     */
    public boolean tryLock(String key, String value, long exp) {
        Boolean absent = redisTemplate.opsForValue().setIfAbsent(key, value, exp, TimeUnit.SECONDS);
        if (Boolean.TRUE.equals(absent)) {
            return true;
        }
        // 如果线程没有获取锁，则在此处循环获取
        return tryLock(key, value, exp); 
    }

    /**
     * 释放锁
     * 
     * @author zzc
     * @date 2023/8/30 16:29 
     * @param key
     * @param value 
     */
    public void unLock(String key, String value) {
        Object obj = redisTemplate.opsForValue().get(key);
        if (Objects.nonNull(obj) && (StrUtil.equals((String) obj, value))) {
            // 避免锁被其他线程误删
            redisTemplate.delete(key);
        }
    }
    
}

使用互斥锁：在查询数据库前进行加锁，读取完成后在释放锁

@Slf4j
@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;

    @Autowired
    private RedisUtil redisUtil;

    @Autowired
    private BloomFilterUtil bloomFilterUtil;
    
    @Autowired
    private RedisLockUtil redisLockUtil;

    @GetMapping("/queryById")
    public User queryById(Integer id) {
        String key = "user::" + id;
        boolean mightContain = bloomFilterUtil.existBloomFilterRedis(key);
        //是否有可能存在于布隆过滤器中
        if(!mightContain) {
            log.info("==== select from bloomFilter , data not available ====");
            return null;
        }
        Object obj = redisUtil.get(key);
        if (Objects.nonNull(obj)) {
            log.info("==== select from cache ====");
            return (User)obj;
        }
        // 给锁加个标识，避免误删
        String s = UUID.randomUUID().toString();
        String lockKey = key + "::lock";
        //尝试加锁
        boolean lock = redisLockUtil.tryLock(lockKey, s, 60);
        User user = null;
        if (lock) {
            try {
                // 如果加锁成功，先再次查询缓存，有可能上一个线程查询并添加到缓存了
                obj = redisUtil.get(key);
                if (Objects.nonNull(obj)) {
                    log.info("==== select from cache ====");
                    return (User)obj;
                }
                log.info("==== select from db ====");
                user = userService.getById(id);
                if (Objects.nonNull(user)) {
                    redisUtil.set(key, user, 5);
                }
            } finally {
                // 解锁
                redisLockUtil.unLock(lockKey, s);
            }
        }
        return user;
    }


    /**
     * 单机版布隆过滤器数据初始化
     * 
     * @author zzc
     * @date 2023/8/30 14:44  
     */
    @PostConstruct
    public void initUserDataLocal(){
        List<User> users = userService.lambdaQuery().select(User::getId).list();
        if (!CollectionUtils.isEmpty(users)) {
            users.stream().map(user -> "user::" + user.getId()).forEach(id -> bloomFilterUtil.putBloomFilterRedis(id));
        }
    }

}

3. 缓存雪崩

缓存雪崩：对热点数据设置了相同的过期时间，在同一时间这些热点数据key大批量发生过期，请求全部转发到数据库，从而导致数据库压力骤增，甚至宕机

与缓存击穿不同，击穿是指一个 key 过期，雪崩是指很多 key 同时过期。

解决方案：

  1. 缓存过期时间设置随机的过期时间
if (Objects.nonNull(user)) {
    //生成一个随机数
    int randomInt = RandomUtil.randomInt(2, 10);
    redisUtil.set(key, user, 5 + randomInt);
}
  1. 缓存过期时间不设置过期时间：在更新数据库数据时，同时也需要更新缓存数据。适用于不严格要求缓存一致性的场景
  2. 搭建高可用集群：缓存服务故障时，也会触发缓存雪崩，为了避免因服务故障而发生的雪崩，推荐使用高可用的服务集群，这样即使发生故障，也可以进行故障转移

4. 缓存污染

缓存污染：由于历史原因，缓存中有很多 key 没有设置过期时间，导致很多 key 其实已经没有用了，但是一直存放在 redis 中，时间久了，redis 内存就被占满了

解决方案：

  1. 缓存尽量设置过期时间
  2. 设置缓存淘汰策略为最近最少使用的原则，然后将这些数据删除

5. 数据一致性

通常情况下，使用缓存的直接目的是为了提高系统的查询效率，减轻数据库的压力。一般情况下使用缓存是下面这几步骤：

  1. 查询缓存，数据是否存在
  2. 如果数据存在，直接返回
  3. 如果数据不存在，再查询数据库
  4. 如果数据库中数据存在，那么将该数据存入缓存并返回。如果不存在，返回空

这么搞好像看上去并没有啥问题，那么会有一个细节问题：当一条数据存入缓存后，立刻又被修改了，那么这个时候缓存该如何更新呢。不更新肯定不行，这样导致了缓存中的数据与数据库中的数据不一致。

一般情况下对于缓存更新有以下情况：

  • 先更新缓存，再更新数据库
  • 先更新数据库，再更新缓存
  • 先删除缓存，再更新数据库
  • 先更新数据库，再删除缓存
1、先更新缓存，再更新数据库

先更新缓存，再更新数据库：如果业务执行正常，不出现网络等问题，这么操作不会有啥问题，两边都可以更新成功。

但是，如果缓存更新成功了，但是当更新数据库时或者在更新数据库之前出现了异常，导致数据库无法更新。这种情况下，缓存中的数据变成了一条实际不存在的假数据。

2、先更新数据库，再更新缓存

这种情况跟上面情况基本一致。如果失败，会导致数据库中是最新的数据，缓存中是旧数据。

还有一种极端情况：在高并发情况下容易出现数据覆盖的现象：A 线程更新完数据库后，在要执行更新缓存的操作时，线程被阻塞了，这个时候线程 B 更新了数据库并成功更新了缓存，当 B 执行完成后线程A继续向下执行，那么最终线程 B 的数据会被覆盖。

3、先删除缓存，再更新数据库

先删除缓存，再更新数据库这种情况，如果并发量不大用起来不会有啥问题。但是在并发场景下会有这样的问题：线程 A 在删除缓存后，在写入数据库前发生了阻塞。这时线程 B 查询了这条数据，发现缓存中不存在，继而向数据库发起查询请求，并将查询结果缓存到了 Redis。当线程 B 执行完成后，线程 A 继续向下执行更新了数据库，那么这时缓存中的数据为旧数据，与数据库中的值不一致

4、先更新数据库，再删除缓存

先更新数据库，再删除缓存也并不是绝对安全的。在高并发场景下，如果线程 A 发起读请求：查询一条在缓存中不存在的数据(这条数据有可能过期被删除了)，查询数据库后在要将查询结果缓存到 Redis 时发生了阻塞。这个时候线程 B 发起了更新请求：先更新了数据库，再次删除了缓存。当线程 B 执行成功后，线程 A 继续向下执行，将查询结果缓存到了 Redis 中，那么此时缓存中的数据与数据库中的数据发生了不一致。

解决数据不一致方案

延时双删

延时双删：延时双删，即在写数据库之前删除一次，写完数据库后，再删除一次，在第二次删除时，并不是立即删除，而是等待一定时间在做删除

这个延时的功能可以使用 mq 来实现，这里为了省事，偷个懒，本地测试使用的延时队列来模拟 mq 达到延时效果。

1、定义一个队列元素对象 DoubleDeleteTask：

@Data
public class DoubleDeleteTask implements Delayed {

    /**
     * 需要删除的key
     */
    private String key;

    /**
     * 需要延迟的时间 毫秒
     */
    private long time;

    public DoubleDeleteTask(String key, long time) {
        this.key = key;
        this.time = time;
    }

    @Override
    public long getDelay(TimeUnit unit) {
        return unit.convert(time - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
    }

    @Override
    public int compareTo(Delayed o) {
        return Long.compare(time, ((DoubleDeleteTask) o).time);
    }

}

2、定义一个队列并交给 Spring 管理：

@Configuration
public class DoubleDeleteQueueConfig {

    @Bean(name = "doubleDeleteQueue")
    public DelayQueue<DoubleDeleteTask> doubleDeleteQueue() {
        return new DelayQueue<>();
    }

}

3、设置一个独立线程，特意用来处理延时的任务：

@Slf4j
@Component
public class DoubleDeleteTaskRunner implements CommandLineRunner {

    @Resource
    private DelayQueue<DoubleDeleteTask> doubleDeleteQueue;

    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 失败重试次数
     */
    private static final int RETRY_COUNT = 3; 

    @Override
    public void run(String... args) {
        Runnable runnable = () -> {
            try{
                while (true) {
                    DoubleDeleteTask doubleDeleteTask = doubleDeleteQueue.take();
                    String key = doubleDeleteTask.getKey();
                    try {
                        redisTemplate.delete(key);
                        log.info("====延时删除key:{}====", key);
                    } catch (Exception e) {
                        int count = 1;
                        for (int i = 1; i <= RETRY_COUNT; i++) {
                            if (count < RETRY_COUNT) {
                                log.info("====延时删除key:{},失败重试次数：{}====", key, count);
                                Boolean aBoolean = redisTemplate.delete(key);
                                if (aBoolean) {
                                    break;
                                } else {
                                    count++;
                                }
                            } else {
                                break;
                            }
                        }
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        };
        new Thread(runnable, "double-delete-task").start();
    }
}

如果数据删除失败，可以自定义重试次数以保证数据的一致性，但是也会带来一定的性能影响，如果在实际项目中，建议还是以异步的方式来实现重试。

4、使用延时队列，处理延时双删：

 @Autowired
private DelayQueue<DoubleDeleteTask> doubleDeleteTask;

@PostMapping("/update")
public String update(@RequestBody User user) {
    String key = "user::" + user.getId();
    // 更新缓存
    redisUtil.set(key, JSON.toJSONString(user), 5);
    // 更新数据库
    userService.updateById(user);
    // 延迟删除缓存
    doubleDeleteTask.add(new DoubleDeleteTask(key, 2000L));
    return "update";
}

最后

在高并发的场景下，使用 Reids 还是存在很多坑的，稍不注意就会出现缓存穿透，缓存雪崩等情况，严重的话可以直接造成服务宕机。所以，在以后的开发中需要注意(如果项目没啥并发量的话，可以不用考虑)

sco5282
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
redis缓存 redis缓存
06-11
redis缓存 redis缓存
redis本地缓存与redis缓存
02-14
redis本地缓存与redis缓存
Redis一些基本问题整理
热门推荐
张彦峰的博客
04-07 170万+
对Redis一些重点内容进行整理总结用于查缺补漏
Windows 下 Redis 安装与配置 教程
小青龍 的博客
06-14 14万+
Windows下Redis安装与配置教程，Windows下安装Redis的几种方式，msi安装包安装，zip安装包安装。使用SC命令，手动创建Redis服务及注册表服务项，实现Redis服务后台运行及服务自启动。Redis服务配置查看及修改，Redis服务各配置项简要说明。
redis 清理缓存
weixin_28947667的博客
07-04 1万+
方法2，清缓存前确保redis-server.exe进程已经启动，然后打开redis-cli.exe，跳出的CMD里面输入flushall，显示OK就可以了。2、执行./redis-cli或者./redis-cli -h 127.0.0.1 -p 6379。flushall：清空整个redis 服务器的数据(删除所有数据库的所有 key )。flushdb：清空当前数据库中的所有 key。方法1，重启redis也能请缓存。方法6，还有定时清理，具体百度。4、执行：flushall命令。
redis缓存失效问题
weixin_53050118的博客
09-21 2084
一个正常的访问流程1.缓存雪崩：redis缓存key同一时间大量失效，导致大量请求全部打到数据库，造成数据库挂掉。1.设置缓存的失效时间，让它2不在同一时间失效。在设置缓存的时候，随机初始化失效时间。这样就能避免缓存在同一时间失效,把所有请求都打到数据上。2.redis一般都是集群部署，可以将热点key放到不同的节点上。让热点的缓存，平均的分布在不同的节点上。3.不设置缓存失效时间，使其永远不失效。4.去跑定时任务，让它定时刷新缓存，避免缓存失效。2.缓存穿透。
redis清理缓存
娜可璐璐的博客
10-28 3万+
redis清理缓存
【Redis篇】Redis缓存之缓存雪崩
qq_40980718的博客
06-07 1590
本篇详细介绍了Redis缓存中的缓存雪崩的情况，包括一些解决方案
Redis安装教程（超详细）
X_lsod的博客
03-03 17万+
Redis 一、Redis安装 1、windows下安装 默认端口：6379 下载连接 https://github.com/tporadowski/redis/releases 解压 双击redis-server.exe启动服务端 双击redis-cli.exe启动客户端连接服务端 在客户端输入 “ping”，出现“PONG”，即证明连接成功 2、Linux下安装 2.1、下载linux压缩包 【redis-5.0.5.tar.gz】 2.2、通过FlashFXP把压缩包
【Redis缓存】
weixin_54161577的博客
07-06 9232
相比于数据库而言，缓存的操作性能更高，缓存性能高的主要原因有以下几点：1、缓存一般都是key-value查询数据的，因为不像数据库一样还有查询的条件等因素，所以查询的性能一般会比数据库高；2、缓存的数据是存储在内存当中的，而数据库的数据是存储在磁盘当中的，因为内存的操作性能远远大于磁盘，因此缓存的查询效率会高很多；3、缓存更容易做分布式部署（当一台服务器变成多台相连的服务器集群），而数据库一般比较难实现分布式部署，因此缓存的负载和性能更容易平行扩展和增加。缓存大致分为两大类：本地缓存、分布式缓存本地缓存：也
【Redis篇】Redis缓存之缓存穿透
qq_40980718的博客
06-05 2092
本篇详细描述了Redis缓存中的缓存穿透问题，包括一些解决方案
Redis缓存机制(详解)
m0_71202849的博客
09-01 9750
redis是*一个运行在内存上的key-value存储系统。是NoSQL数据库之一。redis持久化的意义，在于故障恢复，数据恢复，也可以归类到高可用的一个环节里面去。线程模型，数据结构，持久化，网络模型。持久化，主从复制，哨兵机制。...
redis缓存的学习记录，底层源码学习
01-08
redis缓存的学习记录，底层源码学习
Redis缓存穿透，缓存击穿和缓存雪崩
12-14
处理Reids缓存引发的问题时，我们首先得知道缓存处理的一个流程，如下图： 二、缓存穿透，缓存击穿和缓存雪崩 缓存穿透 描述：缓存穿透是指缓存和数据库中都没有的数据，而用户不断发起请求，如发起为id为“-1024”...
分布式缓存技术Redis在C#中的使用
07-06
Redis是一款开源的、高性能的键-值存储（key-value store）。它常被称作是一款数据结构服务器（data structure server）。Redis的键值可以包括字符串（strings）、哈希（hashes）、列表（lists）、集合（sets）和 ...
四、Redis五种常用数据类型-List
最新发布
qq_41056506的博客
05-08 577
List是Redis中的列表，按照插入顺序保存数据，插入顺序是什么样的，数据就怎么保存。可以添加一个元素到列表的头部(左边)或者尾部(右边)。一个列表最多可以包含232-1个元素(4294967295，每个列表超过40亿个元素)。是一种双向列表结构。与中的类似，中的是一个双向链表，也是由一个个的节点组成。借助语言的链表节点结构如下： 指向前一个节点，指向下一个节点，保存着当前节点对应的数据对象。结构示意图如下： 链表的结构如下： 指向链表的头结点，指向链表的尾节点。表示链表有多少个节点，这样可以在的时间复
剖析Redis Sentinel：构建高可用性的Redis集群管理解决方案“
良月柒
05-08 709
Redis Sentinel是Redis官方提供的一种高可用性解决方案，用于监控和管理Redis集群的健康状态。它可以自动发现、监控、通知以及执行故障转移操作，从而确保Redis集群的稳定运行。Redis Sentinel作为Redis的高可用性解决方案，通过自动化的监控、发现和修复故障，确保了Redis集群的稳定运行。本文深入探究了Redis Sentinel的工作原理、配置选项、限制和示例应用场景，希望能够帮助你更好地理解和应用Redis Sentinel，从而提高系统的稳定性和可靠性。
redis之地理空间GEO
qq_63214872的博客
05-02 435
redis之地理空间GEO
【Redis7】了解Redis
m0_61057201的博客
05-04 1170
如 Map 一样的key-value 对，典型代表就是 Redis。
用Java处理redis缓存问题
08-10
为了在Java中处理Redis缓存问题，您需要使用Redis Java客户端库。常用的Java Redis客户端有Jedis、Lettuce和Redisson。 Jedis是一个纯Java实现的Redis客户端，使用简单，支持同步和异步两种操作方式。 Lettuce是一...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值