Redis知识点记忆

Redis知识点记忆（源于javaGuide）

Redis简介

Redis是一个使用C语言开发的数据库，与传统数据库不同的是Redis的数据是存在内存中的，也就是内存数据库，所以读写速度非常快，因此Redis被广泛应用于缓存方向。除了缓存，Redis也经常用来做分布式锁，甚至是消息队列。

Redis提供了多种数据类型来支持不同的业务场景。Redis还支持事务、持久化、Lua脚本、多种集群方案。

分布式缓存常见的技术选型方案有哪些？

分布式缓存的话，使用比较多的主要是Memcached和Redis。不过，现在基本没有看过

项目使用Memcached来做缓存，都是直接用Redis。

分布式缓存主要解决的是单机缓存的容量受服务器限制并且无法保存通用信息的问题。因为本地缓存只能在当前服务里有效，比如你部署了两个服务，他们两者之间的缓存数据是无法共同的。

Redis和Memcached的区别和共同点

共同点：

• 都是基于内存的数据库，一般都用来当作缓存使用。
• 都有过期策略
• 两者的性能都非常高

区别：

• Redis支持更加丰富的数据类型（支持更复杂的应用场景）。

• Redis支持数据的持久化，可以将内存中的数据保存在磁盘之中，重启的时候可以再次架子啊进行使用，而Memcached可以把数据全部存在内存之中。

• Redis有灾难恢复机制。可以把缓存中的数据持久化到磁盘上

• Redis在服务器内存使用完之后，可以将不用的数据放到磁盘上。但是，Memcached在内存用完之后，会直接报异常

• Memcached没有原生的集群模式，需要依靠客户端来实现往集群中分片写入数据；但是Redis是原生支持cluster模式的。

• Memcached是多线程的，非IO复用的网络模型；Redis使用单线程的多路复用IO模型

• Redis 支持发布订阅模型、Lua 脚本、事务等功能，而 Memcached 不支持。并且，Redis 支持更多的编程语言。

• Memcached 过期数据的删除策略只用了惰性删除，而 Redis 同时使用了惰性删除与定期删除。

缓存数据处理流程：

1. 如果用户请求的数据在缓存中就直接返回。
2. 缓存中不存在的话就看数据库中是否存在。
3. 数据库中存在的话就更新缓存中的数据。
4. 数据库中不存在的话就返回空数据。

为什么要用 Redis/为什么要用缓存？

简单来说为了提升用户体验以及应对更多的用户。

下面我们主要从“高性能”和“高并发”这两点来看待这个问题。

高性能：

那就是保证用户下一次再访问这些数据的时候就可以直接从缓存中获取了。操作缓存就是直接操作内存，所以速度相当快。

不过，要保持数据库和缓存中的数据的一致性。 如果数据库中的对应数据改变的之后，同步改变缓存中相应的数据即可！

高并发：

一般像 MySQL 这类的数据库的 QPS 大概都在 1w 左右（4 核 8g） ，但是使用 Redis 缓存之后很容易达到 10w+，甚至最高能达到 30w+（就单机 redis 的情况，redis 集群的话会更高）。由此可见，直接操作缓存能够承受的数据库请求数量是远远大于直接访问数据库的，所以我们可以考虑把数据库中的部分数据转移到缓存中去，这样用户的一部分请求会直接到缓存这里而不用经过数据库。进而，我们也就提高了系统整体的并发。

Redis单线程模型详解

Redis 基于 Reactor 模式来设计开发了自己的一套高效的事件处理模型 （Netty 的线程模型也基于 Reactor 模式，Reactor 模式不愧是高性能 IO 的基石），这套事件处理模型对应的是 Redis 中的文件事件处理器（file event handler）。由于文件事件处理器（file event handler）是单线程方式运行的，所以我们一般都说 Redis 是单线程模型。

既然是单线程，那怎么监听大量的客户端连接呢？

Redis 通过IO 多路复用程序 来监听来自客户端的大量连接（或者说是监听多个 socket），它会将感兴趣的事件及类型（读、写）注册到内核中并监听每个事件是否发生。

这样的好处非常明显： I/O 多路复用技术的使用让 Redis 不需要额外创建多余的线程来监听客户端的大量连接，降低了资源的消耗（和 NIO 中的 Selector 组件很像）

Redis 没有使用多线程？为什么不使用多线程？

我觉得主要原因有下面 3 个：

1. 单线程编程容易并且更容易维护；
2. Redis 的性能瓶颈不在 CPU ，主要在内存和网络；
3. 多线程就会存在死锁、线程上下文切换等问题，甚至会影响性能。

过期的数据的删除策略了解么？

如果假设你设置了一批 key 只能存活 1 分钟，那么 1 分钟后，Redis 是怎么对这批 key 进行删除的呢？

常用的过期数据的删除策略就两个（重要！自己造缓存轮子的时候需要格外考虑的东西）：

1. 惰性删除 ：只会在取出 key 的时候才对数据进行过期检查。这样对 CPU 最友好，但是可能会造成太多过期 key 没有被删除。
2. 定期删除 ： 每隔一段时间抽取一批 key 执行删除过期 key 操作。并且，Redis 底层会通过限制删除操作执行的时长和频率来减少删除操作对 CPU 时间的影响。

定期删除对内存更加友好，惰性删除对 CPU 更加友好。两者各有千秋，所以 Redis 采用的是 定期删除+惰性/懒汉式删除 。

Redis 内存淘汰机制了解么？

volatile-lru（least recently used）：从已设置过期时间的数据集（server.db[i].expires）中挑选最近最少使用的数据淘汰

volatile-ttl：从已设置过期时间的数据集（server.db[i].expires）中挑选将要过期的数据淘汰

volatile-random：从已设置过期时间的数据集（server.db[i].expires）中任意选择数据淘汰

allkeys-lru（least recently used）：当内存不足以容纳新写入数据时，在键空间中，移除最近最少使用的 key（这个是最常用的）

allkeys-random：从数据集（server.db[i].dict）中任意选择数据淘汰

no-eviction：禁止驱逐数据，也就是说当内存不足以容纳新写入数据时，新写入操作会报错。这个应该没人使用吧！

Redis 持久化机制(怎么保证 Redis 挂掉之后再重启数据可以进行恢复)

Redis 不同于 Memcached 的很重要一点就是，Redis 支持持久化，而且支持两种不同的持久化操作。Redis 的一种持久化方式叫快照（snapshotting，RDB），另一种方式是只追加文件（append-only file, AOF）。这两种方法各有千秋，下面我会详细这两种持久化方法是什么，怎么用，如何选择适合自己的持久化方法。

快照（snapshotting）持久化（RDB）

Redis 可以通过创建快照来获得存储在内存里面的数据在某个时间点上的副本。Redis 创建快照之后，可以对快照进行备份，可以将快照复制到其他服务器从而创建具有相同数据的服务器副本（Redis 主从结构，主要用来提高 Redis 性能），还可以将快照留在原地以便重启服务器的时候使用。

快照持久化是 Redis 默认采用的持久化方式

Redis 事务

使用MUTI命令后可以输入多个命令。Redis 不会立即执行这些命令，而是将它们放到队列，当调用了 EXEC命令将执行所有命令。

这个过程是这样的：

1. 开始事务（MULTI）。
2. 命令入队(批量操作 Redis 的命令，先进先出（FIFO）的顺序执行)。
3. 执行事务(EXEC)。

你也可以通过 DISCARD命令取消一个事务，它会清空事务队列中保存的所有命令。

WATCH命令用于监听指定的键，当调用 EXEC 命令执行事务时，如果一个被 WATCH 命令监视的键被修改的话，整个事务都不会执行，直接返回失败。

Redis 是不支持 roll back 的，因而不满足原子性的（而且不满足持久性）。

你可以将 Redis 中的事务就理解为 ：Redis 事务提供了一种将多个命令请求打包的功能。然后，再按顺序执行打包的所有命令，并且不会被中途打断。

什么是缓存穿透？

缓存穿透情况的处理流程是怎样的？

如下图所示，用户的请求最终都要跑到数据库中查询一遍。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XL9Ei1Ax-1646323206929)(data:image/png;base64,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)]

有哪些解决办法？

最基本的就是首先做好参数校验，一些不合法的参数请求直接抛出异常信息返回给客户端。比如查询的数据库 id 不能小于 0、传入的邮箱格式不对的时候直接返回错误消息给客户端等等。

1）缓存无效 key

如果缓存和数据库都查不到某个 key 的数据就写一个到 Redis 中去并设置过期时间，具体命令如下： SET key value EX 10086 。这种方式可以解决请求的 key 变化不频繁的情况，如果黑客恶意攻击，每次构建不同的请求 key，会导致 Redis 中缓存大量无效的 key 。很明显，这种方案并不能从根本上解决此问题。如果非要用这种方式来解决穿透问题的话，尽量将无效的 key 的过期时间设置短一点比如 1 分钟。

另外，这里多说一嘴，一般情况下我们是这样设计 key 的： 表名:列名:主键名:主键值 。

如果用 Java 代码展示的话，差不多是下面这样的：

public Object getObjectInclNullById(Integer id) {
    // 从缓存中获取数据
    Object cacheValue = cache.get(id);
    // 缓存为空
    if (cacheValue == null) {
        // 从数据库中获取
        Object storageValue = storage.get(key);
        // 缓存空对象
        cache.set(key, storageValue);
        // 如果存储数据为空，需要设置一个过期时间(300秒)
        if (storageValue == null) {
            // 必须设置过期时间，否则有被攻击的风险
            cache.expire(key, 60 * 5);
        }
        return storageValue;
    }
    return cacheValue;
}

2）布隆过滤器

布隆过滤器是一个非常神奇的数据结构，通过它我们可以非常方便地判断一个给定数据是否存在于海量数据中。我们需要的就是判断 key 是否合法，有没有感觉布隆过滤器就是我们想要找的那个“人”。

具体是这样做的：把所有可能存在的请求的值都存放在布隆过滤器中，当用户请求过来，先判断用户发来的请求的值是否存在于布隆过滤器中。不存在的话，直接返回请求参数错误信息给客户端，存在的话才会走下面的流程。

加入布隆过滤器之后的缓存处理流程图如下。

但是，需要注意的是布隆过滤器可能会存在误判的情况。总结来说就是： 布隆过滤器说某个元素存在，小概率会误判。布隆过滤器说某个元素不在，那么这个元素一定不在。

为什么会出现误判的情况呢? 我们还要从布隆过滤器的原理来说！

我们先来看一下，当一个元素加入布隆过滤器中的时候，会进行哪些操作：

1. 使用布隆过滤器中的哈希函数对元素值进行计算，得到哈希值（有几个哈希函数得到几个哈希值）。
2. 根据得到的哈希值，在位数组中把对应下标的值置为 1。

我们再来看一下，当我们需要判断一个元素是否存在于布隆过滤器的时候，会进行哪些操作：

1. 对给定元素再次进行相同的哈希计算；
2. 得到值之后判断位数组中的每个元素是否都为 1，如果值都为 1，那么说明这个值在布隆过滤器中，如果存在一个值不为 1，说明该元素不在布隆过滤器中。

然后，一定会出现这样一种情况：不同的字符串可能哈希出来的位置相同。 （可以适当增加位数组大小或者调整我们的哈希函数来降低概率）

什么是缓存雪崩？

实际上，缓存雪崩描述的就是这样一个简单的场景：缓存在同一时间大面积的失效，后面的请求都直接落到了数据库上，造成数据库短时间内承受大量请求。 这就好比雪崩一样，摧枯拉朽之势，数据库的压力可想而知，可能直接就被这么多请求弄宕机了。

举个例子：系统的缓存模块出了问题比如宕机导致不可用。造成系统的所有访问，都要走数据库。

还有一种缓存雪崩的场景是：有一些被大量访问数据（热点缓存）在某一时刻大面积失效，导致对应的请求直接落到了数据库上。 这样的情况，有下面几种解决办法：

举个例子 ：秒杀开始 12 个小时之前，我们统一存放了一批商品到 Redis 中，设置的缓存过期时间也是 12 个小时，那么秒杀开始的时候，这些秒杀的商品的访问直接就失效了。导致的情况就是，相应的请求直接就落到了数据库上，就像雪崩一样可怕。

针对 Redis 服务不可用的情况：

1. 采用 Redis 集群，避免单机出现问题整个缓存服务都没办法使用。
2. 限流，避免同时处理大量的请求。

针对热点缓存失效的情况：

1. 设置不同的失效时间比如随机设置缓存的失效时间。
2. 缓存永不失效。

如何保证缓存和数据库数据的一致性？

细说的话可以扯很多，但是我觉得其实没太大必要（小声 BB：很多解决方案我也没太弄明白）。我个人觉得引入缓存之后，如果为了短时间的不一致性问题，选择让系统设计变得更加复杂的话，完全没必要。

下面单独对 Cache Aside Pattern（旁路缓存模式） 来聊聊。

Cache Aside Pattern 中遇到写请求是这样的：更新 DB，然后直接删除 cache 。

如果更新数据库成功，而删除缓存这一步失败的情况的话，简单说两个解决方案：

1. 缓存失效时间变短（不推荐，治标不治本） ：我们让缓存数据的过期时间变短，这样的话缓存就会从数据库中加载数据。另外，这种解决办法对于先操作缓存后操作数据库的场景不适用。
2. 增加 cache 更新重试机制（常用）： 如果 cache 服务当前不可用导致缓存删除失败的话，我们就隔一段时间进行重试，重试次数可以自己定。如果多次重试还是失败的话，

B，然后直接删除 cache 。

如果更新数据库成功，而删除缓存这一步失败的情况的话，简单说两个解决方案：

1. 缓存失效时间变短（不推荐，治标不治本） ：我们让缓存数据的过期时间变短，这样的话缓存就会从数据库中加载数据。另外，这种解决办法对于先操作缓存后操作数据库的场景不适用。
2. 增加 cache 更新重试机制（常用）： 如果 cache 服务当前不可用导致缓存删除失败的话，我们就隔一段时间进行重试，重试次数可以自己定。如果多次重试还是失败的话，