Redis从基础到进阶篇（三）----架构原理与集群演变

目录

一、缓存淘汰策略

1.1 LRU原理

1.2 案例分析

1.3 Redis缓存淘汰策略

1.3.1 设置最⼤缓存

1.3.2 淘汰策略

二、Redis事务

2.1 Redis事务典型应⽤—Redis乐观锁

2.2 Redis事务介绍

2.3 事务命令

2.3.1 MULTI

2.3.2 EXEC

2.3.3 DISCARD

2.3.4 WATCH

2.3.5 UNWATCH

2.4 事务演示

2.5 事务失败处理

2.6 Redis乐观锁

2.7 Redis乐观锁实现秒杀

三、Redis持久化

3.1 RDB⽅式（默认）

3.1.1 触发快照的时机

3.1.2 设置快照规则

3.1.3 原理图

3.2 AOF⽅式

3.2.1 AOF介绍

3.2.2 同步磁盘数据

3.2.3 AOF重写原理（优化AOF⽂件）

3.2.4 AOF⽂件损坏以后如何修复

3.3 如何选择RDB和AOF

3.4 如何选择RDB和AOF（4.0之前的还需要考虑）

3.5 混合持久化⽅式

四、Redis主从复制

4.1 什么是主从复制

4.2 主从配置

4.2.1 主Redis配置

4.2.2 从Redis配置

4.2.3 实现原理

4.2.4 全量同步

4.2.5 增量同步

五、Redis哨兵机制

5.1 简介

5.2 哨兵进程的作用

5.3 故障判定原理分析

5.4 ⾃动故障迁移

5.5 案例演示

六、Redis集群

6.1 Redis的集群策略

6.2 Redis-cluster架构图

6.3 Redis-cluster投票:容错

6.4 安装RedisCluster

6.5 命令客户端连接集群

6.6 查看集群的命令

6.7 维护节点

6.7.1 添加主节点

6.7.2 hash槽重新分配（数据迁移）

6.7.3 添加从节点

6.7.4 删除结点

6.8 Jedis连接集群

6.8.1 代码实现

6.8.2 使⽤spring

---

一、缓存淘汰策略

1.1 LRU原理

LRU （ Least recently used ，最近最少使⽤）算法根据数据的历史访问记录来进⾏淘汰数据，其核⼼思 想是“ 如果数据最近被访问过，那么将来被访问的⼏率也更⾼ ” 。

最常⻅的实现是使⽤⼀个链表保存缓存数据，详细算法实现如下：

                     

1. 新数据插⼊到链表头部；

2. 每当缓存命中（即缓存数据被访问），则将数据移到链表头部；

3. 当链表满的时候，将链表尾部的数据丢弃。

在Java中可以使⽤LinkHashMap去实现LRU

利⽤哈希链表实现

1.2 案例分析

让我们以⽤户信息的需求为例，来演示⼀下LRU算法的基本思路：

(1) 假设我们使⽤哈希链表来缓存⽤户信息，⽬前缓存了4个⽤户，这4个⽤户是按照时间顺序依次从链表右端插⼊的。

(2) 此时，业务⽅访问⽤户5，由于哈希链表中没有⽤户5的数据，我们从数据库中读取出来，插⼊到缓存当中。这时候，链表中最右端是最新访问到的⽤户5，最左端是最近最少访问的⽤户1。

(3) 接下来，业务⽅访问⽤户2，哈希链表中存在⽤户2的数据，我们怎么做呢？我们把⽤户2从它的前驱节 点和后继节点之间移除，重新插⼊到链表最右端。这时候，链表中最右端变成了最新访问到的⽤户2，最左端仍然是最近最少访问的⽤户1

(4) 接下来，业务⽅请求修改⽤户4的信息。同样道理，我们把⽤户4从原来的位置移动到链表最右侧，并把⽤户信息的值更新。这时候，链表中最右端是最新访问到的⽤户4，最左端仍然是最近最少访问的⽤户1

(5) 后来业务⽅换⼝味了，访问⽤户6，⽤户6在缓存⾥没有，需要插⼊到哈希链表。假设这时候缓存容量已经达到上限，必须先删除最近最少访问的数据，那么位于哈希链表最左端的⽤户1就会被删除掉，然后再把⽤户6插⼊到最右端。

以上，就是 LRU 算法的基本思路。

1.3 Redis缓存淘汰策略

1.3.1 设置最⼤缓存

在 redis 中，允许⽤户设置最⼤使⽤内存⼤⼩ maxmemory ，默认为 0 ，没有指定最⼤缓存，如果 有新的数据添加，超过最⼤内存，则会使redis 崩溃，所以⼀定要设置。

redis 内存数据集⼤⼩上升到⼀定⼤⼩的时候，就会实⾏数据淘汰策略。

1.3.2 淘汰策略

redis 淘汰策略配置： maxmemory-policy voltile-lru ，⽀持热配置

redis 提供 6 种数据淘汰策略：

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

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

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

4. allkeys-lru ：从数据集（ server.db[i].dict ）中挑选最近最少使⽤的数据淘汰

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

6. no-enviction （驱逐）：禁⽌驱逐数据

二、Redis事务

2.1 Redis事务典型应⽤—Redis乐观锁

在⽣产环境⾥，经常会利⽤ redis 乐观锁来实现秒杀， Redis 乐观锁是 Redis 事务的经典应⽤。

秒杀场景描述 :

秒杀活动对稀缺或者特价的商品进⾏定时，定量售卖，吸引成⼤量的消费者进⾏抢购，但⼜只有少部分 消费者可以下单成功。因此，秒杀活动将在较短时间内产⽣⽐平时⼤数⼗倍，上百倍的⻚⾯访问流量和 下单请求流量。

由于秒杀只有少部分请求能够成功，⽽⼤量的请求是并发产⽣的，所以如何确定哪个请求成功了，就是 由redis 乐观锁来实现。具体思路如下：

监控 锁定量，如果该值被修改成功则表示该请求被通过，反之表示该请求未通过。

从监控到修改到执⾏都需要在 redis ⾥操作，这样就需要⽤到 Redis 事务。

2.2 Redis事务介绍

Redis 的事务是通过 MULTI 、 EXEC 、 DISCARD 和 WATCH 这四个命令来完成的。

Redis 的单个命令都是原⼦性的，所以这⾥需要确保事务性的对象是 命令集合 。

Redis 将命令集合序列化并确保处于同⼀事务的 命令集合连续且不被打断 的执⾏

Redis 不⽀持回滚操作。

2.3 事务命令

2.3.1 MULTI

⽤于标记事务块的开始。

Redis 会将后续的命令逐个放⼊队列中，然后使⽤ EXEC 命令原⼦化地执⾏这个命令序列。

语法：

multi

2.3.2 EXEC

在⼀个事务中执⾏所有先前放⼊队列的命令，然后恢复正常的连接状态

语法：

exec

2.3.3 DISCARD

清除所有先前在⼀个事务中放⼊队列的命令，然后恢复正常的连接状态。

语法：

discard

2.3.4 WATCH

当某个 [ 事务需要按条件执⾏ ] 时，就要使⽤这个命令将给定的 [ 键设置为受监控 ] 的状态。

语法：

watch key [key…]

注意事项： 使⽤该命令可以实现 Redis 的 乐观锁 。（后⾯实现）

2.3.5 UNWATCH

清除所有先前为⼀个事务监控的键。

语法：

unwatch

2.4 事务演示

127.0.0.1:6379> multi
OK
127.0.0.1:6379> set s1 111
QUEUED
127.0.0.1:6379> hset set1 name zhangsan
QUEUED
127.0.0.1:6379> exec
1) OK
2) (integer) 1
127.0.0.1:6379> multi
OK
127.0.0.1:6379> set s2 222
QUEUED
127.0.0.1:6379> hset set2 age 20
QUEUED
127.0.0.1:6379> discard
OK
127.0.0.1:6379> exec
(error) ERR EXEC without MULTI
127.0.0.1:6379> watch s1 
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> set s1 555
QUEUED
127.0.0.1:6379> exec # 此时在没有exec之前，通过另⼀个命令窗⼝对监控的s1字段进⾏修改
(nil)
127.0.0.1:6379> get s1
111

2.5 事务失败处理

（1 ）Redis 语法错误

整个事务的命令在队列⾥都清除

（2）Redis 运⾏错误

在队列⾥正确的命令可以执⾏ （弱事务性）

弱事务性 ：

1 、在队列⾥正确的命令可以执⾏ （⾮原⼦操作）

2 、不⽀持回滚

（3） Redis 不⽀持事务回滚（为什么呢）

1 、⼤多数事务失败是因为 语法错误或者类型错误 ，这两种错误，在开发阶段都是可以预⻅的

2 、 Redis 为了 性能⽅⾯ 就忽略了事务回滚。 （回滚记录历史版本）

2.6 Redis乐观锁

乐观锁基于 CAS （ Compare And Swap ）思想（⽐较并替换），是不具有互斥性，不会产⽣锁等待⽽消 耗资源，但是需要反复的重试，但也是因为重试的机制，能⽐较快的响应。因此我们可以利⽤redis 来实 现乐观锁。具体思路如下：

1 、利⽤ redis 的 watch 功能，监控这个 redisKey 的状态值

2 、获取 redisKey 的值

3 、创建 redis 事务

4 、给这个 key 的值 +1

5 、然后去执⾏这个事务，如果 key 的值被修改过则回滚， key 不加 1

public void watch() {
     try {
         String watchKeys = "watchKeys";
         //初始值 value=1
         jedis.set(watchKeys, 1);
         //监听key为watchKeys的值
         jedis.watch(watchkeys);
         //开启事务
         Transaction tx = jedis.multi();
         //watchKeys⾃增加⼀
         tx.incr(watchKeys);
         //执⾏事务，如果其他线程对watchKeys中的value进⾏修改，则该事务将不会执⾏
         //通过redis事务以及watch命令实现乐观锁
         List