发布订阅模式

列表的局限

通过队列的rpush 和lpop 可以实现消息队列（队尾进队头出），但是消费者需要不停地调用lpop 查看List 中是否有等待处理的消息（比如写一个while 循环）。为了减少通信的消耗，可以sleep()一段时间再消费，但是会有两个问题：
1、如果生产者生产消息的速度远大于消费者消费消息的速度，List 会占用大量的内存。
2、消息的实时性降低。

list 还提供了一个阻塞的命令：blpop，没有任何元素可以弹出的时候，连接会被阻
塞。

blpop queue 5

基于list 实现的消息队列，不支持一对多的消息分发。

发布订阅模式

除了通过list 实现消息队列之外，Redis 还提供了一组命令实现发布/订阅模式。
这种方式，发送者和接收者没有直接关联（实现了解耦），接收者也不需要持续尝试获取消息。

订阅频道

首先，我们有很多的频道（channel），我们也可以把这个频道理解成queue。订阅者可以订阅一个或者多个频道。消息的发布者（生产者）可以给指定的频道发布消息。
只要有消息到达了频道，所有订阅了这个频道的订阅者都会收到这条消息。
需要注意的注意是，发出去的消息不会被持久化，因为它已经从队列里面移除了，所以消费者只能收到它开始订阅这个频道之后发布的消息。
下面我们来看一下发布订阅命令的使用方法。
订阅者订阅频道：可以一次订阅多个，比如这个客户端订阅了3 个频道。

subscribe channel-1 channel-2 channel-3

发布者可以向指定频道发布消息（并不支持一次向多个频道发送消息）：

publish channel-1 2673

取消订阅（不能在订阅状态下使用）：

unsubscribe channel-1

按规则（Pattern）订阅频道

支持?和占位符。?代表一个字符，代表0 个或者多个字符。
消费端1，关注运动信息:

psubscribe *sport

消费端2，关注所有新闻：

psubscribe news*

消费端3，关注天气新闻：

psubscribe news-weather

生产者，发布3 条信息

publish news-sport yaoming
publish news-music jaychou
publish news-weather rain

Redis 事务

为什么要用事务

Redis 的单个命令是原子性的（比如get set mget mset），如果涉及到多个命令的时候，需要把多个命令作为一个不可分割的处理序列，就需要用到事务。
例如我们之前说的用setnx 实现分布式锁，我们先set，然后设置对key 设置expire，防止del 发生异常的时候锁不会被释放，业务处理完了以后再del，这三个动作我们就希望它们作为一组命令执行。
Redis 的事务有两个特点：
1、按进入队列的顺序执行。
2、不会受到其他客户端的请求的影响。
Redis 的事务涉及到四个命令：multi（开启事务），exec（执行事务），discard（取消事务），watch（监视）

事务的用法

案例场景：a 和b 各有1000 元，a 需要向b 转账100 元。
a 的账户余额减少100 元，b 的账户余额增加100 元。

127.0.0.1:6379> set a 1000
OK
127.0.0.1:6379> set b 1000
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> decrby a 100
QUEUED
127.0.0.1:6379> incrby b 100
QUEUED
127.0.0.1:6379> exec
1) (integer) 900
2) (integer) 1100
127.0.0.1:6379> get a
"900"
127.0.0.1:6379> get b
"1100"

通过multi 的命令开启事务。事务不能嵌套，多个multi 命令效果一样。
multi 执行后，客户端可以继续向服务器发送任意多条命令， 这些命令不会立即被执行， 而是被放到一个队列中， 当exec 命令被调用时， 所有队列中的命令才会被执行。
通过exec 的命令执行事务。如果没有执行exec，所有的命令都不会被执行。
如果中途不想执行事务了，怎么办？
可以调用discard 可以清空事务队列，放弃执行。

multi
set k1 1
set k2 2
set k3 3
discard

watch 命令

在Redis 中还提供了一个watch 命令。
它可以为Redis 事务提供CAS 乐观锁行为（Check and Set / Compare andSwap），也就是多个线程更新变量的时候，会跟原值做比较，只有它没有被其他线程修改的情况下，才更新成新的值。
我们可以用watch 监视一个或者多个key，如果开启事务之后，至少有一个被监视key 键在exec 执行之前被修改了， 那么整个事务都会被取消（key 提前过期除外）。可以用unwatch 取消。

先在client 1 执行

127.0.0.1:6379> set balance 1000
OK
127.0.0.1:6379> watch balance
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> incrby balance 100
QUEUED

再新开一个client 2执行

127.0.0.1:6379> decrby balance 100
(integer) 900

回到client 1 执行
127.0.0.1:6379> exec
(nil)
127.0.0.1:6379> get balance
"900"

事务可能遇到的问题

我们把事务执行遇到的问题分成两种，一种是在执行exec 之前发生错误，一种是在执行exec 之后发生错误。

在执行exec 之前发生错误

比如：入队的命令存在语法错误，包括参数数量，参数名等等（编译器错误）。
在这种情况下事务会被拒绝执行，也就是队列中所有的命令都不会得到执行。

在执行exec 之后发生错误

比如，类型错误，比如对String 使用了Hash 的命令，这是一种运行时错误。

127.0.0.1:6379> flushall
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> set k1 1
QUEUED
127.0.0.1:6379> hset k1 a b
QUEUED
127.0.0.1:6379> exec
1) OK
2) (error) WRONGTYPE Operation against a key holding the wrong kind of value
127.0.0.1:6379> get k1
"1"

最后我们发现set k1 1 的命令是成功的，也就是在这种发生了运行时异常的情况下，只有错误的命令没有被执行，但是其他命令没有受到影响。
这个显然不符合我们对原子性的定义，也就是我们没办法用Redis 的这种事务机制来实现原子性，保证数据的一致。

Lua 脚本

Lua/ˈluə/是一种轻量级脚本语言，它是用C 语言编写的，跟数据的存储过程有点类似。使用Lua 脚本来执行Redis 命令的好处：
1、一次发送多个命令，减少网络开销。
2、Redis 会将整个脚本作为一个整体执行，不会被其他请求打断，保持原子性。
3、对于复杂的组合命令，我们可以放在文件中，可以实现程序之间的命令集复用。

在Redis 中调用Lua 脚本

使用eval /ɪ'væl/ 方法，语法格式：

redis> eval lua-script key-num [key1 key2 key3 ....] [value1 value2 value3 ....]

• eval 代表执行Lua 语言的命令。
• lua-script 代表Lua 语言脚本内容。
• key-num 表示参数中有多少个key，需要注意的是Redis 中key 是从1 开始的，如果没有key 的参数，那么写0。
• [key1 key2 key3…]是key 作为参数传递给Lua 语言，也可以不填，但是需要和key-num 的个数对应起来。
• [value1 value2 value3 ….]这些参数传递给Lua 语言，它们是可填可不填的。

示例，返回一个字符串，0 个参数：

redis> eval "return 'Hello World'" 0

在Lua 脚本中调用Redis 命令

使用redis.call(command, key [param1, param2…])进行操作。语法格式：

redis> eval "redis.call('set',KEYS[1],ARGV[1])" 1 lua-key lua-value

• command 是命令，包括set、get、del 等。
• key 是被操作的键。
• param1,param2…代表给key 的参数。
  注意跟Java 不一样，定义只有形参，调用只有实参。
  Lua 是在调用时用key 表示形参，argv 表示参数值（实参）。

设置键值对

在Redis 中调用Lua 脚本执行Redis 命令

redis> eval "return redis.call('set',KEYS[1],ARGV[1])" 1 wei 1234
redis> get wei

以上命令等价于set wei 1234。
在redis-cli 中直接写Lua 脚本不够方便，也不能实现编辑和复用，通常我们会把脚本放在文件里面，然后执行这个文件。

在Redis 中调用Lua 脚本文件中的命令，操作Redis

创建Lua 脚本文件：
cd /usr/local/soft/redis5.0.5/src
vim wei.lua

redis.call('set','wei','lua666')
return redis.call('get','wei')

在Redis 客户端中调用Lua 脚本

cd /usr/local/soft/redis5.0.5/src
redis-cli --eval wei.lua 0

得到返回值：

"lua666"

案例：对IP 进行限流

需求：在X 秒内只能访问Y 次。
设计思路：用key 记录IP，用value 记录访问次数。
拿到IP 以后，对IP+1。如果是第一次访问，对key 设置过期时间（参数1）。否则判断次数，超过限定的次数（参数2），返回0。如果没有超过次数则返回1。超过时间，key 过期之后，可以再次访问。
KEY[1]是IP， ARGV[1]是过期时间X，ARGV[2]是限制访问的次数Y。

-- ip_limit.lua
-- IP 限流，对某个IP 频率进行限制，6 秒钟访问10 次
local num=redis.call('incr',KEYS[1])
if tonumber(num)==1 then
redis.call('expire',KEYS[1],ARGV[1])
return 1
elseif tonumber(num)>tonumber(ARGV[2]) then
return 0
else
return 1
end

6 秒钟内限制访问10 次，调用测试（连续调用10 次）：

./redis-cli --eval "ip_limit.lua" app:ip:limit:192.168.1.102 , 6 10

• app:ip:limit:192.168.1.102 是key 值，后面是参数值，中间要加上一个空格和
  一个逗号，再加上一个空格。
  即：./redis-cli –eval [lua 脚本] [key…]空格,空格[args…]
• 多个参数之间用一个空格分割。

缓存Lua 脚本

在脚本比较长的情况下，如果每次调用脚本都需要把整个脚本传给Redis 服务端，会产生比较大的网络开销。为了解决这个问题，Redis 提供了EVALSHA 命令，允许开发者通过脚本内容的SHA1 摘要来执行脚本。

Redis 在执行script load 命令时会计算脚本的SHA1 摘要并记录在脚本缓存中，执行EVALSHA 命令时Redis 会根据提供的摘要从脚本缓存中查找对应的脚本内容，如果找到了则执行脚本，否则会返回错误："NOSCRIPT No matching script. Please useEVAL."

127.0.0.1:6379> script load "return 'Hello World'"
"470877a599ac74fbfda41caa908de682c5fc7d4b"
127.0.0.1:6379> evalsha "470877a599ac74fbfda41caa908de682c5fc7d4b" 0
"Hello World"

脚本超时

Redis 的指令执行本身是单线程的，这个线程还要执行客户端的Lua 脚本，如果Lua脚本执行超时或者陷入了死循环，是不是没有办法为客户端提供服务了呢？

eval 'while(true) do end' 0

为了防止某个脚本执行时间过长导致Redis 无法提供服务， Redis 提供了lua-time-limit 参数限制脚本的最长运行时间，默认为5 秒钟。
lua-time-limit 5000（redis.conf 配置文件中）

当脚本运行时间超过这一限制后，Redis 将开始接受其他命令但不会执行（以确保脚本的原子性，因为此时脚本并没有被终止），而是会返回“BUSY”错误。
Redis 提供了一个script kill 的命令来中止脚本的执行。新开一个客户端：

script kill

如果当前执行的Lua 脚本对Redis 的数据进行了修改（SET、DEL 等），那么通过script kill 命令是不能终止脚本运行的。

127.0.0.1:6379> eval "redis.call('set','wei','666') while true do end" 0

因为要保证脚本运行的原子性，如果脚本执行了一部分终止，那就违背了脚本原子性的要求。最终要保证脚本要么都执行，要么都不执行。

127.0.0.1:6379> script kill
(error) UNKILLABLE Sorry the script already executed write commands against the dataset. You can either wait the scripttermination or kill the server in a hard way using the SHUTDOWN NOSAVE command.

遇到这种情况，只能通过shutdown nosave 命令来强行终止redis。
shutdown nosave 和shutdown 的区别在于shutdown nosave 不会进行持久化操作，意味着发生在上一次快照后的数据库修改都会丢失。

Redis 为什么这么快

Redis 到底有多快？

https://redis.io/topics/benchmarks

cd /usr/local/soft/redis-5.0.5/src
redis-benchmark -t set,lpush -n 100000 -q

结果（本地虚拟机）：
SET: 51813.47 requests per second —— 每秒钟处理5 万多次set 请求
LPUSH: 51706.31 requests per second —— 每秒钟处理5 万多次lpush 请求

redis-benchmark -n 100000 -q script load "redis.call('set','foo','bar')"

结果（本地虚拟机）：
script load redis.call('set','foo','bar'): 46816.48 requests per second —— 每秒钟46000 次lua 脚本调用

image.png

根据官方的数据，Redis 的QPS 可以达到10 万左右（每秒请求数）。

Redis 为什么这么快？

总结：1）纯内存结构、2）单线程、3）多路复用

• 内存
  KV 结构的内存数据库，时间复杂度O(1)。
  第二个，要实现这么高的并发性能，是不是要创建非常多的线程？
  恰恰相反，Redis 是单线程的。
• 单线程有什么好处呢？
  1、没有创建线程、销毁线程带来的消耗
  2、避免了上线文切换导致的CPU 消耗
  3、避免了线程之间带来的竞争问题，例如加锁释放锁死锁等等
• 异步非阻塞
  异步非阻塞I/O，多路复用处理并发连接

Redis 为什么是单线程的？

不是白白浪费了CPU 的资源吗？
https://redis.io/topics/faq#redis-is-single-threaded-how-can-i-exploit-multiple-cpu--cores
因为单线程已经够用了，CPU 不是redis 的瓶颈。Redis 的瓶颈最有可能是机器内存或者网络带宽。既然单线程容易实现，而且CPU 不会成为瓶颈，那就顺理成章地采用单线程的方案了。

单线程为什么这么快？

因为Redis 是基于内存的操作，我们先从内存开始说起。

虚拟存储器（虚拟内存Vitual Memory）

名词解释：主存：内存；辅存：磁盘（硬盘）
计算机主存（内存）可看作一个由M 个连续的字节大小的单元组成的数组，每个字节有一个唯一的地址，这个地址叫做物理地址（PA）。早期的计算机中，如果CPU 需要内存，使用物理寻址，直接访问主存储器。
这种方式有几个弊端：
1、在多用户多任务操作系统中，所有的进程共享主存，如果每个进程都独占一块物理地址空间，主存很快就会被用完。我们希望在不同的时刻，不同的进程可以共用同一块物理地址空间。
2、如果所有进程都是直接访问物理内存，那么一个进程就可以修改其他进程的内存数据，导致物理地址空间被破坏，程序运行就会出现异常。
为了解决这些问题，我们就想了一个办法，在CPU 和主存之间增加一个中间层。CPU不再使用物理地址访问，而是访问一个虚拟地址，由这个中间层把地址转换成物理地址，最终获得数据。这个中间层就叫做虚拟存储器（Virtual Memory）。
具体的操作如下所示：

image.png

在每一个进程开始创建的时候，都会分配一段虚拟地址，然后通过虚拟地址和物理地址的映射来获取真实数据，这样进程就不会直接接触到物理地址，甚至不知道自己调用的哪块物理地址的数据。
目前，大多数操作系统都使用了虚拟内存，如Windows 系统的虚拟内存、Linux 系统的交换空间等等。Windows 的虚拟内存（pagefile.sys）是磁盘空间的一部分。

在32 位的系统上，虚拟地址空间大小是2^32bit=4G。在64 位系统上，最大虚拟地址空间大小是多少？是不是2^64bit=1024*1014TB=1024PB=16EB？实际上没有用到64 位，因为用不到这么大的空间，而且会造成很大的系统开销。Linux 一般用低48 位来表示虚拟地址空间，也就是2^48bit=256T。

cat /proc/cpuinfo

address sizes : 40 bits physical, 48 bits virtual

实际的物理内存可能远远小于虚拟内存的大小。
总结：引入虚拟内存，可以提供更大的地址空间，并且地址空间是连续的，使得程序编写、链接更加简单。并且可以对物理内存进行隔离，不同的进程操作互不影响。还可以通过把同一块物理内存映射到不同的虚拟地址空间实现内存共享。

用户空间和内核空间

为了避免用户进程直接操作内核，保证内核安全，操作系统将虚拟内存划分为两部分，一部分是内核空间（Kernel-space）/ˈkɜːnl /，一部分是用户空间（User-space）。

image.png

内核是操作系统的核心，独立于普通的应用程序，可以访问受保护的内存空间，也有访问底层硬件设备的权限。
内核空间中存放的是内核代码和数据，而进程的用户空间中存放的是用户程序的代码和数据。不管是内核空间还是用户空间，它们都处于虚拟空间中，都是对物理地址的映射。
在Linux 系统中, 内核进程和用户进程所占的虚拟内存比例是1:3。

image.png

进程在内核空间以执行任意命令，调用系统的一切资源；在用户空间只能执行简单的运算，不能直接调用系统资源，必须通过系统接口（又称system call），才能向内核发出指令。
top 命令：

image.png

us 代表CPU 消耗在User space 的时间百分比;
sy 代表CPU 消耗在Kernel space 的时间百分比。

进程切换（上下文切换）

任务操作系统是怎么实现运行远大于CPU 数量的任务个数的？当然，这些任务实际上并不是真的在同时运行，而是因为系统通过时间片分片算法，在很短的时间内，将CPU 轮流分配给它们，造成多任务同时运行的错觉。
为了控制进程的执行，内核必须有能力挂起正在CPU 上运行的进程，并恢复以前挂起的某个进程的执行。这种行为被称为进程切换。

什么叫上下文？
在每个任务运行前，CPU 都需要知道任务从哪里加载、又从哪里开始运行，也就是说，需要系统事先帮它设置好CPU 寄存器和程序计数器(Program Counter)，这个叫做CPU 的上下文。

而这些保存下来的上下文，会存储在系统内核中，并在任务重新调度执行时再次加载进来。这样就能保证任务原来的状态不受影响，让任务看起来还是连续运行。
在切换上下文的时候，需要完成一系列的工作，这是一个很消耗资源的操作。

进程的阻塞

正在运行的进程由于提出系统服务请求（如I/O 操作），但因为某种原因未得到操作系统的立即响应，该进程只能把自己变成阻塞状态，等待相应的事件出现后才被唤醒。
进程在阻塞状态不占用CPU 资源。

文件描述符FD

Linux 系统将所有设备都当作文件来处理，而Linux 用文件描述符来标识每个文件对象。
文件描述符（File Descriptor）是内核为了高效管理已被打开的文件所创建的索引，用于指向被打开的文件，所有执行I/O 操作的系统调用都通过文件描述符；文件描述符是一个简单的非负整数，用以表明每个被进程打开的文件。
Linux 系统里面有三个标准文件描述符。
0：标准输入（键盘）；1：标准输出（显示器）；2：标准错误输出（显示器）。

传统I/O 数据拷贝

以读操作为例：

当应用程序执行read 系统调用读取文件描述符（FD）的时候，如果这块数据已经存在于用户进程的页内存中，就直接从内存中读取数据。如果数据不存在，则先将数据从磁盘加载数据到内核缓冲区中，再从内核缓冲区拷贝到用户进程的页内存中。（两次拷贝，两次user 和kernel 的上下文切换）。

image.png

I/O 的阻塞到底阻塞在哪里？

Blocking I/O

当使用read 或write 对某个文件描述符进行过读写时，如果当前FD 不可读，系统就不会对其他的操作做出响应。从设备复制数据到内核缓冲区是阻塞的，从内核缓冲区拷贝到用户空间，也是阻塞的，直到copy complete，内核返回结果，用户进程才解除block 的状态。

image.png

为了解决阻塞的问题，我们有几个思路。
1、在服务端创建多个线程或者使用线程池，但是在高并发的情况下需要的线程会很多，系统无法承受，而且创建和释放线程都需要消耗资源。
2、由请求方定期轮询，在数据准备完毕后再从内核缓存缓冲区复制数据到用户空间（非阻塞式I/O），这种方式会存在一定的延迟。
能不能用一个线程处理多个客户端请求？

I/O 多路复用（I/O Multiplexing）

I/O 指的是网络I/O。
多路指的是多个TCP 连接（Socket 或Channel）。
复用指的是复用一个或多个线程。
它的基本原理就是不再由应用程序自己监视连接，而是由内核替应用程序监视文件描述符。

客户端在操作的时候，会产生具有不同事件类型的socket。在服务端，I/O 多路复用程序（I/O Multiplexing Module）会把消息放入队列中，然后通过文件事件分派器（Fileevent Dispatcher），转发到不同的事件处理器中。

image.png

多路复用有很多的实现，以select 为例，当用户进程调用了多路复用器，进程会被阻塞。内核会监视多路复用器负责的所有socket，当任何一个socket 的数据准备好了，多路复用器就会返回。这时候用户进程再调用read 操作，把数据从内核缓冲区拷贝到用户空间。

I/O 多路复用的特点是通过一种机制一个进程能同时等待多个文件描述符，而这些文件描述符（套接字描述符）其中的任意一个进入读就绪（readable）状态，select()函数就可以返回。

Redis 的多路复用， 提供了select, epoll, evport, kqueue 几种选择，在编译的时候来选择一种。源码ae.c

#ifdef HAVE_EVPORT
#include "ae_evport.c"
#else
#ifdef HAVE_EPOLL
#include "ae_epoll.c"
#else
#ifdef HAVE_KQUEUE
#include "ae_kqueue.c"
#else
#include "ae_select.c"
#endif
#endif
#endif

evport 是Solaris 系统内核提供支持的；
epoll 是LINUX 系统内核提供支持的；
kqueue 是Mac 系统提供支持的；
select 是POSIX 提供的，一般的操作系统都有支撑（保底方案）；
源码：ae_epoll.c、ae_select.c、ae_kqueue.c、ae_evport.c

内存回收

Reids 所有的数据都是存储在内存中的，在某些情况下需要对占用的内存空间进行回收。内存回收主要分为两类，一类是key 过期，一类是内存使用达到上限（max_memory）触发内存淘汰。

过期策略

• 定时过期（主动淘汰）
  每个设置过期时间的key 都需要创建一个定时器，到过期时间就会立即清除。该策略可以立即清除过期的数据，对内存很友好；但是会占用大量的CPU 资源去处理过期的数据，从而影响缓存的响应时间和吞吐量。
• 惰性过期（被动淘汰）
  只有当访问一个key 时，才会判断该key 是否已过期，过期则清除。该策略可以最大化地节省CPU 资源，却对内存非常不友好。极端情况可能出现大量的过期key 没有再次被访问，从而不会被清除，占用大量内存。
  例如String，在getCommand 里面会调用expireIfNeeded
  源码：server.c expireIfNeeded(redisDb *db, robj *key)

第二种情况，每次写入key 时，发现内存不够，调用activeExpireCycle 释放一部分内存。
源码：expire.c activeExpireCycle(int type)

• 定期过期
  源码：server.h

typedef struct redisDb {
dict *dict; /* 所有的键值对*/
dict *expires; /* 设置了过期时间的键值对*/
dict *blocking_keys; /* Keys with clients waiting for data (BLPOP)*/
dict *ready_keys; /* Blocked keys that received a PUSH */
dict *watched_keys; /* WATCHED keys for MULTI/EXEC CAS */
int id; /* Database ID */
long long avg_ttl; /* Average TTL, just for stats */
list *defrag_later; /* List of key names to attempt to defrag one by one, gradually. */
} redisDb;

每隔一定的时间，会扫描一定数量的数据库的expires 字典中一定数量的key，并清除其中已过期的key。该策略是前两者的一个折中方案。通过调整定时扫描的时间间隔和每次扫描的限定耗时，可以在不同情况下使得CPU 和内存资源达到最优的平衡效果。

Redis 中同时使用了惰性过期和定期过期两种过期策略。

淘汰策略

Redis 的内存淘汰策略，是指当内存使用达到最大内存极限时，需要使用淘汰算法来决定清理掉哪些数据，以保证新数据的存入。

• 最大内存设置
  redis.conf 参数配置：

# maxmemory <bytes>

如果不设置maxmemory 或者设置为0，64 位系统不限制内存，32 位系统最多使用3GB 内存。
动态修改：

redis> config set maxmemory 2GB

到达最大内存以后怎么办？

• 淘汰策略
  https://redis.io/topics/lru-cache
  redis.conf

# maxmemory-policy noeviction

# volatile-lru -> Evict using approximated LRU among the keys with an expire set.
# allkeys-lru -> Evict any key using approximated LRU.
# volatile-lfu -> Evict using approximated LFU among the keys with an expire set.
# allkeys-lfu -> Evict any key using approximated LFU.
# volatile-random -> Remove a random key among the ones with an expire set.
# allkeys-random -> Remove a random key, any key.
# volatile-ttl -> Remove the key with the nearest expire time (minor TTL)
# noeviction -> Don't evict anything, just return an error on write operations.

先从算法来看：
LRU，Least Recently Used：最近最少使用。判断最近被使用的时间，目前最远的数据优先被淘汰。
LFU，Least Frequently Used，最不常用，4.0 版本新增。
random，随机删除。

volatile-lru 根据LRU 算法删除设置了超时属性（expire）的键，直到腾出足够内存为止。如果没有
可删除的键对象，回退到noeviction 策略。

allkeys-lru 根据LRU 算法删除键，不管数据有没有设置超时属性，直到腾出足够内存为止。

volatile-lfu 在带有过期时间的键中选择最不常用的。

allkeys-lfu 在所有的键中选择最不常用的，不管数据有没有设置超时属性。

volatile-random 在带有过期时间的键中随机选择。

allkeys-random 随机删除所有键，直到腾出足够内存为止。

volatile-ttl 根据键值对象的ttl 属性，删除最近将要过期数据。如果没有，回退到noeviction 策略。

noeviction 默认策略，不会删除任何数据，拒绝所有写入操作并返回客户端错误信息（error）OOM command not allowed when used memory，此时Redis 只响应读操作。

如果没有符合前提条件的key 被淘汰，那么volatile-lru、volatile-random 、volatile-ttl 相当于noeviction（不做内存回收）。
动态修改淘汰策略：

redis> config set maxmemory-policy volatile-lru

建议使用volatile-lru，在保证正常服务的情况下，优先删除最近最少使用的key。

• LRU 淘汰原理
  需要额外的数据结构存储，消耗内存。
  Redis LRU 对传统的LRU 算法进行了改良，通过随机采样来调整算法的精度。
  如果淘汰策略是LRU，则根据配置的采样值maxmemory_samples（默认是5 个）,随机从数据库中选择m 个key, 淘汰其中热度最低的key 对应的缓存数据。所以采样参数m 配置的数值越大, 就越能精确的查找到待淘汰的缓存数据,但是也消耗更多的CPU 计算,执行效率降低。

如何找出热度最低的数据？

Redis 中所有对象结构都有一个lru 字段, 且使用了unsigned 的低24 位，这个字段用来记录对象的热度。对象被创建时会记录lru 值。在被访问的时候也会更新lru 的值。
但是不是获取系统当前的时间戳，而是设置为全局变量server.lruclock 的值。

源码：server.h

typedef struct redisObject {
unsigned type:4;
unsigned encoding:4;
unsigned lru:LRU_BITS; /* LRU time (relative to global lru_clock) or
* LFU data (least significant 8 bits frequency
* and most significant 16 bits access time). */
int refcount;
void *ptr;
} robj;

server.lruclock 的值怎么来的？
Redis 中有个定时处理的函数serverCron ， 默认每100 毫秒调用函数
updateCachedTime 更新一次全局变量的server.lruclock 的值，它记录的是当前unix时间戳。
源码：server.c

void updateCachedTime(void) {
time_t unixtime = time(NULL);
atomicSet(server.unixtime,unixtime);
server.mstime = mstime();
struct tm tm;
localtime_r(&server.unixtime,&tm);
server.daylight_active = tm.tm_isdst;
}

为什么不获取精确的时间而是放在全局变量中？不会有延迟的问题吗？

这样函数lookupKey 中更新数据的lru 热度值时,就不用每次调用系统函数time，可以提高执行效率。
OK，当对象里面已经有了LRU 字段的值，就可以评估对象的热度了。
函数estimateObjectIdleTime 评估指定对象的lru 热度，思想就是对象的lru 值和全局的server.lruclock 的差值越大（越久没有得到更新）， 该对象热度越低。
源码evict.c

/* Given an object returns the min number of milliseconds the object was never
* requested, using an approximated LRU algorithm. */
unsigned long long estimateObjectIdleTime(robj *o) {
unsigned long long lruclock = LRU_CLOCK();
if (lruclock >= o->lru) {
    return (lruclock - o->lru) * LRU_CLOCK_RESOLUTION;
} else {
    return (lruclock + (LRU_CLOCK_MAX - o->lru)) *
    LRU_CLOCK_RESOLUTION;
}
}

server.lruclock 只有24 位，按秒为单位来表示才能存储194 天。当超过24bit 能表示的最大时间的时候，它会从头开始计算。
server.h

#define LRU_CLOCK_MAX ((1<<LRU_BITS)-1) /* Max value of obj->lru */

在这种情况下，可能会出现对象的lru 大于server.lruclock 的情况，如果这种情况出现那么就两个相加而不是相减来求最久的key。

为什么不用常规的哈希表+双向链表的方式实现？需要额外的数据结构，消耗资源。
而Redis LRU 算法在sample 为10 的情况下，已经能接近传统LRU 算法了。
https://redis.io/topics/lru-cache

image.png

除了消耗资源之外，传统LRU 还有什么问题？

如图，假设A 在10 秒内被访问了5 次，而B 在10 秒内被访问了3 次。因为B 最后一次被访问的时间比A 要晚，在同等的情况下，A 反而先被回收。

image.png

要实现基于访问频率的淘汰机制，怎么做？

• LFU
  server.h

typedef struct redisObject {
unsigned type:4;
unsigned encoding:4;
unsigned lru:LRU_BITS; /* LRU time (relative to global lru_clock) or
* LFU data (least significant 8 bits frequency
* and most significant 16 bits access time). */
int refcount;
void *ptr;
} robj;

当这24 bits 用作LFU 时，其被分为两部分：
高16 位用来记录访问时间（单位为分钟，ldt，last decrement time）
低8 位用来记录访问频率，简称counter（logc，logistic counter）
counter 是用基于概率的对数计数器实现的，8 位可以表示百万次的访问频率。
对象被读写的时候，lfu 的值会被更新。
db.c——lookupKey

void updateLFU(robj *val) {
unsigned long counter = LFUDecrAndReturn(val);
counter = LFULogIncr(counter);
val->lru = (LFUGetTimeInMinutes()<<8) | counter;
}

增长的速率由，lfu-log-factor 越大，counter 增长的越慢
redis.conf 配置文件

# lfu-log-factor 10

如果计数器只会递增不会递减，也不能体现对象的热度。没有被访问的时候，计数器怎么递减呢？
减少的值由衰减因子lfu-decay-time（分钟）来控制，如果值是1 的话，N 分钟没有访问就要减少N。
redis.conf 配置文件

# lfu-decay-time 1

持久化机制

https://redis.io/topics/persistence
Redis 速度快，很大一部分原因是因为它所有的数据都存储在内存中。如果断电或者宕机，都会导致内存中的数据丢失。为了实现重启后数据不丢失，Redis 提供了两种持久化的方案，一种是RDB 快照（Redis DataBase），一种是AOF（Append Only File）。

RDB

RDB 是Redis 默认的持久化方案。当满足一定条件的时候，会把当前内存中的数据写入磁盘，生成一个快照文件dump.rdb。Redis 重启会通过加载dump.rdb 文件恢复数据。
什么时候写入rdb 文件？

• 自动触发
  a）配置规则触发。
  redis.conf， SNAPSHOTTING，其中定义了触发把数据保存到磁盘的触发频率。
  如果不需要RDB 方案，注释save 或者配置成空字符串""。

save 900 1 # 900 秒内至少有一个key 被修改（包括添加）
save 300 10 # 400 秒内至少有10 个key 被修改
save 60 10000 # 60 秒内至少有10000 个key 被修改

注意上面的配置是不冲突的，只要满足任意一个都会触发。
RDB 文件位置和目录：

# 文件路径，
dir ./
# 文件名称
dbfilename dump.rdb
# 是否是LZF 压缩rdb 文件
rdbcompression yes
# 开启数据校验
rdbchecksum yes

dir： rdb 文件默认在启动目录下（相对路径）config get dir 获取
dbfilename： 文件名称
rdbcompression： 开启压缩可以节省存储空间，但是会消耗一些CPU 的计算时间，默认开启
rdbchecksum： 使用CRC64 算法来进行数据校验，但是这样做会增加大约10%的性能消耗，如果希望获取到最大的性能提升，可以关闭此功能。

为什么停止Redis 服务的时候没有save，重启数据还在？
RDB 还有两种触发方式：
b）shutdown 触发，保证服务器正常关闭。
c）flushall，RDB 文件是空的，没什么意义（删掉dump.rdb 演示一下）。

• 手动触发
  如果我们需要重启服务或者迁移数据，这个时候就需要手动触RDB 快照保存。Redis提供了两条命令：
  a）save
  save 在生成快照的时候会阻塞当前Redis 服务器， Redis 不能处理其他命令。如果内存中的数据比较多，会造成Redis 长时间的阻塞。生产环境不建议使用这个命令。
  为了解决这个问题，Redis 提供了第二种方式。
  b）bgsave
  执行bgsave 时，Redis 会在后台异步进行快照操作，快照同时还可以响应客户端请求。
  具体操作是Redis 进程执行fork 操作创建子进程（copy-on-write），RDB 持久化过程由子进程负责，完成后自动结束。它不会记录fork 之后后续的命令。阻塞只发生在fork 阶段，一般时间很短。
  用lastsave 命令可以查看最近一次成功生成快照的时间。
• RDB 数据的恢复
  1、shutdown 持久化
  添加键值

redis> set k1 1
redis> set k2 2
redis> set k3 3
redis> set k4 4
redis> set k5 5

停服务器，触发save

redis> shutdown

备份dump.rdb 文件

cp dump.rdb dump.rdb.bak

启动服务器

/usr/local/soft/redis-5.0.5/src/redis-server /usr/local/soft/redis-5.0.5/redis.conf

数据都在：

redis> keys *

2、模拟数据丢失
模拟数据丢失，触发save

redis> flushall

停服务器

redis> shutdown

启动服务器

/usr/local/soft/redis-5.0.5/src/redis-server /usr/local/soft/redis-5.0.5/redis.conf

啥都没有：

redis> keys *

3、通过备份文件恢复数据
停服务器

redis> shutdown

重命名备份文件

mv dump.rdb.bak dump.rdb

启动服务器

/usr/local/soft/redis-5.0.5/src/redis-server /usr/local/soft/redis-5.0.5/redis.conf

查看数据：

redis> keys *

• RDB 文件的优势和劣势
  一、优势
  1.RDB 是一个非常紧凑(compact)的文件，它保存了redis 在某个时间点上的数据集。这种文件非常适合用于进行备份和灾难恢复。
  2.生成RDB 文件的时候，redis 主进程会fork()一个子进程来处理所有保存工作，主进程不需要进行任何磁盘IO 操作。
  3.RDB 在恢复大数据集时的速度比AOF 的恢复速度要快。
  二、劣势
  1、RDB 方式数据没办法做到实时持久化/秒级持久化。因为bgsave 每次运行都要执行fork 操作创建子进程，频繁执行成本过高。
  2、在一定间隔时间做一次备份，所以如果redis 意外down 掉的话，就会丢失最后一次快照之后的所有修改（数据有丢失）。
  如果数据相对来说比较重要，希望将损失降到最小，则可以使用AOF 方式进行持久化。

AOF

Append Only File
AOF：Redis 默认不开启。AOF 采用日志的形式来记录每个写操作，并追加到文件中。开启后，执行更改Redis 数据的命令时，就会把命令写入到AOF 文件中。
Redis 重启时会根据日志文件的内容把写指令从前到后执行一次以完成数据的恢复工作。

• AOF 配置
  配置文件redis.conf

# 开关
appendonly no
# 文件名
appendfilename "appendonly.aof"

appendonly： Redis 默认只开启RDB 持久化，开启AOF 需要修改为yes
appendfilename： "appendonly.aof" 路径也是通过dir 参数配置config get dir

由于操作系统的缓存机制，AOF 数据并没有真正地写入硬盘，而是进入了系统的硬盘缓存。什么时候把缓冲区的内容写入到AOF 文件？
appendfsync everysec
AOF 持久化策略（硬盘缓存到磁盘），默认everysec
no 表示不执行fsync，由操作系统保证数据同步到磁盘，速度最快，但是不太安全；
always 表示每次写入都执行fsync，以保证数据同步到磁盘，效率很低；
everysec 表示每秒执行一次fsync，可能会导致丢失这1s 数据。通常选择everysec ，兼顾安全性和效率。

文件越来越大，怎么办？
由于AOF 持久化是Redis 不断将写命令记录到AOF 文件中，随着Redis 不断的进行，AOF 的文件会越来越大，文件越大，占用服务器内存越大以及AOF 恢复要求时间越长。
例如set wei 666，执行1000 次，结果都是wei=666。
为了解决这个问题，Redis 新增了重写机制，当AOF 文件的大小超过所设定的阈值时，Redis 就会启动AOF 文件的内容压缩，只保留可以恢复数据的最小指令集。
可以使用命令bgrewriteaof 来重写。
AOF 文件重写并不是对原文件进行重新整理，而是直接读取服务器现有的键值对，然后用一条命令去代替之前记录这个键值对的多条命令，生成一个新的文件后去替换原来的AOF 文件。

# 重写触发机制
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb

aof-rewrite-percentage
默认值为100。aof 自动重写配置，当目前aof 文件大小超过上一次重写的aof 文件大小的百分之多少进行重写，即当aof 文件增长到一定大小的时候，Redis 能够调用bgrewriteaof对日志文件进行重写。当前AOF 文件大小是上次日志重写得到AOF 文件大小的二倍（设置为100）时，自动启动新的日志重写过程。

auto-aof-rewrite-min-size
默认64M。设置允许重写的最小aof 文件大小，避免了达到约定百分比但尺寸仍然很小的情况还要重写。

重写过程中，AOF 文件被更改了怎么办？

image.png

另外有两个与AOF 相关的参数：
no-appendfsync-on-rewrite
在aof 重写或者写入rdb 文件的时候，会执行大量IO，此时对于everysec 和always 的aof模式来说，执行fsync 会造成阻塞过长时间，no-appendfsync-on-rewrite 字段设置为默认设置为no。如果对延迟要求很高的应用，这个字段可以设置为yes，否则还是设置为no，这样对持久化特性来说这是更安全的选择。设置为yes 表示rewrite 期间对新写操作不fsync,暂时存在内存中,等rewrite 完成后再写入，默认为no，建议修改为yes。Linux 的默认fsync策略是30 秒。可能丢失30 秒数据。

aof-load-truncated aof
文件可能在尾部是不完整的，当redis 启动的时候，aof 文件的数据被载入内存。重启可能发生在redis 所在的主机操作系统宕机后，尤其在ext4 文件系统没有加上data=ordered选项，出现这种现象。redis 宕机或者异常终止不会造成尾部不完整现象，可以选择让redis退出，或者导入尽可能多的数据。如果选择的是yes，当截断的aof 文件被导入的时候，会自动发布一个log 给客户端然后load。如果是no，用户必须手动redis-check-aof 修复AOF文件才可以。默认值为yes。

• AOF 数据恢复
  重启Redis 之后就会进行AOF 文件的恢复。

• AOF 优势与劣势
  优点：
  1、AOF 持久化的方法提供了多种的同步频率，即使使用默认的同步频率每秒同步一次，Redis 最多也就丢失1 秒的数据而已。
  缺点：
  1、对于具有相同数据的的Redis，AOF 文件通常会比RDF 文件体积更大（RDB存的是数据快照）。
  2、虽然AOF 提供了多种同步的频率，默认情况下，每秒同步一次的频率也具有较高的性能。在高并发的情况下，RDB 比AOF 具好更好的性能保证。

两种方案比较

那么对于AOF 和RDB 两种持久化方式，我们应该如何选择呢？

如果可以忍受一小段时间内数据的丢失，毫无疑问使用RDB 是最好的，定时生成RDB 快照（snapshot）非常便于进行数据库备份， 并且RDB 恢复数据集的速度也要比AOF 恢复的速度要快。
否则就使用AOF 重写。但是一般情况下建议不要单独使用某一种持久化机制，而是应该两种一起用，在这种情况下,当redis 重启的时候会优先载入AOF 文件来恢复原始的数据，因为在通常情况下AOF 文件保存的数据集要比RDB 文件保存的数据集要完整。

——学自咕泡学院