Redis优点：

1. 少量数据存储，高速读写访问。通过数据全部in-momery 的方式来保证高速访问，同时提供数据落地的功能，实际这正是Redis最主要的适用场景。
2. 海量数据存储，分布式系统支持，数据一致性保证，方便的集群节点添加/删除。
3. 内置了集合数据类型，并支持对集合执行交集、 并集、差集等集合计算操作（关系型数据库并不直接支持交集计算操作，要计算两个集合的交集，除了需要对两个数据表执行合并（join）操作外，还需要对合并的结果执行去重复（distinct）操作）；

Ｒedis细节：

1. Redis禁用flushAll，flushDb，keys命令
 Redis提供了非常简单且有效的方法，直接在配置文件中设置禁用这些命令。设置非常简单，如下
 rename-command flushAll ""
 rename-command flushDb""
 rename-command keys ""
 rename-command命名无法直接对线上集群生效。如果需要使用rename-command，必须重启集群。

 禁用这3个命令是为了规避大的风险。
  1. flushAll，flushDb 命令会清空数据，而且从不失败，对于线上集群非常危险。
  2. keys * 命令，当数据规模较大时使用，会严重影响Redis性能，也非常危险。

2. Ｒedis初始化服务器时，程序会根据服务器状态dbunm属性来决定应该创建多少个数据库。dbnum属性的值由服务器配置的databasr选项决定，默认为16,Ｒedis服务器默认会创建16个服务器。

3. Ｒedis数据库中的所有键值对，由redisDb中的dict字典字段来保存，所以对数据库的添加、删除、更新、取值操作，实际上都是通过对字典的操作来实现的。
   * 在读取（读操作写操作都要）一个键盘之后，服务器会根据键是否存在来更新服务器中的键空间命中（hit）或不命中（miss）次数，这两个值可以在INFO status命令的keysapce_hits属性和keyspace_misses属性中查看；
   * 在读取（读操作写操作都要）一个键盘之后服务器会更新键的lru（最后一次使用）时间，这个值可以用于计算键的空闲时间，使用OBJECT idletime<key>命令可以查看键key的闲置时间；
   * 如果服务器在读取一个键时发现该键已经过期，那么服务器会删除这个过期键，然后才执行余下的其他操作（TODO）
   * 如果有客户端使用ＷATCH命令监视看某个键，那么服务器在对被监视的键进行修改之后，会将这个键标记为脏（dirty），从而让事务程序注意到这个键已经被修改（TODO）
   * 服务器每次修改一个键之后，都会对脏（dirty）键计数器的值增1,这个计数器会触发服务器的持久化以及复制操作（TODO）
   * 如果服务器开启了数据库通知功能，那么在对键进行修改之后，服务器将按配置发送相应的数据库通知（TODO）

4. Redis的过期删除策略：惰性删除和定期删除。

• 惰性删除：放任键过期不管，但是每次从键空间中获取键时，都检查取得的键是否过期，如果过期的话，就删除该键；如果没有过期，就返回该键（内存占用过大，如果一个键过期了，但是一直没被访问）；
• 定期删除*：每隔一段时间，程序就对数据库进行一次检查，删除里面的过期键。至于要删除多少过期键，以及检查多少数据库，由算法决定；（cpu时间占用过长，在过期键比较多的情况下）
  可以根据服务器的情况，合理设置定期删除的时长和执行效率。定期删除在redis.conf 的hz选项，默认为10 （即1秒执行10次，100ms一次）

当主服务器删除一个过期键之后，它会向所有从服务器发送一条DEL命令，显式地删除过期键；从服务器即使发现过期键也不会自作主张地删除它，而是等待主节点发来DEL命令,这样可以保证从数据的一致性。

5.Pub/Sub v.s. 消息中间
Reids的Pub/Sub与消息中间件相比，并不支持持久化，如系统宕机，网络问题等都会造成消息丢失；

Redis的消息多用于实时性较高的消息推送，并不保证可靠性。Redis的消息也无法支持水平扩展，

如通过增加consumer或者订阅者分组之类进行负载均衡。

性能方面，Redis的Pub/Sub与常用消息中间件如著名的RabbitMQ比较，则伯仲之间。

11.jpeg

上图以处理10万个消息为例，在发布消息方面，RabbitMQ的耗时为Redis的75%；订阅消费消息

RabbitMQ耗时为Redis的86%，可见整体性能Redis已与消息中间件相近。

6.LRU

LRU(Least Recently Used) 最近最久未使用算法，是多数缓存系统当内存受限时自动清理旧数据的

常用常用算法之一。当Redis使用内存达到配置maxmemory时，Redis会根据配置的policy进行数据置

换处理，其中策略包括如下：

• noenviction（不清除）

• allkeys-lru（从所有数据集选择最近最少用）

• volatile-lru（从设置过期时间的数据集选择最近最少用）

• allkeys-random（所有数据集随机选取淘汰），

• volatile-random（以设置过期时间数据集中随机），

• volatile-ttl（从已设置过期过期时间的数据集中选择，非LRU）

Redis出于性能及节约内存考量，采用的并非严格意义LRU算法算法，而是近似的LRU算法，即Redis通过采样

一小部分键，然后在样本池中进行LRU。当然在Redis 3.0中，算法进一步改进为维护回收候选键池，改善了性

能同时更接近于LRU算法行为。

7.事务

事务可以一次执行多个命令， 并且带有以下两个重要的保证：

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

• 事务是一个原子操作：事务中的命令要么全部被执行，要么全部都不执行。

  EXEC 命令负责触发并执行事务中的所有命令：

  • 如果客户端在使用 MULTI 开启了一个事务之后，却因为断线而没有成功执行 EXEC ，那么事务中的所有命令都不会被执行。
  • 另一方面，如果客户端成功在开启事务之后执行 EXEC ，那么事务中的所有命令都会被执行。

  当使用 AOF 方式做持久化的时候， Redis 会使用单个 write(2)命令将事务写入到磁盘中。

  然而，如果 Redis 服务器因为某些原因被管理员杀死，或者遇上某种硬件故障，那么可能只有部分事务命令会被成功写入到磁盘中。

  如果 Redis 在重新启动时发现 AOF 文件出了这样的问题，那么它会退出，并汇报一个错误。

  使用 redis-check-aof程序可以修复这一问题：它会移除 AOF 文件中不完整事务的信息，确保服务器可以顺利启动。

用法

MULTI 命令用于开启一个事务，它总是返回 OK 。

MULTI 执行之后， 客户端可以继续向服务器发送任意多条命令， 这些命令不会立即被执行， 而是被放到一个队列中， 当 EXEC 命令被调用时， 所有队列中的命令才会被执行。

另一方面， 通过调用 DISCARD ， 客户端可以清空事务队列， 并放弃执行事务。

以下是一个事务例子， 它原子地增加了 foo 和 bar两个键的值：

> MULTI
OK

> INCR foo
QUEUED

> INCR bar
QUEUED

> EXEC
1) (integer) 1
2) (integer) 1

EXEC 命令的回复是一个数组， 数组中的每个元素都是执行事务中的命令所产生的回复。 其中， 回复元素的先后顺序和命令发送的先后顺序一致。

当客户端处于事务状态时， 所有传入的命令都会返回一个内容为 <tt class="docutils literal" style="background-color: transparent; font-size: 1.1em; font-family: monospace;">QUEUED</tt> 的状态回复（status reply）， 这些被入队的命令将在 EXEC 命令被调用时执行。

Redis 不支持回滚（roll back）

放弃事务

当执行 DISCARD 命令时， 事务会被放弃， 事务队列会被清空， 并且客户端会从事务状态中退出：

redis> SET foo 1
OK

redis> MULTI
OK

redis> INCR foo
QUEUED

redis> DISCARD
OK

redis> GET foo
"1"

WATCH 命令

WATCH 命令可以为 Redis 事务提供 check-and-set （CAS）行为。

被 WATCH 的键会被监视，并会发觉这些键是否被改动过了。 如果有至少一个被监视的键在 EXEC 执行之前被修改了， 那么整个事务都会被取消， EXEC 返回空多条批量回复（null multi-bulk reply）来表示事务已经失败。

举个例子， 假设我们需要原子性地为某个值进行增 <tt class="docutils literal" style="background-color: transparent; font-size: 1.1em; font-family: monospace;">1</tt> 操作（假设 INCR 不存在）。

首先我们可能会这样做：

val = GET mykey
val = val + 1
SET mykey $val

上面的这个实现在只有一个客户端的时候可以执行得很好。 但是， 当多个客户端同时对同一个键进行这样的操作时， 就会产生竞争条件。

举个例子， 如果客户端 A 和 B 都读取了键原来的值， 比如 10 ， 那么两个客户端都会将键的值设为 11 ， 但正确的结果应该是 12 才对。

有了 WATCH ， 我们就可以轻松地解决这类问题了：

WATCH mykey

val = GET mykey
val = val + 1

MULTI
SET mykey $val
EXEC

使用上面的代码， 如果在 WATCH 执行之后， EXEC 执行之前， 有其他客户端修改了 mykey 的值， 那么当前客户端的事务就会失败。 程序需要做的， 就是不断重试这个操作， 直到没有发生碰撞为止。

这种形式的锁被称作乐观锁， 它是一种非常强大的锁机制。 并且因为大多数情况下， 不同的客户端会访问不同的键， 碰撞的情况一般都很少， 所以通常并不需要进行重试。

——————————————————————————————————————————————————————

在运行情况下， Redis 以数据结构的形式将数据维持在内存中， 为了让这些数据在 Redis 重启之后仍然可用， Redis 分别提供了 RDB 和 AOF 两种持久化模式。

R D B

在 Redis 运行时， RDB 程序将当前内存中的数据库快照保存到磁盘文件中， 在 Redis 重启动时， RDB 程序可以通过载入 RDB 文件来还原数据库的状态。这种持久化方式被称为快照（snapshot）。

RDB 功能最核心的是 rdbSave 和 rdbLoad 两个函数， 前者用于生成 RDB 文件到磁盘， 而后者则用于将 RDB 文件中的数据重新载入到内存中

RDB.png

RDB文件的创建和载入

有两个Ｒedis命令可以用于生成ＲDB文件，一个是SAVE,一个是BGSAVE。

区别：

1. SAVE命令会阻塞Ｒedis服务器进程，知道ＲＤＢ文件创建完成，BGSAVE则是派生出一个子进程来负责创建ＲＤＢ
2. BGSAVE命令可以通过设置save选项来触发执行，可以对 Redis 进行设置， 让它在“ N 秒内数据集至少有 M 个改动”这一条件被满足时， 自动保存一次数据集

以下设置会让 Redis 在满足“ 60 秒内有至少有 1000 个键被改动”这一条件时， 自动保存一次数据集：

save 60 1000

服务器在启动时载入ＲＤＢ文件，会一直处于阻塞状态直到载入成功

ＡＯＦ

AOF通过保存Ｒedis服务器执行的写命令来记录数据库状态。

AOF.png

每当 Redis 执行一个改变数据集的命令时（比如 SET）， 这个命令就会被追加到 AOF 文件的末尾。

这样的话， 当 Redis 重新启时， 程序就可以通过重新执行 AOF 文件中的命令来达到重建数据集的目的。

AOF重写

因为 AOF 的运作方式是不断地将命令追加到文件的末尾， 所以随着写入命令的不断增加， AOF 文件的体积也会变得越来越大。

举个例子， 如果你对一个计数器调用了 100 次 INCR ， 那么仅仅是为了保存这个计数器的当前值， AOF 文件就需要使用 100 条记录（entry）。

然而在实际上， 只使用一条 SET 命令已经足以保存计数器的当前值了， 其余 99 条记录实际上都是多余的。

为了处理这种情况， Redis 支持一种有趣的特性： 可以在不打断服务客户端的情况下， 对 AOF 文件进行重建（rebuild）。

执行 BGREWRITEAOF 命令， Redis 将生成一个新的 AOF 文件， 这个文件包含重建当前数据集所需的最少命令。

RDB 和 AOF比较

RDB 的优点：

• RDB 是一个非常紧凑（compact）的文件，它保存了 Redis 在某个时间点上的数据集。 这种文件非常适合用于进行备份： 比如说，你可以在最近的 24 小时内，每小时备份一次 RDB 文件，并且在每个月的每一天，也备份一个 RDB 文件。 这样的话，即使遇上问题，也可以随时将数据集还原到不同的版本。
• RDB 非常适用于灾难恢复（disaster recovery）：它只有一个文件，并且内容都非常紧凑，可以（在加密后）将它传送到别的数据中心，或者亚马逊 S3 中。
• RDB 可以最大化 Redis 的性能：父进程在保存 RDB 文件时唯一要做的就是 fork 出一个子进程，然后这个子进程就会处理接下来的所有保存工作，父进程无须执行任何磁盘 I/O 操作。
• RDB 在恢复大数据集时的速度比 AOF 的恢复速度要快。

RDB 的缺点：

• 如果你需要尽量避免在服务器故障时丢失数据，那么 RDB 不适合你。 虽然 Redis 允许你设置不同的保存点（save point）来控制保存 RDB 文件的频率， 但是， 因为RDB 文件需要保存整个数据集的状态， 所以它并不是一个轻松的操作。 因此你可能会至少 5 分钟才保存一次 RDB 文件。 在这种情况下， 一旦发生故障停机， 你就可能会丢失好几分钟的数据。
• 每次保存 RDB 的时候，Redis 都要 fork() 出一个子进程，并由子进程来进行实际的持久化工作。 在数据集比较庞大时， fork() 可能会非常耗时，造成服务器在某某毫秒内停止处理客户端； 如果数据集非常巨大，并且 CPU 时间非常紧张的话，那么这种停止时间甚至可能会长达整整一秒。 虽然 AOF 重写也需要进行 fork() ，但无论 AOF 重写的执行间隔有多长，数据的耐久性都不会有任何损失。

AOF 的优点:

• 使用 AOF 持久化会让 Redis 变得非常耐久（much more durable）：你可以设置不同的fsync策略，比如无 fsync，每秒钟一次fsync，或者每次执行写入命令时fsync 。 AOF 的默认策略为每秒钟fsync 一次，在这种配置下，Redis 仍然可以保持良好的性能，并且就算发生故障停机，也最多只会丢失一秒钟的数据（ fsync会在后台线程执行，所以主线程可以继续努力地处理命令请求）。
• AOF 文件是一个只进行追加操作的日志文件（append only log）， 因此对 AOF 文件的写入不需要进行 seek ， 即使日志因为某些原因而包含了未写入完整的命令（比如写入时磁盘已满，写入中途停机，等等），redis-check-aof 工具也可以轻易地修复这种问题。
• Redis 可以在 AOF 文件体积变得过大时，自动地在后台对 AOF 进行重写： 重写后的新 AOF 文件包含了恢复当前数据集所需的最小命令集合。 整个重写操作是绝对安全的，因为 Redis 在创建新 AOF 文件的过程中，会继续将命令追加到现有的 AOF 文件里面，即使重写过程中发生停机，现有的 AOF 文件也不会丢失。 而一旦新 AOF 文件创建完毕，Redis 就会从旧 AOF 文件切换到新 AOF 文件，并开始对新 AOF 文件进行追加操作。
• AOF 文件有序地保存了对数据库执行的所有写入操作， 这些写入操作以 Redis 协议的格式保存， 因此 AOF 文件的内容非常容易被人读懂， 对文件进行分析（parse）也很轻松。 导出（export） AOF 文件也非常简单： 举个例子， 如果你不小心执行了 FLUSHALL 命令， 但只要 AOF 文件未被重写， 那么只要停止服务器， 移除 AOF 文件末尾的 FLUSHALL 命令， 并重启 Redis ， 就可以将数据集恢复到 FLUSHALL 执行之前的状态。

AOF 的缺点：

• 对于相同的数据集来说，AOF 文件的体积通常要大于 RDB 文件的体积。

当 Redis 启动时， 如果 RDB 持久化和 AOF 持久化都被打开了， 那么程序会优先使用 AOF 文件来恢复数据集， 因为 AOF 文件所保存的数据通常是最完整的。

主从，支持读写分离

调用 SLAVEOF 命令， 输入主服务器的 IP 和端口， 然后同步就会开始：

127.0.0.1:6379> SLAVEOF 192.168.1.1 10086
OK

从服务器支持只读模式， 并且该模式为从服务器的默认模式。

只读模式由redis.conf 文件中的 slave-read-only 选项控制， 也可以通过CONFIG SET
命令来开启或关闭这个模式。

只读从服务器会拒绝执行任何写命令， 所以不会出现因为操作失误而将数据不小心写入到了从服务器的情况。

网络模型

Redis使用单线程的IO复用模型，自己封装了一个简单的AeEvent事件处理框架，主要实现了epoll、kqueue和select，对于单纯只有IO操作来说，单线程可以将速度优势发挥到最大，但是Redis也提供了一些简单的计算功能，比如排序、聚合等，对于这些操作，单线程模型实际会严重影响整体吞吐量，CPU计算过程中，整个IO调度都是被阻塞住的。

内存管理

Redis使用现场申请内存的方式来存储数据，并且很少使用free-list等方式来优化内存分配，会在一定程度上存在内存碎片，Redis跟据存储命令参数，会把带过期时间的数据单独存放在一起，并把它们称为临时数据，非临时数据是永远不会被剔除的，即便物理内存不够，导致swap也不会剔除任何非临时数据（但会尝试剔除部分临时数据），这点上Redis更适合作为存储而不是cache。