小工具知识网

当前位置: 首页 > 行业知识 > 【Redis】Redis 缓存重点解析

行业知识

【Redis】Redis 缓存重点解析

2026-11-18 19:21:14 来源:互联网转载

Redis 缓存重点解析

���荐文章:【Redis】Redis的特性和应用场景 · 数据类型 · 持久化 · 数据淘汰 · 事务 · 多机部署-CSDN博客

1. 我看你的项目都用到了 Redis,你在最近的项目的哪些场景下用到了 Redis 呢?

一定要结合业务场景来回答问题!要是没有不要硬讲,除非面试官问;

接下来面试官将深入发问。

  • 你没用到的也可能会试探着去问;

    2. 缓存三兄弟

    正常的场景是这样的:

    2.1 缓存穿透

    缓存穿透:查询一个不存在的数据的时候,MySQL 查询不到数据也不会写入缓存,就会导致每次这样的查询请求都不会命中 Redis 的缓存,每次都穿过 Redis,查询 MySQL;

    解决方案:

    1. 缓存 null 值

    也就是查询出来的结果不存在,也将其缓存出来,例如:

    {"id:1": null}

    优点:简单直接有效;

    缺点:消耗内存比较大,可能会出现双写不一致的问题,需要去维护双写一致性;

    1. 布隆过滤器

    也就是通过布隆过滤器判断键值是否存在,再判断是否读缓存,再决定是否读 MySQL:

    1. 布隆过滤器查询结果为不存在,则键值一定不存在;
    2. 布隆过滤器查询结果为存在,键值不一定存在(极小概率会误判);

    布隆过滤器的底层主要是一个比较大的数组,里面存放的是 0 / 1,在一开始的时候都是 0,当一个 key 来之后,经过 3 次 hash 计算,模上数组长度找到数据的下标,然后把数组中原来的 0 改为 1(1 则还是 1),这样的话,数组的三个位置就能标明一个 key 是否存在;

    当然,这里很明显的问题就是可能会出现误判,并且避免不了,我们一般可以控制这个误判率,数组越大,误判率就越小,性能也越差,最好就是 0.03 - 0.05 了,性能还算好一点,误差也是在接受范围内的,在实际业务可以大大降低 key 不存在而查 MySQL 的次数;

    优点:内存占用小,没有多余的 key,布隆过滤器一般不会设置过期时间;

    缺点:实现复杂,存在误判,删除不是很好删,可能会影响其他的数据;

    如果出现误判,那么岂不是还是会出现缓存穿透?

    是的,我觉得两种方法可以结合起来使用!

    1. 布隆过滤器查询结果:缓存存在(假设为误判结果);
    2. 查询 Redis,不存在;
    3. 查询 MySQL,不存在;
    4. 在 Redis 中设置值为 null 的 key(在布隆过滤器表示存在的时候,再设置这个 key,而不是每次表示不存在都设置 null);
    5. 下一次同样的请求;
    6. 布隆过滤器查询结果:缓存存在(假设为误判结果);
    7. 查询 Redis,结果为 null,返回 null;

    同理,其实业务中删除了 Redis 的某个键,也没必要在布隆过滤器中删除,把之后的每一次都视作“误判”;

    回答:

    • 缓存穿透就是一个请求查询了一个不存在的数据,无命中 Redis 的缓存,直接访问 MySQL,如果大量的这样的请求,那么每次都会穿过 Redis 直接访问 MySQL,给 MySQL 较大的压力;
    • 解决方案:
      1. 缓存 null 值;
      2. 布隆过滤器;

      2.2 缓存击穿

      缓存击穿:给某个 key 设置了过期时间,当 kye 过期的时候,恰好这个时间点对这个 key 有大量的并发请求过来,在 MySQL 读完并设置缓存这个间隙,MySQL 将瞬间收到大量的压力,甚至被搞垮;

      解决方案:

      1. 互斥锁
        • 强一致性,性能比较差;
        • 逻辑过期
          • 高可用性(允许特别小的一段时间的响应是过期数据),性能比较好;

      回答:

      • 缓存穿透就是给某个 key 设置了过期时间,当 kye 过期的时候,恰好这个时间点对这个 key 有大量的并发请求过来,在 MySQL 读完并设置缓存这个间隙,MySQL 将瞬间收到大量的压力,甚至被搞垮;
      • 解决方案:
        1. 互斥锁,强一致,性能差;
        2. 逻辑过期,高可用,性能好,不能保证数据的绝对一致;

        缓存穿透与缓存击穿的字面理解:

        • 缓存穿透给我的感觉就像“洞”是本来就有的,大量的请求穿透过这个“洞”访问 MySQL,当然用缓存 null 值可以将洞堵上;
        • 缓存击穿给我的感觉就是“洞”是突然出现的,强调其变化性,像被击穿了一样;当然,这里是 Redis 将过期键删除了,是 Redis 击穿的,但是感觉是被大量的并发请求冲出来个洞一样;

          这里的“洞”指的是,某个 key 无命中 Redis 的缓存,直接穿过 Redis 访问 MySQL;

          2.3 缓存雪崩

          缓存雪崩:在同一段时间内,大量的缓存 key 同时失效或者 Redis 服务宕机,导致大量的请求直接数据库,带来巨大压力;

          • 相较于缓存击穿,缓存雪崩更加严重,更加强调一下子出现很多的“洞”,或者 Redis 直接炸了,大量的不同的并发请求直接访问 MySQL;

            解决方案:

            1. 给不同的 key 的 TTL 添加随机值(比如在原来的基础上延迟 1 - 5 分钟过期),尽可能错开过期时间;
            2. 利用 Redis 集群提高服务可用性(哨兵模式、集群模式);
            3. 保底策略: 给业务添加降级限流策略(nginx、spring cloud 的 gateway 网关);
              • 这个策略适用于缓存穿透、缓存击穿、缓存雪崩;
              • 给业务添加多级缓存(Guava 或 Caffeine)

            一首打油诗,当作看了个乐就行:

            3. Redis 作为缓存,MySQL 的数据如何与 Redis 进行同步,也就是如何保证双写一致性的?

            一定要先介绍自己的哪些业务背景维护了双写一致,或者可以去维护双写一致。

            双写一致性:当修改了数据库的数据也要同时更新缓存的数据,保证缓存和数据库的数据要保持一致;

            我们可能会想,更新的时候把缓存删了不就好了,那么我们是先更新后删除缓存,还是先删除缓存再更新数据库?

            • 其实都是有问题的;

              况且,对于 Redis 集群,主从库同步也需要时间,这个问题也会被扩大;

              分为两个思路:

              1. 允许延迟一致
                • 延迟双删;
                • 一致性要求高
                  • Redis 读写锁;

              3.1 延迟双删

              • 读数据操作:缓存命中则返回,缓存未命中则查询数据库,写入缓存,设定超时时间;

              • 写数据操作:

                • 期间是可能出现脏数据的;

                  延时多久不太好确定,延时删除可以通过定时器任务、消息中间件异步通知删除等方式去实现;

                  3.2 Redis 读写锁

                  一般缓存的数据应该是**读多写少**,这样的数据才值得缓存,读多写少的场景下用读写锁可以尽可能的保持性能不会太差;

                  读写锁:

                  1. 读锁:又称共享锁,别的线程读的话不阻塞,写的话则阻塞等待;
                  2. 写锁:又称排他锁,别的线程读写都得阻塞等待;

                  用读写锁解决问题:

                  代码实例:

                  回答(示例):

                  • 如果业务允许延时一致,可以采用延时双删的策略,即先删除,再修改数据库,延时一段时间再删除一次,可以用计时器任务、消息中间件(例如 MQ),异步通知删除;
                  • 如果业务要求强一致性,可以采用读写锁保证双写一致性(共享锁:readLock,排他锁:writeLock)

                    4. Redis 作为缓存,数据的持久化是怎么做的?

                    1. RDB;
                    2. AOF;

                    4.1 RDB

                    RDB 全称 Redis Database Backup file(Redis 数据库备份文件,有压缩),也称为 Redis 数据快照。也就是把 Redis 内存中的所有数据都记录到磁盘中,当 Redis 实例故障重启,从磁盘中读取快照文件,恢复数据;

                    RDB 的执行原理:

                    • 由于 save 无非就是阻塞所有命令,把内存中的数据保存到 RDB 文件中,这种不可取;
                    • 而主要还是 bgsave 的执行原理:

                      4.2 AOF

                      AOF 全称 Append Only File(追加文件)。Redis 处理的每一个“写”命令都会记录在 AOF 文件,可以看做是命令日志/重做日志;

                      需要通过 redis.conf 来配置:

                      AOF 的执行频率策略:

                      因为是记录命令,没有压缩,AOF 文件会比 RDB 文件大很多,而且 AOF 会记录对同一个 key 的多次写操作,但是可能最后一次写操作有效,我们可以通过 bgrewriteaof 命令(bg rewrite aof),可以让 AOF 文件执行重写操作,减少最少命令达到相同效果;

                      可以通过 redis.conf 配置触发自动重写的阈值:

                      4.3 RDB 与 AOF 对比

                      5. Redis 的 key 过期之后,会立即删除吗?

                      可能不会立即删除,要看 Redis 的数据过期策略;

                      • Redis 对数据设置过期时间

                      • set name macaku 10
                      • 数据过期之后,就需要将数据从内存中删除,可以按照不同的规则进行删除,这种删除规则就是 Redis 的数据过期策略;

                        有两种:

                        1. 惰性删除;
                        2. 定期删除;

                        Redis 采用的是 惰性 + 定期;

                        • 勉强算第三种吧;

                          5.1 惰性删除

                          惰性删除:设置该 key 过期时间后,我们不去管它,当需要该 key 时,我们检查是否过期,如果过期,我们就删掉;

                          优点: 对 CPU 友好,只会在使用该 key 的时候进行删除,对于很多用不到的 key 就不用浪费时间删除了;

                          缺点: 对内存不友好,如果一个 key 已经过期,长期不用,就滞留在内存里不会被释放了;

                          5.2 定时删除

                          定时删除:每隔一段时间,我们就从 Redis 取出一定量的随机 key 进行检查,并删除其中过期的 key;

                          定期删除有两种模式:

                          1. SLOW 模式是定时任务,执行频率默认是 10hz(每秒10次),每次不超过 25ms,以通过修改配置文件 redis.conf 和 hz 选项来调整这个次数;
                          2. FAST 模式执行频率不限制,但限制两次间隔不低于 2ms,每次耗时不超过 1ms;

                          每次的删除程度,例如:

                          1. 从过期字典中随机取出20个键
                          2. 删除这20个键中过期得键
                          3. 如果过期键的比例超过25%,重复此过程

                          (由于有时间限制,所以不会循环太多次,可能最终没达到 25%,不过没啥大碍,交给下次咯)

                          可以自己去配;

                          优点: 可以通过限制删除操作执行的时长和频率来避免一次性删除/删除的数据量太大对 CPU 的影响,另外定期删除,也能有效释放过期键占用的内存,避免过期数据滞留在内存里;

                          缺点: 难以确定删除操作执行的时长和频率,“没有轮到删除”的过期数据可能被访问到;

                          所以混搭组合技才是王道,当访问到定时删除下还没删除的数据,判断其为过期数据则删除;

                          回答:

                          • 惰性删除:设置该 key 过期时间后,我们不去管它,当需要该 key 时,我们检查是否过期,如果过期,我们就删掉;
                          • 定时删除:每隔一段时间,我们就从 Redis 取出一定量的随机 key 进行检查,并删除其中过期的 key;
                          • Redis 的过期删除策略:惰性删除 + 定期删除 两种策略进行配合使用;

                            6. 加入缓存过多,内存是有限的,内存被占满了怎么办?(数据淘汰策略是什么?)

                            6.1 内存淘汰策略

                            早期版本的Redis有以下六种内存淘汰策略:

                            1. 报错
                              1. noeviction,不驱赶数据,即不淘汰任何数据,内存不足就报错,默认
                            2. 最久未用 LRU
                              1. allkeys-lru,淘汰所有键值中最久未使用的键值
                              2. volatile-lru,淘汰所有设置了过期时间的键值中最久未使用的键值
                            3. 随机
                              1. allkeys-random,随机淘汰所有键值中的任意键值
                              2. volatile-random,随机淘汰所有设置了过期时间的键值中的任意键值
                            4. 最先过期
                              1. volatile-ttl,优先淘汰最先过期的键值

                            在Redis 4.0版本中又新增了两种淘汰策略:

                            1. 最少使用 LFU
                              1. allkeys-lfu,淘汰所有键值中最少使用的键值
                              2. volatile-lfu,淘汰所有设置了过期时间的键值中,最少使用的键值

                            6.2 LRU和LFU有什么区别

                            侧重点不同

                            1. LRU,Least Recently Used,最近最少使用,是基于时间的策略,理念为:最近被访问过的键值就可能再次被访问,因此应该淘汰最久未被访问的键值;LRU策略会维护一个访问顺序列表
                              • 每当一个键被访问的时候,它会被移动到列表的末尾,最近没有被访问的键值的位置会比较靠前,所以会被优先淘汰
                              • 关注键的访问顺序
                              • LFU,Least Frequently Used,最不常使用,是基于频率的策略,理念为:它认为被访问次数最少的键值最不常用,更不重要,因此在淘汰时会优先选择访问次数最少的键值;LFU策略会维护一个访问计数器
                                • 每当一个键被访问时,此计数器会增加,LFU策略会选择访问计数最低的键进行淘汰
                                • 关注键的访问频率

                            6.3 过期淘汰策略和内存淘汰策略有何不同

                            1. 内存淘汰策略:解决Redis运行内存过大的问题;
                            2. 过期淘汰策略:主要是为了删除过期数据的问题;

                            6.4 策略选择的建议

                            1. 优先使用 allkeys-lru 策略。充分利用 LRU 算法的优势,把最近最常访问的数据留在缓存中。如果业务有明显的冷热数据区分,建议使用。
                            2. 如果业务中数据访问频率差别不大,没有明显冷热数据区分,建议使用 allkeys-random,随机选择淘汰,这样性能高。
                            3. 如果业务中有置顶的需求,可以使用 volatile-lru 策略,同时置顶数据不设置过期时间,这些数据就一直不被删除,会淘汰其他设置过期时间的数据。
                            4. 如果业务中有短时高频访问的数据,可以使用 allkeys-lfu 或 volatile-lfu 策略。

                            6.5 补充

                            Redis 的内存用完了会发生什么?

                            • 主要看数据淘汰策略是什么?如果是默认的配置(noeviction,不驱赶/不淘汰数据),会直接报错;

                              数据库有 1000w 数据,Redis 只能缓存 20w 数据,如何保证 Redis 中的数据都是热点数据?

                              • 也就是问,超额的数据 Redis 怎么缓存 => 数据淘汰策略 => 数据淘汰策略的选择;
                              • 使用 allkeys-lru ,留下来的都是经常访问的热点数据;

                                6.6 总结重点

                                1. Redis 提供了 8 种不同的数据淘汰策略,默认是 noeviction 不淘汰,内存不足则直接报错;
                                2. 其中,LRU:最久未用,以时间为衡量标准,用当前时间减去最后一次访问时间,这个值越大则淘汰优先级越高;LFU:最少使用,以频率为衡量标准,会统计每个 key 的访问频率,值越小淘汰优先级越高;
                                3. 平时开发过程中用的比较多的是 allkeys-lru(结合自己的业务场景去说)

上一篇:私人影院怎么配服务器?

下一篇:镜像怎么安装到服务器?