redis备忘录

时间 2019-11-19

原文原文链接

Redis 是一个基于内存的高性能key-value数据库。
Redis本质上是一个Key-Value类型的内存数据库，很像memcached，整个数据库通通加载在内存当中进行操做，按期经过异步操做把数据库数据flush到硬盘上进行保存。由于是纯内存操做，Redis的性能很是出色，每秒能够处理超过 10万次读写操做，是已知性能最快的Key-Value DB。
Redis的出色之处不只仅是性能，Redis最大的魅力是支持保存多种数据结构，此外单个value的最大限制是1GB，不像 memcached只能保存1MB的数据，所以Redis能够用来实现不少有用的功能，比方说用他的List来作FIFO双向链表，实现一个轻量级的高性能消息队列服务，用他的Set能够作高性能的tag系统等等。另外Redis也能够对存入的Key-Value设置expire时间，所以也能够被看成一个功能增强版的memcached来用。
Redis的主要缺点是数据库容量受到物理内存的限制，不能用做海量数据的高性能读写，所以Redis适合的场景主要局限在较小数据量的高性能操做和运算上。node

Redis经过Key-Value的单值不一样类型来区分, 如下是支持的类型:
Strings
Lists
Sets 求交集、并集
Sorted Set
hashesredis

Redis是单进程单线程的
redis利用队列技术将并发访问变为串行访问，消除了传统数据库串行控制的开销算法

redis支持主从的模式。原则：Master会将数据同步到slave，而slave不会将数据同步到master。Slave启动时会链接master来同步数据。
这是一个典型的分布式读写分离模型。咱们能够利用master来插入数据，slave提供检索服务。这样能够有效减小单个机器的并发访问数量数据库

使用Redis有哪些好处？后端

(1) 速度快，由于数据存在内存中，相似于HashMap，HashMap的优点就是查找和操做的时间复杂度都是O(1)缓存

(2) 支持丰富数据类型，支持string，list，set，sorted set，hash安全

(3) 支持事务，操做都是原子性，所谓的原子性就是对数据的更改要么所有执行，要么所有不执行服务器

(4) 丰富的特性：可用于缓存，消息，按key设置过时时间，过时后将会自动删除网络

redis相比memcached有哪些优点？session

(1) memcached全部的值均是简单的字符串，redis做为其替代者，支持更为丰富的数据类型

(2) redis的速度比memcached快不少

(3) redis能够持久化其数据

redis常见性能问题和解决方案：

(1) Master最好不要作任何持久化工做，如RDB内存快照和AOF日志文件

(2) 若是数据比较重要，某个Slave开启AOF备份数据，策略设置为每秒同步一次

(3) 为了主从复制的速度和链接的稳定性，Master和Slave最好在同一个局域网内

(4) 尽可能避免在压力很大的主库上增长从库

(5) 主从复制不要用图状结构，用单向链表结构更为稳定，即：Master <- Slave1 <- Slave2 <- Slave3...

这样的结构方便解决单点故障问题，实现Slave对Master的替换。若是Master挂了，能够马上启用Slave1作Master，其余不变。

MySQL里有2000w数据，redis中只存20w的数据，如何保证redis中的数据都是热点数据

相关知识：redis 内存数据集大小上升到必定大小的时候，就会施行数据淘汰策略。redis 提供 6种数据淘汰策略：

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

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

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

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

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

no-enviction（驱逐）：禁止驱逐数据

Memcache与Redis的区别都有哪些？

1)、存储方式

Memecache把数据所有存在内存之中，断电后会挂掉，数据不能超过内存大小。

Redis有部份存在硬盘上，这样能保证数据的持久性。

2)、数据支持类型

Memcache对数据类型支持相对简单。

Redis有复杂的数据类型。

3)、使用底层模型不一样

它们之间底层实现方式以及与客户端之间通讯的应用协议不同。

Redis直接本身构建了VM 机制，由于通常的系统调用系统函数的话，会浪费必定的时间去移动和请求。

4），value大小

redis最大能够达到1GB，而memcache只有1MB

redis 最适合的场景

Redis最适合全部数据in-momory的场景，虽然Redis也提供持久化功能，但实际更多的是一个disk-backed的功能，跟传统意义上的持久化有比较大的差异，那么可能你们就会有疑问，彷佛Redis更像一个增强版的Memcached，那么什么时候使用Memcached,什么时候使用Redis呢?

若是简单地比较Redis与Memcached的区别，大多数都会获得如下观点：

1 、Redis不只仅支持简单的k/v类型的数据，同时还提供list，set，zset，hash等数据结构的存储。
2 、Redis支持数据的备份，即master-slave模式的数据备份。
3 、Redis支持数据的持久化，能够将内存中的数据保持在磁盘中，重启的时候能够再次加载进行使用。

（1）、会话缓存（Session Cache）

最经常使用的一种使用Redis的情景是会话缓存（session cache）。用Redis缓存会话比其余存储（如Memcached）的优点在于：Redis提供持久化。当维护一个不是严格要求一致性的缓存时，若是用户的购物车信息所有丢失，大部分人都会不高兴的，如今，他们还会这样吗？

幸运的是，随着 Redis 这些年的改进，很容易找到怎么恰当的使用Redis来缓存会话的文档。甚至广为人知的商业平台Magento也提供Redis的插件。

（2）、全页缓存（FPC）

除基本的会话token以外，Redis还提供很简便的FPC平台。回到一致性问题，即便重启了Redis实例，由于有磁盘的持久化，用户也不会看到页面加载速度的降低，这是一个极大改进，相似PHP本地FPC。

再次以Magento为例，Magento提供一个插件来使用Redis做为全页缓存后端。

此外，对WordPress的用户来讲，Pantheon有一个很是好的插件 wp-redis，这个插件能帮助你以最快速度加载你曾浏览过的页面。

（3）、队列

Reids在内存存储引擎领域的一大优势是提供 list 和 set 操做，这使得Redis能做为一个很好的消息队列平台来使用。Redis做为队列使用的操做，就相似于本地程序语言（如Python）对 list 的 push/pop 操做。

若是你快速的在Google中搜索“Redis queues”，你立刻就能找到大量的开源项目，这些项目的目的就是利用Redis建立很是好的后端工具，以知足各类队列需求。例如，Celery有一个后台就是使用Redis做为broker，你能够从这里去查看。

（4），排行榜/计数器

Redis在内存中对数字进行递增或递减的操做实现的很是好。集合（Set）和有序集合（Sorted Set）也使得咱们在执行这些操做的时候变的很是简单，Redis只是正好提供了这两种数据结构。因此，咱们要从排序集合中获取到排名最靠前的10个用户–咱们称之为“user_scores”，咱们只须要像下面同样执行便可：

固然，这是假定你是根据你用户的分数作递增的排序。若是你想返回用户及用户的分数，你须要这样执行：

ZRANGE user_scores 0 10 WITHSCORES

Agora Games就是一个很好的例子，用Ruby实现的，它的排行榜就是使用Redis来存储数据的，你能够在这里看到。

（5）、发布/订阅

最后（但确定不是最不重要的）是Redis的发布/订阅功能。发布/订阅的使用场景确实很是多。我已看见人们在社交网络链接中使用，还可做为基于发布/订阅的脚本触发器，甚至用Redis的发布/订阅功能来创建聊天系统！（不，这是真的，你能够去核实）。

Redis提供的全部特性中，我感受这个是喜欢的人最少的一个，虽然它为用户提供若是此多功能。

Redis 提供了多种不一样级别的持久化方式：
RDB 持久化能够在指定的时间间隔内生成数据集的时间点快照（point-in-time snapshot）。
AOF 持久化记录服务器执行的全部写操做命令，并在服务器启动时，经过从新执行这些命令来还原数据集。 AOF 文件中的命令所有以 Redis 协议的格式来保存，新命令会被追加到文件的末尾。 Redis 还能够在后台对 AOF 文件进行重写（rewrite），使得 AOF 文件的体积不会超出保存数据集状态所需的实际大小。
Redis 还能够同时使用 AOF 持久化和 RDB 持久化。在这种状况下，当 Redis 重启时，它会优先使用 AOF 文件来还原数据集，由于 AOF 文件保存的数据集一般比 RDB 文件所保存的数据集更完整。
你甚至能够关闭持久化功能，让数据只在服务器运行时存在。

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 文件的体积。
根据所使用的 fsync 策略，AOF 的速度可能会慢于 RDB 。在通常状况下，每秒 fsync 的性能依然很是高，而关闭 fsync 可让 AOF 的速度和 RDB 同样快，即便在高负荷之下也是如此。不过在处理巨大的写入载入时，RDB 能够提供更有保证的最大延迟时间（latency）。
AOF 在过去曾经发生过这样的 bug ：由于个别命令的缘由，致使 AOF 文件在从新载入时，没法将数据集恢复成保存时的原样。（举个例子，阻塞命令 BRPOPLPUSH 就曾经引发过这样的 bug 。）测试套件里为这种状况添加了测试：它们会自动生成随机的、复杂的数据集，并经过从新载入这些数据来确保一切正常。虽然这种 bug 在 AOF 文件中并不常见，可是对比来讲， RDB 几乎是不可能出现这种 bug 的。

RDB 和 AOF ，我应该用哪个？
通常来讲，若是想达到足以媲美 PostgreSQL 的数据安全性，你应该同时使用两种持久化功能。

若是你很是关心你的数据，但仍然能够承受数分钟之内的数据丢失，那么你能够只使用 RDB 持久化。

有不少用户都只使用 AOF 持久化，但咱们并不推荐这种方式：由于定时生成 RDB 快照（snapshot）很是便于进行数据库备份，而且 RDB 恢复数据集的速度也要比 AOF 恢复的速度要快，除此以外，使用 RDB 还能够避免以前提到的 AOF 程序的 bug 。

RDB 快照
在默认状况下， Redis 将数据库快照保存在名字为 dump.rdb 的二进制文件中。

你能够对 Redis 进行设置，让它在“ N 秒内数据集至少有 M 个改动”这一条件被知足时，自动保存一次数据集。

你也能够经过调用 SAVE 或者 BGSAVE ，手动让 Redis 进行数据集保存操做。

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

save 60 1000
这种持久化方式被称为快照（snapshot）。
快照的运做方式
当 Redis 须要保存 dump.rdb 文件时，服务器执行如下操做：

Redis 调用 fork() ，同时拥有父进程和子进程。
子进程将数据集写入到一个临时 RDB 文件中。
当子进程完成对新 RDB 文件的写入时，Redis 用新 RDB 文件替换原来的 RDB 文件，并删除旧的 RDB 文件。
这种工做方式使得 Redis 能够从写时复制（copy-on-write）机制中获益。

只进行追加操做的文件（append-only file，AOF）
快照功能并非很是耐久（durable）：若是 Redis 由于某些缘由而形成故障停机，那么服务器将丢失最近写入、且仍未保存到快照中的那些数据。

尽管对于某些程序来讲，数据的耐久性并非最重要的考虑因素，可是对于那些追求彻底耐久能力（full durability）的程序来讲，快照功能就不太适用了。

从 1.1 版本开始， Redis 增长了一种彻底耐久的持久化方式： AOF 持久化。

你能够经过修改配置文件来打开 AOF 功能：

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

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

AOF 重写
由于 AOF 的运做方式是不断地将命令追加到文件的末尾，因此随着写入命令的不断增长， AOF 文件的体积也会变得愈来愈大。

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

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

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

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

Redis 2.2 须要本身手动执行 BGREWRITEAOF 命令； Redis 2.4 则能够自动触发 AOF 重写，具体信息请查看 2.4 的示例配置文件。

AOF 有多耐久？
你能够配置 Redis 多久才将数据 fsync 到磁盘一次。

有三个选项：

每次有新命令追加到 AOF 文件时就执行一次 fsync ：很是慢，也很是安全。
每秒 fsync 一次：足够快（和使用 RDB 持久化差很少），而且在故障时只会丢失 1 秒钟的数据。
从不 fsync ：将数据交给操做系统来处理。更快，也更不安全的选择。
推荐（而且也是默认）的措施为每秒 fsync 一次，这种 fsync 策略能够兼顾速度和安全性。

老是 fsync 的策略在实际使用中很是慢，即便在 Redis 2.0 对相关的程序进行了改进以后还是如此 —— 频繁调用 fsync 注定了这种策略不可能快得起来。

若是 AOF 文件出错了，怎么办？
服务器可能在程序正在对 AOF 文件进行写入时停机，若是停机形成了 AOF 文件出错（corrupt），那么 Redis 在重启时会拒绝载入这个 AOF 文件，从而确保数据的一致性不会被破坏。

当发生这种状况时，能够用如下方法来修复出错的 AOF 文件：

为现有的 AOF 文件建立一个备份。
使用 Redis 附带的 redis-check-aof 程序，对原来的 AOF 文件进行修复。
$ redis-check-aof --fix
（可选）使用 diff -u 对比修复后的 AOF 文件和原始 AOF 文件的备份，查看两个文件之间的不一样之处。
重启 Redis 服务器，等待服务器载入修复后的 AOF 文件，并进行数据恢复。

AOF 的运做方式
AOF 重写和 RDB 建立快照同样，都巧妙地利用了写时复制机制。

如下是 AOF 重写的执行步骤：

Redis 执行 fork() ，如今同时拥有父进程和子进程。
子进程开始将新 AOF 文件的内容写入到临时文件。
对于全部新执行的写入命令，父进程一边将它们累积到一个内存缓存中，一边将这些改动追加到现有 AOF 文件的末尾：这样即便在重写的中途发生停机，现有的 AOF 文件也仍是安全的。
当子进程完成重写工做时，它给父进程发送一个信号，父进程在接收到信号以后，将内存缓存中的全部数据追加到新 AOF 文件的末尾。
搞定！如今 Redis 原子地用新文件替换旧文件，以后全部命令都会直接追加到新 AOF 文件的末尾。

怎么从 RDB 持久化切换到 AOF 持久化
在 Redis 2.2 或以上版本，能够在不重启的状况下，从 RDB 切换到 AOF ：

为最新的 dump.rdb 文件建立一个备份。
将备份放到一个安全的地方。
执行如下两条命令：
redis-cli> CONFIG SET appendonly yes

redis-cli> CONFIG SET save ""
确保命令执行以后，数据库的键的数量没有改变。
确保写命令会被正确地追加到 AOF 文件的末尾。
步骤 3 执行的第一条命令开启了 AOF 功能： Redis 会阻塞直到初始 AOF 文件建立完成为止，以后 Redis 会继续处理命令请求，并开始将写入命令追加到 AOF 文件末尾。

步骤 3 执行的第二条命令用于关闭 RDB 功能。这一步是可选的，若是你愿意的话，也能够同时使用 RDB 和 AOF 这两种持久化功能。

别忘了在 redis.conf 中打开 AOF 功能！不然的话，服务器重启以后，以前经过 CONFIG SET 设置的配置就会被遗忘，程序会按原来的配置来启动服务器。

RDB 和 AOF 之间的相互做用
在版本号大于等于 2.4 的 Redis 中， BGSAVE 执行的过程当中，不能够执行 BGREWRITEAOF 。反过来讲，在 BGREWRITEAOF 执行的过程当中，也不能够执行 BGSAVE 。

这能够防止两个 Redis 后台进程同时对磁盘进行大量的 I/O 操做。

若是 BGSAVE 正在执行，而且用户显示地调用 BGREWRITEAOF 命令，那么服务器将向用户回复一个 OK 状态，并告知用户， BGREWRITEAOF 已经被预约执行：一旦 BGSAVE 执行完毕， BGREWRITEAOF 就会正式开始。

当 Redis 启动时，若是 RDB 持久化和 AOF 持久化都被打开了，那么程序会优先使用 AOF 文件来恢复数据集，由于 AOF 文件所保存的数据一般是最完整的。

备份 Redis 数据
在阅读这个小节前，先将下面这句话铭记于心：必定要备份你的数据库！

磁盘故障，节点失效，诸如此类的问题均可能让你的数据消失不见，不进行备份是很是危险的。

Redis 对于数据备份是很是友好的，由于你能够在服务器运行的时候对 RDB 文件进行复制： RDB 文件一旦被建立，就不会进行任何修改。当服务器要建立一个新的 RDB 文件时，它先将文件的内容保存在一个临时文件里面，当临时文件写入完毕时，程序才使用 rename(2) 原子地用临时文件替换原来的 RDB 文件。

这也就是说，不管什么时候，复制 RDB 文件都是绝对安全的。

如下是咱们的建议：

建立一个按期任务（cron job），每小时将一个 RDB 文件备份到一个文件夹，而且天天将一个 RDB 文件备份到另外一个文件夹。
确保快照的备份都带有相应的日期和时间信息，每次执行按期任务脚本时，使用 find 命令来删除过时的快照：好比说，你能够保留最近 48 小时内的每小时快照，还能够保留最近一两个月的每日快照。
至少天天一次，将 RDB 备份到你的数据中心以外，或者至少是备份到你运行 Redis 服务器的物理机器以外。

redis主从复制
1、Redis的Replication：

这里首先须要说明的是，在Redis中配置Master-Slave模式真是太简单了。相信在阅读完这篇Blog以后你也能够轻松作到。这里咱们仍是先列出一些理论性的知识，后面给出实际操做的案例。
下面的列表清楚的解释了Redis Replication的特色和优点。
1). 同一个Master能够同步多个Slaves。
2). Slave一样能够接受其它Slaves的链接和同步请求，这样能够有效的分载Master的同步压力。所以咱们能够将Redis的Replication架构视为图结构。
3). Master Server是以非阻塞的方式为Slaves提供服务。因此在Master-Slave同步期间，客户端仍然能够提交查询或修改请求。
4). Slave Server一样是以非阻塞的方式完成数据同步。在同步期间，若是有客户端提交查询请求，Redis则返回同步以前的数据。
5). 为了分载Master的读操做压力，Slave服务器能够为客户端提供只读操做的服务，写服务仍然必须由Master来完成。即使如此，系统的伸缩性仍是获得了很大的提升。
6). Master能够将数据保存操做交给Slaves完成，从而避免了在Master中要有独立的进程来完成此操做。

2、Replication的工做原理：

在Slave启动并链接到Master以后，它将主动发送一个SYNC命令。此后Master将启动后台存盘进程，同时收集全部接收到的用于修改数据集的命令，在后台进程执行完毕后，Master将传送整个数据库文件到Slave，以完成一次彻底同步。而Slave服务器在接收到数据库文件数据以后将其存盘并加载到内存中。此后，Master继续将全部已经收集到的修改命令，和新的修改命令依次传送给Slaves，Slave将在本次执行这些数据修改命令，从而达到最终的数据同步。
若是Master和Slave之间的连接出现断连现象，Slave能够自动重连Master，可是在链接成功以后，一次彻底同步将被自动执行。

3、如何配置Replication：

见以下步骤：
1). 同时启动两个Redis服务器，能够考虑在同一台机器上启动两个Redis服务器，分别监听不一样的端口，如6379和6380。
2). 在Slave服务器上执行一下命令：
/> redis-cli -p 6380 #这里咱们假设Slave的端口号是6380
redis 127.0.0.1:6380> slaveof 127.0.0.1 6379 #咱们假设Master和Slave在同一台主机，Master的端口为6379
OK
上面的方式只是保证了在执行slaveof命令以后，redis_6380成为了redis_6379的slave，一旦服务(redis_6380)从新启动以后，他们之间的复制关系将终止。
若是但愿长期保证这两个服务器之间的Replication关系，能够在redis_6380的配置文件中作以下修改：
/> cd /etc/redis #切换Redis服务器配置文件所在的目录。
/> ls
6379.conf 6380.conf
/> vi 6380.conf
将
# slaveof <masterip> <masterport>
改成
slaveof 127.0.0.1 6379
保存退出。
这样就能够保证Redis_6380服务程序在每次启动后都会主动创建与Redis_6379的Replication链接了。

4、应用示例：

这里咱们假设Master-Slave已经创建。
#启动master服务器。
[root@Stephen-PC redis]# redis-cli -p 6379
redis 127.0.0.1:6379>
#状况Master当前数据库中的全部Keys。
redis 127.0.0.1:6379> flushdb
OK
#在Master中建立新的Keys做为测试数据。
redis 127.0.0.1:6379> set mykey hello
OK
redis 127.0.0.1:6379> set mykey2 world
OK
#查看Master中存在哪些Keys。
redis 127.0.0.1:6379> keys *
1) "mykey"
2) "mykey2"

#启动slave服务器。
[root@Stephen-PC redis]# redis-cli -p 6380
#查看Slave中的Keys是否和Master中一致，从结果看，他们是相等的。
redis 127.0.0.1:6380> keys *
1) "mykey"
2) "mykey2"

#在Master中删除其中一个测试Key，并查看删除后的结果。
redis 127.0.0.1:6379> del mykey2
(integer) 1
redis 127.0.0.1:6379> keys *
1) "mykey"

#在Slave中查看是否mykey2也已经在Slave中被删除。
redis 127.0.0.1:6380> keys *
1) "mykey"

纯内存存储/IO多路复用技术/单线程架构是造就Redis高性能的三个因素。
因为Redis的单线程架构，因此须要每一个命令能被快速执行完，不然会存在阻塞Redis的可能。批量操做（mget,mset,hmset)可以有效提升命令执行的效率，但要注意每次批量操做的个数和字节数。
了解每一个名流的时间复杂度在开发中相当重要，例如在使用keys/hgetall,smembers/zrange等时间复杂度较高的命令时，须要考虑数据规模对于Redis的影响。
migrate命令用原子性的方式实现了dump+restore,而且支持批量操做，是Redis Cluster实现水平扩容的重要工具。
scan命令能够解决keys命令可能带来的阻塞问题，同时Redis还提供了hscan,sscan,zscan渐进式遍历hash,set,zset.
scan采用渐进式遍历的方式解决keys命令带来的阻塞问题。

Redis集群架构
蓝色的为Redis集群中的每一个node节点，节点之间经过ping 命令，测试相互是否链接正常，普通集群没有主从区分，链接任何一个节点操做，均可以转发到其余任意一个节点。
一、Redis 容错机制
每Redis提供了节点之间相互发送的ping命令，用于测试每一个节点的健康状态，集群中链接正常的节点接收到其余节点发送的ping命令时，会返回一个pong字符串。
Redis投票机制：若是一个节点A给B发送ping没有获得pong返回，那么A就会通知其余节点再次给B发送ping，若是集群中超过一半的节点给B发送ping都没有获得返回，那么B就被坐实game over了，因此为了不单点故障，通常都会为Redis的每一个节点提供一个备份节点，B节点挂掉了立马启动B的备份节点服务器。

Redis 集群存储原理每一个节点上的数据都不同，（同样就是主备了）把数据都分散存放到各个节点上进行存储。如何肯定哪些类型数据存入哪一个节点呢？Redis中槽slot就用于圈定当前节点的存储范围，分散存储使用hash算法，肯定什么值放到哪一个槽里。因此在建立Redis集群时，会首先为每一个节点建立槽容量，例如从1~2000，指定数据存储区域。