关于redis面试相关

喜欢ヅ旅行 2022-09-02 05:27 214阅读 0赞

# **Redis 支持的数据类型有哪些？** #

Redis 支持的数据类型：string（字符串）、list（列表）、hash（字典）、set（集合）、zset（有序集合）。

**这些类型分别都有那些应用场景:**

1.  **string : **   
    是 redis 最基本的类型，你可以理解成与 Memcached 一模一样的类型，一个 key 对应一个 value。value其实不仅是String，也可以是数字。string 类型是二进制安全的。意思是 redis 的 string 可以包含任何数据。比如jpg图片或者序列化的对象。string 类型是 Redis 最基本的数据类型，string 类型的值最大能存储 512MB
2.  **list** : 
    
     列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）或者尾部（右边）。
    
    　　常用命令：lpush（添加左边元素）,rpush,lpop（移除左边第一个元素）,rpop,lrange（获取列表片段，LRANGE key start stop）等。
    
    　　**应用场景：**例如点赞人,关注列表,当天的活跃用户,又或者秒杀时可以有序的将用户列表插入进去,前100名就是抢购成功的
3.  **hash :**  
    是一个键值(key => value)对集合。Redis hash 是一个 string 类型的 field 和 value 的映射表，hash 特别适合用于存储对象。  
    常用命令：hget,hset,hgetall 等。  
    **应用场景**:例如可以将用户信息存入进入,key为用户id,值为用户详细数据,可以把这种结构看作一个map
4.  **set :**  
    是string类型的无序集合。集合是通过hashtable实现的，概念和数学中个的集合基本类似，可以交集，并集，差集等等，set中的元素是没有顺序的。所以添加，删除，查找的复杂度都是O(1)  
    　　  
    **应用场景：**交集，并集，差集：(Set)  
             Redis set对外提供的功能与list类似是一个列表的功能，特殊之处在于set是可以自动排重的，当你需要存储一个列表数据，又不希望出现重复数据时，set是一个很好的选择，并且set提供了判断某个成员是否在一个set集合内的重要接口，这个也是list所不能提供的。  
    实现方式： set 的内部实现是一个 value永远为null的HashMap，实际就是通过计算hash的方式来快速排重的，这也是set能提供判断一个成员是否在集合内的原因
5.  sorted set的使用场景与set类似，区别是set不是自动有序的，而sorted set可以通过用户额外提供一个优先级(score)的参数来为成员排序，并且是插入有序的，即自动排序。当你需要一个有序的并且不重复的集合列表，那么可以选择sorted set数据结构，比如twitter 的public timeline可以以发表时间作为score来存储，这样获取时就是自动按时间排好序的。和Set相比，**Sorted Set关联了一个double类型权重参数score**，使得集合中的元素能够按score进行有序排列，redis正是通过分数来为集合中的成员进行从小到大的排序。zset的成员是唯一的,但分数(score)却可以重复。比如一个存储全班同学成绩的Sorted Set，其集合value可以是同学的学号，而score就可以是其考试得分，这样在数据插入集合的时候，就已经进行了天然的排序。另外还可以用Sorted Set来做带权重的队列，比如普通消息的score为1，重要消息的score为2，然后工作线程可以选择按score的倒序来获取工作任务。让重要的任务优先执行。
    
    　　实现方式：Redis sorted set的内部使用HashMap和跳跃表(SkipList)来保证数据的存储和有序，HashMap里放的是成员到score的映射，而跳跃表里存放的是所有的成员，排序依据是HashMap里存的score,使用跳跃表的结构可以获得比较高的查找效率，并且在实现上比较简单。  
    **应用场景:例如:现在一个投票的需求,就可以使用这个**

# redis是单线程的还是多线程的 #

在4.0之前虽然我们说Redis是单线程，也只是说它的网络I/O线程以及Set 和 Get操作是由一个线程完成的。但是Redis的持久化、集群同步还是使用其他线程来完成。

4.0之后添加了多线程的支持，主要是体现在大数据的异步删除功能上，例如 `unlink key`、`flushdb async`、`flushall async` 等

> **del ------> unlink**  
> 删除指令 del 会直接释放对象的内存，大部分情况下，这个指令非常快，没有明显延迟。不过如果删除的 key 是一个非常大的对象，举个例子一个包含几千万元素的key，那么删除操作就会导致单线程卡顿。
> 
> Redis 为了解决这个卡顿问题，在 4.0 版本引入了 unlink 指令，它能对删除操作进行懒处理，丢给后台线程来异步回收内存
> 
> **FLUSHDB/FLUSHALL --> FLUSHDB ASYNC/FLUSHALL ASYNC**
> 
> **FLUSHDB : 清空当前库**
> 
> **FLUSHALL:清空所有库**
> 
> Redis 提供了 flushdb 和 flushall 指令，用来清空数据库，当数据量很大时，容易阻塞Redis。
> 
> Redis 4.0 同样给这两个指令也带来了异步化，在指令后面增加 **async** 参数扔给后台线程销毁，不会阻塞当前线程。

# redis速度为什么快? #

*  基于内存操作：Redis的所有数据都存在内存中，因此所有的运算都是内存级别的，所以它的性能比较高。
 *  数据结构简单: 他使用了哈希表和跳表等结构
 *  多路复用和非阻塞IO：Redis使用IO多路复用功能来监听多个socket连接的客户端，这样就可以使用一个线程来处理多个情况，从而减少线程切换带来的开销，同时也避免了IO阻塞操作，从而大大提高了Redis的性能。
 *  避免上下文切换：因为是单线程模型，因此就避免了不必要的上下文切换和多线程竞争，这就省去了多线程切换带来的时间和性能上的开销，而且单线程不会导致死锁的问题发生

# 理解io多路复用 #

> 首先说一下，什么是IO多路复用技术。
> 
> 比如，现在我们模拟一个tcp服务器处理30个客户的socket，如何快速的处理掉这30个请求呢？
> 
> **文件事件处理器使用 I/O 多路复用模块同时监听多个 FD**，当 accept、read、write 和 close 文件事件产生时，文件事件处理器就会回调 FD 绑定的**事件处理器.**
> 
> 在不了解原理的情况下，我们类比一个实例：在课堂上让全班30个人同时做作业，做完后老师检查，30个学生的作业都检查完成才能下课。如何在有限的资源下，以最快的速度下课呢？
> 
> 理论示例例如:
> 
>  *  第一种：安排一个老师，按顺序逐个检查。先检查A，然后是B，之后是C、D。。。这中间如果有一个学生卡住，全班都会被耽误。这种模式就好比，你用循环挨个处理socket，根本不具有并发能力。这种方式只需要一个老师，但是耗时时间会比较长。
>  *  第二种：安排30个老师，每个老师检查一个学生的作业。 这种类似于为每一个socket创建一个进程或者线程处理连接。这种方式需要30个老师（最消耗资源），但是速度最快。
>  *  第三种：安排一个老师，站在讲台上，谁解答完谁举手。这时C、D举手，表示他们作业做完了，老师下去依次检查C、D的答案，然后继续回到讲台上等。此时E、A又举手，然后去处理E和A。这种方式可以在最小的资源消耗的情况下，最快的处理完任务。
> 
> 第三种就是IO复用模型（Linux下的select、poll和epoll就是干这个的。将用户socket对应的fd注册进epoll，然后epoll帮你监听哪些socket上有消息到达，这样就避免了大量的无用操作。此时的socket应该采用非阻塞模式。这样，整个过程只在调用select、poll、epoll这些调用的时候才会阻塞，收发客户消息是不会阻塞的，整个进程或者线程就被充分利用起来，这就是事件驱动，所谓的reactor模式。
> 
> 其他可参考  :   [https://www.cnblogs.com/reecelin/p/13538382.html][https_www.cnblogs.com_reecelin_p_13538382.html]

# **Redis6.0中的多线程？** #

> Redis单线程的优点非常，不但降低了Redis内部实现的负责性，也让所有操作都可以在无锁的情况下进行，并且不存在死锁和线程切换带来的性能以及时间上的消耗；但是其缺点也很明显，单线程机制导致Redis的QPS（Query Per Second，每秒查询数）很难得到有效的提高（虽然够快了，但人毕竟还是要有更高的追求的）。
> 
> Redis在4.0版本中虽然引入了多线程，但是此版本的多线程只能用于大数据量的异步删除，对于非删除操作的意义并不是很大。
> 
> 如果我们使用Redis多线程就可以分摊Redis同步读写IO的压力，以及充分利用多核CPU资源，并且可以有效的提升Redis的QPS。在Redis中虽然使用了IO多路复用，并且是基于非阻塞的IO进行操作的，但是IO的读写本身是阻塞的。比如当socket中有数据时，Redis会先将数据从内核态空间拷贝到用户态空间，然后再进行相关操作，而这个拷贝过程是阻塞的，并且当数据量越大时拷贝所需要的的时间就越多，而这些操作都是基于单线程完成的。
> 
> 因此在Redis6.0中新增了多线程的功能来提高IO的读写性能，它的主要实现思路是将主线程的IO读写任务拆分给一组独立的线程去执行，这样就可以使用多个socket的读写并行化了，但Redis的命令依旧是主线程串行执行的。
> 
> 但是注意：Redis6.0是默认禁用多线程的，但可以通过配置文件redis.conf中的io-threads-do-reads 等于 true 来开启。但是还不够，除此之外我们还需要设置线程的数量才能正确地开启多线程的功能，同样是修改Redis的配置，例如设置 io-threads 4，表示开启4个线程。

# 关于redis的持续化方式? #

> Redis数据是存储在内存中的，为了保证Redis数据不丢失，那就要把数据从内存存储到磁盘上，以便在服务器重启后还能够从磁盘中恢复原有数据，这就是Redis的数据持久化。Redis数据持久化有三种方式。
> 
>  *  AOF 日志（Append Only File，文件追加方式）：记录所有的操作命令，并以文本的形式追加到文件中。
>  *  RDB 快照（Redis DataBase）：将某一个时刻的内存数据，以二进制的方式写入磁盘。
>  *  混合持久化方式：Redis 4.0 新增了混合持久化的方式，集成了 RDB 和 AOF 的优点。

## rdb和aof对比优缺点 ##

> **RDB是Redis默认的持久化方式。按照一定的时间将内存的数据以快照的形式保存到硬盘中，对应产生的数据文件为dump.rdb。通过配置文件中的save参数来定义快照的周期**
> 
> 优点：
> 
>  *  1、只有一个文件 dump.rdb，方便持久化。
>  *  2、容灾性好，一个文件可以保存到安全的磁盘。
>  *  3、性能最大化，fork 子进程来完成写操作，让主进程继续处理命令，所以是 IO 最大化。使用单独子进程来进行持久化，主进程不会进行任何 IO 操作，保证了 redis 的高性能
>  *  4.相对于数据集大时，比 AOF 的启动效率更高。
> 
> 缺点：
> 
>  *  1、数据安全性低。RDB 是间隔一段时间进行持久化，如果持久化之间 redis 发生故障，会发生数据丢失。所以这种方式更适合数据要求不严谨的时候)
>  *  2、AOF（Append-only file)持久化方式：是指所有的命令行记录以 redis 命令请 求协议的格式完全持久化存储)保存为 aof 文件。
> 
> **AOF：持久化**
> 
> AOF持久化(即Append Only File持久化)，则是将Redis执行的每次写命令记录到单独的日志文件中，当重启Redis会重新将持久化的日志中文件恢复数据。
> 
> 当两种方式同时开启时，数据恢复Redis会优先选择AOF恢复
> 
> 优点：
> 
>  *  1、数据安全，aof 持久化可以配置 appendfsync 属性，有 always，每进行一次 命令操作就记录到 aof 文件中一次。
>  *  2、通过 append 模式写文件，即使中途服务器宕机，可以通过 redis-check-aof 工具解决数据一致性问题。
>  *  3、AOF 机制的 rewrite 模式。AOF 文件没被 rewrite 之前（文件过大时会对命令 进行合并重写），可以删除其中的某些命令（比如误操作的 flushall）)
> 
> 缺点：
> 
>  *  1、AOF 文件比 RDB 文件大，且恢复速度慢。
>  *  2、数据集大的时候，比 rdb 启动效率低。
> 
> **优缺点是什么？**
> 
>  *  AOF文件比RDB更新频率高，优先使用AOF还原数据。
>  *  AOF比RDB更安全也更大
>  *  RDB性能比AOF好
>  *  如果两个都配了优先加载AOF

> AOF采用的是写后日志的方式，Redis先执行命令把数据写入内存，然后再记录日志到文件中。AOF日志记录的是操作命令，不是实际的数据，如果采用AOF方法做故障恢复时需要将全量日志都执行一遍。![image.png][]
> 
> RDB采用的是内存快照的方式，它记录的是某一时刻的数据，而不是操作，所以采用RDB方法做故障恢复时只需要直接把RDB文件读入内存即可，实现快速恢复。
> 
> ### AOF采用的是 “写后日志” 的方式，我们平时用的MySQL则采用的是 “写前日志”，那 **Redis为什么要先执行命令，再把数据写入日志呢？** ###
> 
>  这个主要是由于Redis在写入日志之前，不对命令进行语法检查，所以只记录执行成功的命令，避免出现记录错误命令的情况，而且在命令执行后再写日志不会阻塞当前的写操作。
> 
> ### 后写日志主要有两个风险可能会发生： ###
> 
>  *  数据可能会丢失： 如果 Redis 刚执行完命令，此时发生故障宕机，会导致这条命令存在丢失的风险。
>  *  可能阻塞其他操作： AOF 日志其实也是在主线程中执行，所以当 Redis 把日志文件写入磁盘的时候，还是会阻塞后续的操作无法执行。
> 
> ###  **RDB做快照时会阻塞线程吗？** ###
> 
> Redis 提供了两个命令来生成 RDB 快照文件，分别是 `save` 和 `bgsave`。`save` 命令在主线程中执行，会导致阻塞。而 `bgsave` 命令则会创建一个子进程，用于写入 RDB 文件的操作，避免了对主线程的阻塞，这也是 Redis RDB 的默认配置。
> 
> ### 那做快照时可以对数据做修改吗? ###
> 
> save是同步的会阻塞客户端命令，bgsave的时候是可以修改的。
> 
> **那Redis是怎么解决在bgsave做快照的时候允许数据修改呢？**
> 
> 这里主要是利用 `bgsave`的子线程实现的，具体操作如下：
> 
>  *  如果主线程执行读操作，则主线程和 `bgsave` 子进程互相不影响；
>  *  如果主线程执行写操作，则被修改的数据会复制一份副本，然后 `bgsave`子进程会把该副本数据写入 RDB 文件，在这个过程中，主线程仍然可以直接修改原来的数据。
> 
> 要注意，Redis 对 RDB 的执行频率非常重要，因为这会影响快照数据的完整性以及 Redis 的稳定性，所以在 Redis 4.0 后，**增加了 AOF 和 RDB 混合的数据持久化机制：** 把数据以 RDB 的方式写入文件，再将后续的操作命令以 AOF 的格式存入文件，既保证了 Redis 重启速度，又降低数据丢失风险。

如果用redis实现分布式锁?

> 可以使用 Redis 自带的 SETNX 命令实现分布式锁，除此之外，还可以使用官方提供的 RedLock 分布式锁实现。

# redis的缓存雪崩、击穿、穿透 #

> **什么是雪崩?(短时间内大批量数据失效)**  
> 同一时间大面积失效，那一瞬间Redis跟没有一样，那这个数量级别的请求直接打到数据库几乎是灾难性的，你想想如果打挂的是一个用户服务的库，那其他依赖他的库所有的接口几乎都会报错，如果没做熔断等策略基本上就是瞬间挂一片的节奏，你怎么重启用户都会把你打挂，等你能重启的时候，用户早就睡觉去了，并且对你的产品失去了信心，什么垃圾产品
> 
> **雪崩怎么解决**  
> 处理缓存雪崩简单，在批量往`Redis`存数据的时候，把每个Key的失效时间都加个随机值就好了，这样可以保证数据不会在同一时间大面积失效
> 
> **什么是缓存穿透?(频繁访问缓存中肯定没有的数据)**  
> 缓存穿透是指缓存和数据库中都没有的数据，而用户不断发起请求，我们数据库的 id 都是1开始自增上去的，如发起为id值为 -1 的数据或 id 为特别大不存在的数据。这时的用户很可能是攻击者，攻击会导致数据库压力过大，严重会击垮数据库。
> 
> **穿透怎么解决?**  
> 方法一(从接口效验上解决) : 直接回绝不符合常规的请求,例如:我们的id是正整数,那么凡是负数的请求就可以直接拒绝  
> 方法二:  `Redis`还有一个高级用法`布隆过滤器（Bloom Filter）`这个也能很好的防止缓存穿透的发生，他的原理也很简单就是利用高效的数据结构和算法快速判断出你这个Key是否在数据库中存在，不存在你return就好了，存在你就去查了DB刷新KV再return。 
> 
> **什么是缓存击穿?(非常热点的数据突然失效导致直接打死数据库)**  
> 至于缓存击穿嘛，这个跟缓存雪崩有点像，但是又有一点不一样，缓存雪崩是因为大面积的缓存失效，打崩了DB，而缓存击穿不同的是缓存击穿是指一个Key非常热点，在不停的扛着大并发，大并发集中对这一个点进行访问，当这个Key在失效的瞬间，持续的大并发就穿破缓存，直接请求数据库，就像在一个完好无损的桶上凿开了一个洞 
> 
> (借鉴了:[https://blog.csdn.net/qq\_35190492/article/details/102889333][https_blog.csdn.net_qq_35190492_article_details_102889333])

# ** redis的事务** #

> 在redis中使用事务，通常的使用watch…multi…exec命令组合。  
> redis执行事务过程：
> 
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MDA0MDg4_size_16_color_FFFFFF_t_70]
> 
> watch命令是可以监控redis的一些键；multi命令是开始事务，开始事务后，该客户端的命令不会马上被执行，而是存放到一个队列里，这时执行一些返回数据的命令，结果返回都是空。exec执行事务，在执行前判断watch监控的redis键的数据是否发生了变化（即使赋予之前相同的值也会被认为是变化过），如果它认为发生了变化，那么redis就会取消事务，否则执行事务
> 
>     假设一个业务是读取一个值,将值自增1然后再存入,该实现在只有一个客户端的时候可以执行得很好。
>     
>     但是，当多个客户端同时对同一个键进行这样的操作时，就会产生竞争条件。
>     
>     如果客户端 A 和 B 都读取了键原来的值，比如 10 ，那么两个客户端都会将键的值设为 11 ，但正确的结果应该是 12 才对。
>     
>     使用 WATCH ，可以轻松解决这个问题。
>     
>     WATCH 命令可以为 Redis 事务提供 check-and-set （CAS）行为。
>     
>     被 WATCH 的键会被监视，并会发觉这些键是否被改动过了。
>     
>     如果有至少一个被监视的键在 EXEC 执行之前被修改了，那么整个事务都会被取消，EXEC 返回空多条批量回复（null multi-bulk reply）来表示事务已经失败。
> 
> **springboot使用redis事务简单用法:[https://blog.csdn.net/weixin\_42567046/article/details/112246288][https_blog.csdn.net_weixin_42567046_article_details_112246288]**

# Redis的过期键的删除策略  #

> 我们都知道，Redis是key-value数据库，我们可以设置Redis中缓存的key的过期时间。Redis的过期策略就是指当Redis中缓存的key过期了，Redis如何处理。
> 
> 过期策略通常有以下三种：
> 
>  *  定时过期：每个设置过期时间的key都需要创建一个定时器，到过期时间就会立即清除。该策略可以立即清除过期的数据，对内存很友好；但是会占用大量的CPU资源去处理过期的数据，从而影响缓存的响应时间和吞吐量。
>  *  惰性过期：只有当访问一个key时，才会判断该key是否已过期，过期则清除。该策略可以最大化地节省CPU资源，却对内存非常不友好。极端情况可能出现大量的过期key没有再次被访问，从而不会被清除，占用大量内存。
>  *  定期过期：每隔一定的时间，会扫描一定数量的数据库的expires字典中一定数量的key，并清除其中已过期的key。该策略是前两者的一个折中方案。通过调整定时扫描的时间间隔和每次扫描的限定耗时，可以在不同情况下使得CPU和内存资源达到最优的平衡效果。  
>     (expires字典会保存所有设置了过期时间的key的过期时间数据，其中，key是指向键空间中的某个键的指针，value是该键的毫秒精度的UNIX时间戳表示的过期时间。键空间是指该Redis集群中保存的所有键。)
> 
> Redis中同时使用了**惰性过期和定期过期**两种过期策略

# redis内存淘汰策略 #

> ### MySQL里有2000w数据，redis中只存20w的数据，如何保证redis中的数据都是热点数据 ###
> 
> redis内存数据集大小上升到一定大小的时候，就会施行数据淘汰策略。
> 
> ### Redis的内存淘汰策略有哪些 ###
> 
> Redis的内存淘汰策略是指在Redis的用于缓存的内存不足时，怎么处理需要新写入且需要申请额外空间的数据。
> 
> 全局的键空间选择性移除
> 
>  *  noeviction：当内存不足以容纳新写入数据时，新写入操作会报错。
>  *  allkeys-lru：当内存不足以容纳新写入数据时，在键空间中，移除最近最少使用的key。（这个是最常用的）
>  *  allkeys-random：当内存不足以容纳新写入数据时，在键空间中，随机移除某个key。
> 
> 设置过期时间的键空间选择性移除
> 
>  *  volatile-lru：当内存不足以容纳新写入数据时，在设置了过期时间的键空间中，移除最近最少使用的key。
>  *  volatile-random：当内存不足以容纳新写入数据时，在设置了过期时间的键空间中，随机移除某个key。
>  *  volatile-ttl：当内存不足以容纳新写入数据时，在设置了过期时间的键空间中，有更早过期时间的key优先移除。
> 
> **总结**
> 
> Redis的内存淘汰策略的选取并不会影响过期的key的处理。内存淘汰策略用于处理内存不足时的需要申请额外空间的数据；过期策略用于处理过期的缓存数据。

[https_www.cnblogs.com_reecelin_p_13538382.html]: https://www.cnblogs.com/reecelin/p/13538382.html
[image.png]: /images/20220829/b049a44a8855409f810db0c1d02b1849.png
[https_blog.csdn.net_qq_35190492_article_details_102889333]: https://blog.csdn.net/qq_35190492/article/details/102889333
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MDA0MDg4_size_16_color_FFFFFF_t_70]: /images/20220829/ff3c7e9243da4c94b7a0579061e440de.png
[https_blog.csdn.net_weixin_42567046_article_details_112246288]: https://blog.csdn.net/weixin_42567046/article/details/112246288