【数据库】Redis

一、概述

Redis 是速度非常快的非关系型（NoSQL）内存键值数据库，可以存储键和五种不同类型的值之间的映射

键的类型只能为字符串，值支持五种数据类型：字符串、列表、集合、散列表、有序集合。

Redis 支持很多特性，例如将内存中的数据持久化到硬盘中，使用复制来扩展读性能，使用分片来扩展写性能

二、数据类型及相应操作

数据类型	可以存储的值	操作
STRING	字符串、整数或浮点数	字符串操作、数字自增减
LIST	列表	两端压入或弹出、元素修剪、保留范围内元素
SET	无序集合	添加获取移除元素、contains、交并差
ZSET	有序集合	添加获取移除元素、计算键的排名
HASH	键值对的无序散列表	添加获取移除键值对、containsKey

String

> set hello world
OK
> get hello
"world"
> del hello
(integer) 1
> get hello
(nil)

LIST

> rpush list-key item
(integer) 1
> rpush list-key item2
(integer) 2
> rpush list-key item
(integer) 3

> lrange list-key 0 -1
1) "item"
2) "item2"
3) "item"

> lindex list-key 1
"item2"

> lpop list-key
"item"

> lrange list-key 0 -1
1) "item2"
2) "item"

SET

> sadd set-key item
(integer) 1
> sadd set-key item2
(integer) 1
> sadd set-key item3
(integer) 1
> sadd set-key item
(integer) 0

> smembers set-key
1) "item"
2) "item2"
3) "item3"

> sismember set-key item4
(integer) 0
> sismember set-key item
(integer) 1

> srem set-key item2
(integer) 1
> srem set-key item2
(integer) 0

> smembers set-key
1) "item"
2) "item3"

HASH

> hset hash-key sub-key1 value1
(integer) 1
> hset hash-key sub-key2 value2
(integer) 1
> hset hash-key sub-key1 value1
(integer) 0

> hgetall hash-key
1) "sub-key1"
2) "value1"
3) "sub-key2"
4) "value2"

> hdel hash-key sub-key2
(integer) 1
> hdel hash-key sub-key2
(integer) 0

> hget hash-key sub-key1
"value1"

> hgetall hash-key
1) "sub-key1"
2) "value1"

ZSET

三、数据结构

字典

dictht 是一个散列表结构，使用拉链法解决哈希冲突

/* This is our hash table structure. Every dictionary has two of this as we
 * implement incremental rehashing, for the old to the new table. */
typedef struct dictht {
    dictEntry **table;
    unsigned long size;
    unsigned long sizemask;
    unsigned long used;
} dictht;

typedef struct dictEntry {
    void *key;
    union {
        void *val;
        uint64_t u64;
        int64_t s64;
        double d;
    } v;
    struct dictEntry *next;
} dictEntry;

Redis 的字典 dict 中包含两个哈希表 dictht，这是为了方便进行 rehash 操作。在扩容时，将其中一个 dictht 上的键值对 rehash 到另一个 dictht 上面，完成之后释放空间并交换两个 dictht 的角色

typedef struct dict {
    dictType *type;
    void *privdata;
    dictht ht[2];
    long rehashidx; /* rehashing not in progress if rehashidx == -1 */
    unsigned long iterators; /* number of iterators currently running */
} dict;

rehash 操作不是一次性完成，而是采用渐进方式，这是为了避免一次性执行过多的 rehash 操作给服务器带来过大的负担

渐进式 rehash 通过记录 dict 的 rehashidx 完成，它从 0 开始，然后每执行一次 rehash 都会递增。例如在一次 rehash 中，要把 dict[0] rehash 到 dict[1]，这一次会把 dict[0] 上 table[rehashidx] 的键值对 rehash 到 dict[1] 上，dict[0] 的 table[rehashidx] 指向 null，并令 rehashidx++。也就是每次操作只会rehash一个值

在 rehash 期间，每次对字典执行添加、删除、查找或者更新操作时，都会执行一次渐进式 rehash

采用渐进式 rehash 会导致字典中的数据分散在两个 dictht 上，因此对字典的查找操作也需要到对应的 dictht 去执行

跳表

是有序集合的底层实现之一

跳跃表是基于多指针有序链表实现的，可以看成多个有序链表

在查找时，从上层指针开始查找，找到对应的区间之后再到下一层去查找。下图演示了查找 22 的过程

与红黑树等平衡树相比，跳跃表具有以下优点：

• 插入速度非常快速，因为不需要进行旋转等操作来维护平衡性；
• 更容易实现；
• 支持无锁操作。

四、应用场景

1. 计数器

   可以对 String 进行自增自减运算，从而实现计数器功能。

   Redis 这种内存型数据库的读写性能非常高，很适合存储频繁读写的计数量。

2. 缓存

   将热点数据放到内存中，设置内存的最大使用量以及淘汰策略来保证缓存的命中率。

3. 查找表

   例如 DNS 记录就很适合使用 Redis 进行存储。

   查找表和缓存类似，也是利用了 Redis 快速的查找特性。但是查找表的内容不能失效，而缓存的内容可以失效，因为缓存不作为可靠的数据来源。

4. 消息队列

   List 是一个双向链表，可以通过 lpush 和 rpop 写入和读取消息

   不过最好使用 Kafka、RabbitMQ 等消息中间件。

5. 会话缓存

   可以使用 Redis 来统一存储多台应用服务器的会话信息。

   当应用服务器不再存储用户的会话信息，也就不再具有状态，一个用户可以请求任意一个应用服务器，从而更容易实现高可用性以及可伸缩性。

6. 分布式锁实现

   在分布式场景下，无法使用单机环境下的锁来对多个节点上的进程进行同步。

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

7. 其它

   Set 可以实现交集、并集等操作，从而实现共同好友等功能。

   ZSet 可以实现有序性操作，从而实现排行榜等功能。

五、Redis 与 Memcached

两者都是非关系型内存键值数据库，主要有以下不同：

数据类型

Memcached 仅支持字符串类型，而 Redis 支持五种不同的数据类型，可以更灵活地解决问题

数据持久化

Redis 支持两种持久化策略：RDB 快照和 AOF 日志，而 Memcached 不支持持久化

分布式

Memcached 不支持分布式，Redis Cluster 实现了分布式的支持

内存管理机制

• 在 Redis 中，并不是所有数据都一直存储在内存中，可以将一些很久没用的 value 交换到磁盘，而 Memcached 的数据则会一直在内存中。

• Memcached 将内存分割成特定长度的块来存储数据，以完全解决内存碎片的问题。但是这种方式会使得内存的利用率不高，例如块的大小为 128 bytes，只存储 100 bytes 的数据，那么剩下的 28 bytes 就浪费掉了

六、键的过期时间

Redis 可以为每个键设置过期时间，当键过期时，会自动删除该键

redis如何清理过期key

redis出于性能上的考虑，无法做到对每一个过期的key进行即时的过期监听和删除。但是redis提供了其它的方法来清理过期的key

1. 惰性清理

访问一个过期的key时， redis会将其直接从内存中删除

2. 定期清理

周期性的执行一个函数，进行内存的主动清理edis采用了一个随机算法来进行这个过程：

• 随机的抽取N(默认100)个被设置了过期时间的key，清除过期的key

• 同时，如果这其中已经过期的key超过了一定的百分比M(默认是25)，则将继续执行一次主动清理，直至过期key的百分比在概率上降低到M以下

3. 内存不足时触发主动清理

在redis的内存不足时，也会触发主动清理

内存满时，如何进行数据淘汰

共6种策略

策略	描述
volatile-lru	从已设置过期时间的数据集中挑选最近最少使用的数据淘汰
volatile-lfu	从已设置过期时间的数据集中挑选访问频率最少的数据淘汰
volatile-ttl	从已设置过期时间的数据集中挑选将要过期的数据淘汰
volatile-random	从已设置过期时间的数据集中任意选择数据淘汰
allkeys-lru	从所有数据集中挑选最近最少使用的数据淘汰
allkeys-lfu	从所有数据集中挑选访问频率最少的数据淘汰
allkeys-random	从所有数据集中任意选择数据进行淘汰
noeviction	禁止驱逐数据

七、持久化

Redis 是内存型数据库，为了保证数据在断电后不会丢失，需要将内存中的数据持久化到硬盘上

RDB 持久化

将某个时间点的所有数据都存放到硬盘上。

可以将快照复制到其它服务器从而创建具有相同数据的服务器副本。

如果系统发生故障，将会丢失最后一次创建快照之后的数据。

如果数据量很大，保存快照的时间会很长。

AOF 持久化

将 写命令 添加到 AOF 文件（Append Only File）的末尾

使用 AOF 持久化需要设置同步选项，从而确保写命令同步到磁盘文件上的时机。这是因为对文件进行写入并不会马上将内容同步到磁盘上，而是先存储到缓冲区，然后由操作系统决定什么时候同步到磁盘。有以下同步选项：

• always：每个写命令都同步
• everysec：每秒同步一次
• no：让操作系统来决定何时同步

随着服务器写请求的增多，AOF 文件会越来越大。Redis 提供了一种将 AOF 重写的特性，能够去除 AOF 文件中的冗余写命令

八、事务

Redis事务是一个单独的隔离操作：事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。

Redis事务的主要作用就是串联多个命令防止别的命令插队

Redis 最简单的事务实现方式是使用 MULTI 和 EXEC 命令将事务操作包围起来

事务的错误处理

在组队的过程中如果某个命令出现了错误报告，那么执行exec时整个的命令队列都会被取消，即所有的命令都不会成功执行。这个过程的示意图如下：

如果在执行阶段的某个命令报出了错误（比如对一个非整数型的值进行incr自增），则执行exec时只有报错的命令不会被执行，而其他的命令都会执行，不会回滚。这个过程的示意图如下

Redis事务三特性

1. 单独的隔离操作
   事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。

2. 没有隔离级别的概念
   队列中的命令没有提交之前都不会实际被执行，因为事务提交前任何指令都不会被实际执行。

3. 不保证原子性
   事务中如果有一条命令执行失败，其后的命令仍然会被执行，没有回滚。

九、主从复制

通过使用 slaveof host port 命令来让一个服务器成为另一个服务器的从服务器。

一个从服务器只能有一个主服务器，并且不支持主主复制。

连接过程

1. 主服务器创建快照文件，发送给从服务器，并在发送期间使用缓冲区记录执行的写命令。快照文件发送完毕之后，开始向从服务器发送存储在缓冲区中的写命令；

2. 从服务器丢弃所有旧数据，载入主服务器发来的快照文件，之后从服务器开始接受主服务器发来的写命令；

3. 主服务器每执行一次写命令，就向从服务器发送相同的写命令。

主从链

随着负载不断上升，主服务器可能无法很快地更新所有从服务器，或者重新连接和重新同步从服务器将导致系统超载。为了解决这个问题，可以创建一个中间层来分担主服务器的复制工作。中间层的服务器是最上层服务器的从服务器，又是最下层服务器的主服务器

十、Sentinel

Sentinel（哨兵）可以监听集群中的服务器，并在主服务器进入下线状态时，自动从从服务器中选举出新的主服务器

十一、常用命令

全局命令

查看所有键：keys *
查看键总数：dbsize
查看键是否存在：exists key
删除键：del key
设置键过期：expire key seconds/时间戳

字符串STRING类型

设置值：set key value
key不存在才设置值：setnx
key存在更新值：set key value xx
获取值：get key
自增减；incr key，decr key，incrby，decrby
追加：append key 追加的串
字符串长度：strlen
设置并返回原值：getset
设置指定位置的字符：setrange key 下标 设置的值
得到指定位置的字符：setrange key 下标开始 结束

列表LIST类型

前缀为l

lpush，lpop，rpush，rpop
lrange 开始 结束：获取指定范围内元素
lrem key count 要删除的元素：count>0从左到右删最多count个，<0从右到左，=0全删
ltrim key 开始 结束：保留开始到结束闭区间的元素
lset key 下标 修改的值：修改值
lindex：获取指定下标元素
llen：获取列表长度

集合SET类型

前缀为s

sadd
srem
scard：计算元素个数
sismember：相当于contains
srandmember：从集合中堆积返回数字
spop：随机弹出，弹出后集合中会删除
smembers：列出所有元素
sinter，sunion，sdiff：交并差

有序集合ZSET类型

前缀为z
有序集合给每个元素设置一个分数（score）作为排序的依据

zadd key score 元素：往key这个zset里加分数为score的元素，有nx，xx选项
zcard：返回成员个数
zscore：返回成员分数
zrank：计算成员排名
zrem：删除成员
zincrby：增加成员分数

散列表HASH类型

前缀为h
对于过期时间，只能对整个键设置过期时间，而不能对表中具体某个键值对设置过期时间

hset key field value：给名为key的hash表里添加field-value键值对
hget
hdel
hhexists
hkeys：获取键集合
hvals：获取值集合
hgetall：获取键值集合
hincrby：增加

十二、常见问题

1. Redis 为什么这么快？

1. Redis 基于内存，内存的访问速度是磁盘的上千倍；
2. Redis 基于 Reactor 模式设计开发了一套高效的事件处理模型，主要是单线程事件循环和 IO 多路复用；
3. Redis 内置了多种优化过后的数据结构实现，性能非常高。

2. Redis 应用

1. 分布式锁：通过 Redis 来做分布式锁是一种比较常见的方式。通常情况下，我们都是基于 Redisson 来实现分布式锁。关于 Redis 实现分布式锁的详细介绍参考redis实现分布式锁
2. 限流
3. 消息队列：Redis 自带的 list 数据结构可以作为一个简单的队列使用
4. 复杂业务场景 ：通过 Redis 以及 Redis 扩展（比如 Redisson）提供的数据结构，我们可以很方便地完成很多复杂的业务场景比如通过 bitmap 统计活跃用户、通过 sorted set 维护排行榜

3. Redis常用数据结构

5 种基础数据结构 ：String（字符串）、List（列表）、Set（集合）、Hash（散列）、Zset（有序集合）链出去
3 种特殊数据结构 ：HyperLogLogs（基数统计）、Bitmap （位存储）、Geospatial (地理位置)

4. Redis线程模型

对于读写命令来说，Redis 一直是单线程模型
Redis 4.0 版本之后引入了多线程来执行一些大键值对的异步删除操作
Redis 6.0 版本之后引入了多线程来处理网络请求（提高网络 IO 读写性能）

Redis单线程模型

Redis 基于 Reactor 模式开发了自己的网络事件处理器：这个处理器被称为文件事件处理器（file event handler）。

• 文件事件处理器使用 I/O 多路复用（multiplexing）程序来同时监听多个套接字，并根据套接字目前执行的任务来为套接字关联不同的事件处理器。
• 当被监听的套接字准备好执行连接应答（accept）、读取（read）、写入（write）、关闭（close）等操作时，与操作相对应的文件事件就会产生，这时文件事件处理器就会调用套接字之前关联好的事件处理器来处理这些事件。

I/O 多路复用技术的使用让 Redis 不需要额外创建多余的线程来监听客户端的大量连接，降低了资源的消耗

文件事件处理器（file event handler）主要是包含 4 个部分：

• 多个 socket（客户端连接）
• IO 多路复用程序（支持多个客户端连接的关键）
• 文件事件分派器（将 socket 关联到相应的事件处理器）
• 事件处理器（连接应答处理器、命令请求处理器、命令回复处理器）
  

引入多线程

Redis6.0 引入多线程主要是为了提高网络 IO 读写性能，因为这个算是 Redis 中的一个性能瓶颈（Redis 的瓶颈主要受限于内存和网络，不在CPU）。

虽然，Redis6.0 引入了多线程，但是 Redis 的多线程只是在网络数据的读写这类耗时操作上使用了，执行命令仍然是单线程顺序执行。因此，你也不需要担心线程安全问题。

Redis6.0 的多线程默认是禁用的，只使用主线程。如需开启需要设置 IO 线程数 > 1，需要修改 redis 配置文件 redis.conf

但是官网描述开启多线程读并不能有太大提升，因此一般情况下并不建议开启

5.Redis 是如何判断数据是否过期的呢？

Redis 通过一个叫做过期字典（可以看作是 hash 表）来保存数据过期的时间。过期字典的键指向 Redis 数据库中的某个 key(键)，过期字典的值是一个 long long 类型的整数，这个整数保存了 key 所指向的数据库键的过期时间（毫秒精度的 UNIX 时间戳）

过期字典是存储在 redisDb 这个结构里的：

typedef struct redisDb {
    ...

    dict *dict;     //数据库键空间,保存着数据库中所有键值对
    dict *expires   // 过期字典,保存着键的过期时间
    ...
} redisDb;

6.Redis生产问题

缓存穿透

1. 描述：请求的 key 不存在于缓存中，也不存在于数据库中，这就导致这些请求直接到了数据库上，根本没有经过缓存这一层，对数据库造成了巨大的压力，可能直接就被这么多请求弄宕机了
   
2. 解决：
   • 做好参数校验，一些不合法的参数请求直接抛出异常信息返回给客户端
   • 缓存无效 key
   • 布隆过滤器：判断请求的key是不是不存在在数据库中

缓存击穿

1. 描述：请求的 key 存在于数据库中，但不存在于缓存中（通常是因为缓存中的那份数据已经过期） 。这就可能会导致瞬时大量的请求直接打到了数据库上，对数据库造成了巨大的压力，可能直接就被这么多请求弄宕机了。

   举个例子 ：秒杀进行过程中，缓存中的某个秒杀商品的数据突然过期，这就导致瞬时大量对该商品的请求直接落到数据库上，对数据库造成了巨大的压力。

2. 解决：

   • 设置热点数据永不过期或者过期时间比较长。
   • 针对热点数据提前预热，将其存入缓存中并设置合理的过期时间比如秒杀场景下的数据在秒杀结束之前不过期。
   • 限流：请求数据库写数据到缓存之前，先获取互斥锁，保证只有一个请求会落到数据库上，减少数据库的压力。

缓存雪崩

1. 描述：缓存在同一时间大面积的失效，导致大量的请求都直接落到了数据库上，对数据库造成了巨大的压力

   举个例子 ：数据库中的大量数据在同一时间过期，这个时候突然有大量的请求需要访问这些过期的数据。这就导致大量的请求直接落到数据库上，对数据库造成了巨大的压力
   

2. 解决：

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

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

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

  • 设置不同的失效时间比如随机设置缓存的失效时间
  • 缓存永不失效（不太推荐，实用性太差）
  • 设置二级缓存

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

lian