redis注册服务 redis注册为服务

redis能解决什么问题

redis是内存数据库，访问速度非常快，所以能够解决的也都是些缓存类型的问题，如下：

redis注册服务 redis注册为服务

redis注册服务 redis注册为服务

1、会话缓存（Session Cache）

2、全页缓存（FPC）

3、队列

4、排行榜/计数器

5AOF的劣势有哪些呢？、发布/RESP 是二进制安全的，不需要处理从一个进程传输到另一个进程的批量数据，因为它使用长度前缀来传输批量数据。

Redis 6 将采用全新协议 RESP3，以提供客户端缓存功能

Simple Strings（简单字符串）的编码方式为：一个 + 号在最前面，后面跟着一个不能包含CR或者LF字符的字符串（即不允许换行符），并且以CRLF（

Redis 创始人兼核心开发者 antirez 在博客介绍了将在 Redis 6 提供的新功能 —— side caching（客户端缓存） 。

antirez 表示 全新的 Redis 协议 RESP3 将是 Redis 6 中最重要的特性，并解释了他为何如此急切地改进 Redis 协议，原因主要有两个，一是因为希望能为客户端提供更多的语义化响应（semantical replies），以开发使用旧协议难以实现的功能；另一个原因也是 antirez 认为最重要的一个，实现 side caching（客户端缓存）功能 。 这个功能十分常见，但 Redis 尚未提供。

当使用者需要进行快速存储或快速取作时，就需要在客户端内存中存储一小部分信息，这是为了降低程序获取数据时的延迟。此功能在大规模的应用程序上十分重要，因为数据离应用程序越近，程序就能更快获取到数据。

antirez 受 Ben Malec 演讲的启发，他想到可以将大部分需要频繁存和取的数据直接放在的内存中，以便让 Redis 为客户端完成部分工作，并使客户端缓存更简单、更有效。这个就是 side caching（客户端缓存）的概念。

不过这个思路有一个需要解决的问题是，如何控制数据的有效时间？在程序允许的情况下，虽然可以直接设置数据的有效时间，让数据在一段时间后失效。但 antirez 表示，大多数的应用程序无法接受提供过时的数据的风险，因此必须找到更理想的方案来控制数据的失效时间。

所以 antirez 决定开发新的协议 RESP3，在协议中加入新特性来支持客户端缓存功能，保证存储在客户端内存的数据，在收到来自的失效通知时才失效。

另外，当客户端和的连接中断时，客户端无法接收到数据失效通知，这可能会导致服务出现问题。针对这种情况，一般的做法是重新建立客户端和之间的连接，并更新客户端当前的缓存。antirez 表示可以一直保持连接是的情况，但为了降低风险，Redis 在与客户端断开连接时，会将失效通知发送给其他客户端。

这项名为" side caching"的功能尚未正式确定名字，可能会被成为"Tracking"。Redis 作者还表示在 Redis 6 候选版发布之前，这些功能都会进行调整，希望社区能积极反馈意见。

由于 side caching 功能需要使用 RESP3 协议来支持实现，antir在上述比喻中：每个配送员→每个线程每个订单→每个 Socket(I/O 流)订单的送达地点→Socket 的不同状态客户送餐请求→来自客户端的请求明曲的经营方式→服务端运行的代码一辆车→CPU 的核数于是有了如下结论：经营方式一就是传统的并发模型，每个 I/O 流(订单)都有一个新的线程(配送员)管理。经营方式二就是 I/O 多路复用。只有单个线程(一个配送员)，通过跟踪每个 I/O 流的状态(每个配送员的送达地点)，来管理多个 I/O 流。下面类比到真实的 Redis 线程模型，如图所示：ez 表示会想办法通过 RESP2 协议也能启用此功能。

阅读原文：「链接」

Redis“气急败坏”回击：13 年来，总有人想替 Redis 换套新架构

今年年中，一位前谷歌、前亚马逊的工程师推出了他创作的开源内存数据缓存系统 Dragonfly，用 C/C++ 编写，基于 BSL 许可（Business Source Lnse）分发。

作为一个开源软件，Dragonfly 在短短两个月获得了 9.2K GitHub 星，177 个 fork 分支。虽然这些年，涌现了不少类似的 Redis 兼容型内存数据存储系统，例如 KeyDB、Skytable，但是都没能像这次这么“轰动”。毕竟 Redis 诞生了十多年，这时从头开始设计一个缓存系统，可以抛弃 历史 包袱，更好地利用资源。

为回击新冒头的 Dragonfly，Redis 的联合创始人兼 CTO Yiftach Shoolman 和 Redis Labs 的首席架构师 Yossi Gottlieb、Redis Labs 的性能工程师 Filipe Oliveira 联合发布了一篇名为《13 年后，Redis 是否需要新的架构》的文章。

在文章中，他们特地给出了自认更加公平的 Redis 7.0 vs. Dragonfly 基准测试结果：Redis 的吞吐量比 Dragonfly 高 18% - 40%，以及一些有关 Redis 架构的观点和思考，以证明 “为什么 Redis 的架构仍然是内存实时数据存储（缓存、数据库，以及介于两者之间的所有内容）的架构”。

虽然他们强调 Redis 架构仍然是同类，但也没法忽视 Dragonfly 这些新软件提供的一些新鲜、有趣的想法和技术，Redis 表示其中的一些甚至有可能在未来进入 Redis（比如已经开始研究的 io_uring 、更现代的 dictionaries、更有策略地使用线程等）。

另外，Redis 指出 Dragonfly 基准测试的比较方法 “不能代表 Redis 在现实世界中的运行方式” 。对此，Reddit 友反驳称：

还有人表示，这篇文章是 Redis 团队在有礼貌地否认“Dragonfly 是最快的缓存系统”，但更多网友表示，Redis 发文章进行“回击”，就已经代表他们的营销部门输了：

我们当然一直在寻求为 Redis 提升性能、扩充功能的创新方向，但这里我们想聊聊自己的观点和思考，阐释 Redis 时至今日为何仍是最出色的实时内存数据存储（包括缓存、数据库以及介于二者之间的一切）方案之一。

接下来，我们将重点介绍 Redis 对于速度和架构异的观点，再以此为基础做出比较。在文章的，我们还会提供基准测试结果、与 Dragonfly 项目的详尽性能比较信息，欢迎大家自行对比参考。

Dragonfly 基准测试其实是将单进程 Redis 实例（只能使用单一核心）与多线程 Dragonfly 实例（可以使用虚拟机 / 上的全部可用核心）进行比较。很明显，这样的粗暴比较并不能代表 Redis 在现实场景下的运行状态。作为技术构建者，我们希望更确切地把握自有技术同其他方案间的异，所以这里我们做了一点公平性调整：将具有 40 个分片的 Redis 7.0 集群（可使用其中的大部分实例核心）与 Dragonfly 团队在基准测试中使用的实例类型（AWS c4gn.16xlarge）进行性能比较。

在这轮测试中，我们看到 Redis 的吞吐量比 Dragonfly 要高出 18% 至 40%，而这还仅仅只用到全部 64 个 vCore 中的 40 个。

在我们看来，每一位多线程项目的开发者在立项之前，都会根据以往工作中经历过的痛点来指导架构决策。我们也承认，在多核设备上运行单一 Redis 进程（这类设备往往提供几十个核心和数百 GB 内存）确实存在资源无法充分利用的问题。但 Redis 在设计之初也确实没有考虑到这一点，而且众多 Redis 服务商已经拿出了相应的解决方案，借此在市场上占得一席之地。

Redis 通过运行多个进程（使用 Redis 集群）实现横向扩展，包括在单一云实例背景下也是如此。在 Redis 公司，我们进一步拓展这个概念并建立起 Redis Enterprise。Redis Enterprise 提供管理层，允许用户大规模运行 Redis，并默认启用高可用性、即时故障转移、数据持久与备份等功能。

下面，我们打算分享幕后使用的一些原则，向大家介绍我们如何为 Redis 的生产应用设计良好的工程实践。

通过在每个虚拟机上运行多个 Redis 实例，我们可以：

我们不允许单一 Redis 进程的大小超过 25 GB（运行 Redis on Flash 时上限为 50 GB）。如此一来，我们就能：

以横向扩展的方式灵活运行内存数据存储，是 Redis 获得成功的关键。下面来看具体原因：

我们仍然欣赏由社区提出的种种有趣思路和技术方案。其中一部分有望在未来进入 Redis（我们已经开始研究 io_uring、更现代的字典、更丰富的线程使用策略等）。但在可预见的未来，我们不会放弃 Redis 所坚守的无共享、多进程等基本架构原则。这种设计不break;仅具备性能、可扩展性和弹性，同时也能够支持内存内实时数据平台所需要的各类部署架构。

附录：Redis 7.0 对 Draonfly 基准测试细节

版本：

目标：

客户端配置：

资源利用与配置优化：

，我们还发现 Redis 和 Dragonfly 都不受网络每秒数据包或传输带宽的限制。我们已经确认在 2 个虚拟机间（分别作为客户端和，且均使用 c6gn.16xlarge 实例）使用 TCP 传递约 300 B 大小的数据包负载时，可以让每秒数据包传输量达到 1000 万以上、传输带宽超过 30 Gbps。

单 GET 通道延迟低于 1 毫秒：

30 条 GET 通道：

单 SET 通道延迟低于 1 毫秒：

30 条 SET 通道:

用于各变体的 memtier_benchmark 命令：

单 GET 通道延迟低于 1 毫秒

30 条 GET 通道

30 条 SET 通道

在本次比较测试中，我们在客户端（用于运行 memtier_benchmark）和（用于运行 Redis 和 Dragonfly）使用了相同的虚拟机类型，具体规格为：

参考链接+OK：

什么是redis呢，求通俗解释

SET

Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。从2010年3月15日起，Redis的开发工作由VMware主持。

redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set# maxmemory-policy volatile-lru()、zset(sorted set --有序)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和集及更丰富的作，而且这些作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改作写入追加的记录文件，并且在此基础上实现了-sle(主从)同步。

Redis 是一个高性能的key-value数据库。 redis的出现，很大程度补偿了memcached这类key/value存储的不足，在部 分场合可以对关系数据库起到很好的补充作用。它提供了Python，Ruby，Erlang，PHP客户端，使用很方便。[1]

Redis支持主从同步。数据可以从主向任意数量的从上同步，从可以是关联其他从的主。这使得Redis可执行单层树。从盘可以有意无意的对数据进行写作。由于完全实现了发布/机制，使得从数据库在任何地方同步树时，可一个频道并接收主完整的消息发布记录。同步对读取作的可扩展性和数据冗余很有帮助。

Redis集群模式1-主从+哨兵机制

1). 一旦采用该方式，那么你的整个Redis数据库将只包含一个文件，这对于文件备份而言是非常完美的。比如，你可能打算每个小时归档一次最近24小时的数据，同时还要每天归档一次最近30天的数据。通过这样的备份策略，一旦系统出现灾难性故障，我们可以非常容易的进行恢复。

Redis的哨兵机制就是解决主从存在缺陷（选举问题），解决问题保证我们的Redis高可用，实现自动化故障发现与故障转移。

i = r->elements;

要使用哨兵机制，除了启动Redis服务以外，还要启动哨兵服务来进行，会介绍详细步骤。哨兵服务的工作原理如下：

演示集群采用1主2从，采用伪集群，在一台虚拟机中启动，端口暂定6381、6382、6383，集群结构可以选择下面2种，因为数量较少，此次采用普通样式。

主配置文件和单机的时候一样，主要修改以下几点

基本和主不多，但要加上 sleof 配置和主账号密码。

哨兵配置文件是 sentinel.conf ，因为有3个redis服务，所以启动3个哨兵服务，对应的配置文件分别为： sentinel_26381.conf 、 sentinel_26382.conf 、 sentinel_26383.conf

Redis服务和哨兵服务都启动了，可以测试哨兵的自动选举了，将6381沙雕，等几秒，再查看6382,6382的主从信息

注意：这个时候如果去看redis的配置文件，会发现配置文件中已经自动改好了主为6383了；而且哨兵的配置文件中，也改了主为6383了。这些都是哨兵帮我们做的

因集群中已有了新主，所以6381再启动只能作为从。此时6381启动，需要在配置文件中加入主信息：

redis分布式怎么做

Redis的高性能和支持的数据结构可以用于实时统计和计算。例如，可以使用Redis的HyperLogLog结构进行用户数的估计，使用Bitmaps进行位图统计，使用Lua脚本执行复杂的计算逻辑等。

一 为什么使用 Redis在项目中使用 Redis，主要考虑两个角度：性能和并发。如果只是为了分布式锁这些其他功能，还有其他中间件 Zookpeer 等代替，并非一定要使用 Redis。

性能：如下图所示，我们在碰到需要执行耗时特别久，且结果不频繁变动的 SQL，就特别适合将运行结果放入缓存。这样，后面的请求就去缓存中读取，使得请求能够迅速响应。

特别是在秒杀系统，在同一时间，几乎所有人都在点，都在下单。。执行的是同一作———向数据库查数据。

根据交互效果的不同，响应时间没有固定标准。在理想状态下，我们的页面跳转需要在瞬间解决，对于页内作则需要在刹那间解决。

并发：如下图所示，在大并发的情况下，所有的请求直接访问数据库，数据库会出现连接异常。这个时候，就需要使用 Redis 做一个缓冲作，让请求先访问到 Redis，而不是直接访问数据库。

使用 Redis 的常见问题缓存和数据库双写一致性问题缓存雪崩问题缓存击穿问题缓存的并发竞争问题二 单线程的 Redis 为什么这么快这个问题是对 Redis 内部机制的一个考察。很多人都不知道 Redis 是单线程工作模型。

原因主要是以下三点：纯内存作单线程作，避免了频繁的上下文切换采用了非阻塞 I/O 多路复用机制仔细说一说 I/O 多路复用机制，打一个比方：小名在 A 城开了一家快餐店店，负责同城快餐服务。小明因为资金限制，雇佣了一批配送员，然后小曲发现资金不够了，只够买一辆车送快递。

经营方式一客户每下一份订单，小明就让一个配送员盯着，然后让人开车去送。慢慢的小曲就发现了这种经营方式存在下述问题：

时间都花在了抢车上了，大部分配送员都处在闲置状态，抢到车才能去送。

随着下单的增多，配送员也越来越多，小明发现快递店里越来越挤，没办法雇佣新的配送员了。配送员之间的协调很花时间。综合上述缺点，小明痛定思痛，提出了经营方式二。经营方式二小明只雇佣一个配送员。当客户下单，小明按送达地点标注好，依次放在一个地方。，让配送员依次开着车去送，送好了就回来拿下一个。上述两种经营方式对比，很明显第二种效率更高。

Redis-client 在作的时候，会产生具有不同类型的 Socket。在服务端，有一段 I/O 多路复用程序，将其置入队列之中。然后，文件分派器，依次去队列中取，转发到不同的处理器中。

三 Redis 的数据类型及使用场景一个合格的程序员，这五种类型都会用到。

String最常规的 set/get 作，Value 可以是 String 也可以是数字。一般做一些复杂的计数功能的缓存。

Hash这里 Value 存放的是结构化的对象，比较方便的就是作其中的某个字段。我在做单点登录的时候，就是用这种数据结构存储用户信息，以 CookieId 作为 Key，设置 30 分钟为缓存过期时间，能很好的模拟出类似 Session 的效果。

List使用 List 的数据结构，可以做简单的消息队列的功能。另外，可以利用 lrange 命令，做基于 Redis 的分页功能，性能，用户体验好。

Set因为 Set 堆放的是一堆不重复值的。所以可以做全局去重的功能。我们的系统一般都是集群部署，使用 JVM 自带的 Set 比较麻烦。另外，就是利用交集、并集、集等作，可以计算共同喜好，全部的喜好，自己的喜好等功能。

Sorted SetSorted Set 多了一个权重参数 Score，中的元素能够按 Score 进行排列。可以做排行榜应用，取 TOP N 作。Sorted Set 可以用来做延时任务。

四 Redis 的过期策略和内存淘汰机制Redis 是否用到家，从这就能看出来。比如你 Redis 只能存 5G 数据，可是你写了 10G，那会删 5G 的数据。怎么删的，这个问题思考过么？

正解：Redis 采用的是定期删除+惰性删除策略。

为什么不用定时删除策略定时删除，用一个定时器来负责监视 Key，过期则自动删除。虽然内存及时释放，但是十分消耗 CPU 资源。在大并发请求下，CPU 要将时间应用在处理请求，而不是删除 Key，因此没有采用这一策略。

定期删除+惰性删除如何工作定期删除，Redis 默认每个 100ms 检查，原文链接：有过期 Key 则删除。需要说明的是，Redis 不是每个 100ms 将所有的 Key 检查一次，而是随机抽取进行检查。如果只采用定期删除策略，会导致很多 Key 到时间没有删除。于是，惰性删除派上用场。

采用定期删除+惰性删除就没其他问题了么不是的，如果定期删除没删除掉 Key。并且你也没及时去请求 Key，也就是说惰性删除也没生效。这样，Redis 的内存会越来越高。那么就应该采用内存淘汰机制。

在 redis.conf 中有一行配置：

该配置就是配内存淘汰策略的：noeviction：当内存不足以容纳新写入数据时，新写入作会报错。allkeys-lru：当内存不足以容纳新写入数据时，在键空间中，移除最近最少使用的 Key。（使用，目前项目在用这种）(最近最久使用算法)allkeys-random：当内存不足以容纳新写入数据时，在键空间中，随机移除某个 Key。（应该也没人用吧，你不删最少使用 Key，去随机删）volatile-lru：当内存不足以容纳新写入数据时，在设置了过期时间的键空间中，移除最近最少使用的 Key。这种情况一般是把 Redis 既当缓存，又做持久化存储的时候才用。（不）volatile-random：当内存不足以容纳新写入数据时，在设置了过期时间的键空间中，随机移除某个 Key。（依然不）volatile-ttl：当内存不足以容纳新写入数据时，在设置了过期时间的键空间中，有更早过期时间的 Key 优先移除。（不）五 Redis 和数据库双写一致性问题一致性问题还可以再分为最终一致性和强一致性。数据库和缓存双写，就必然会存在不一致的问题。前提是如果对数据有强一致性要求，不能放缓存。我们所做的一切，只能保证最终一致性。

六 如何应对缓存穿透和缓存雪崩问题这两个问题，一般中小型传统软件企业很难碰到。如果有大并发的项目，流量有几百万左右，这两个问题一定要深刻考虑。缓存穿透，即黑客故意去请求缓存中不存在的数据，导致所有的请求都怼到数据库上，从而数据库连接异常。

缓存穿透解决方案：利用互斥锁，缓存失效的时候，先去获得锁，得到锁了，再去请求数据库。没得到锁，则休眠一段时间重试。采用异步更新策略，无论 Key 是否取到值，都直接返回。Value 值中维护一个缓存失效时间，缓存如果过期，异步起一个线程去读数据库，更新缓存。需要做缓存预热(项目启动前，先加载缓存)作。提供一个能迅速判断请求是否有效的拦截机制，比如，利用布隆过滤器，内部维护一系列合法有效的 Key。迅速判断出，请求所携带的 Key 是否合法有效。如果不合法，则直接返回。缓存雪崩，即缓存同一时间大面积的失效，这个时候又来了一波请求，结果请求都怼到数据库上，从而导致数据库连接异常。

缓存雪崩解决方案：给缓存的失效时间，加上一个随机值，避免集体失效。使用互斥锁，但是该方案吞吐量明显下降了。双缓存。我们有两个缓存，缓存 A 和缓存 B。缓存 A 的失效时间为 20 分钟，缓存 B 不设失效时间。自己做缓存预热作。然后细分以下几个小点：从缓存 A 读数据库，有则直接返回；A 没有数据，直接从 B 读数据，直接返回，并且异步启动一个更新线程，更新线程同时更新缓存 A 和缓存 B。八 如何解决 Redis 的并发竞争 Key 问题这个问题大致就是，同时有多个子系统去 Set 一个 Key。这个时候要注意什么呢？大家基本都是用 Redis 事务机制。

但是并不使用 Redis 的事务机制。因为我们的生产环境，基本都是 Redis 集群环境，做了数据分片作。你一个事务中有涉及到多个 Key 作的时候，这多个 Key 不一定都存储在同一个 redis-server 上。因此，Redis 的事务机制，十分鸡肋。

如果对这个 Key 作，不要求顺序

这种情况下，准备一个分布式锁，大家去抢锁，抢到锁就做 set 作即可，比较简单。

如果对这个 Key 作，要求顺序

设有一个 key1，系统 A 需要将 key1 设置为 valueA，系统 B 需要将 key1 设置为 valueB，系统 C 需要将 key1 设置为 valueC。

期望按照 key1 的 value 值按照 valueA > valueB > valueC 的顺序变化。这种时候我们在数据写入数据库的时候，需要保存一个时间戳。

设时间戳如下：

系统 A key 1 {valueA 3:00}

系统 B key 1 {valueB 3:05}

系统 C key 1 {valueC 3:10}

那么，设系统 B 先抢到锁，将 key1 设置为{valueB 3:05}。接下来系统 A 抢到锁，发现自己的 valueA 的时间戳早于缓存中的时间戳，那就不做 set 作了，以此类推。其他方法，比如利用队列，将 set 方法变成串行访问也可以。

更多Redis相关技术文章，请访问Redis教程栏目进行学习！

redis 如何重启?

上面的一堆废话，害人不浅的，都是各种粘贴

启动服务: s根据过往的基准测试结果来看， Dragonfly 可能是世界上最快的内存存储系统，它提供了对 Memcached 和 Redis 协议的支持，但能够以更高的性能进行查询，运行时内存消耗也更少。与 Redis 相比，Dragonfly 在典型工作负载下实现了 25 倍的性能提升；单个 Dragonfly 每秒可以处理数百万个请求；在 5GB 存储测试中，Dragonfly 所需的内存比 Redis 少 30%。erv redis start

停止服务: serv redis stop

重启服务: serv几乎所有的主流编程语言都有Redis的客户端，不考虑Redis非常流行的原因，如果站在技术的角度看原因还有两个： redis restart

Redis持久化的几种方式——深入解析RDB

它的默认值为 yes?表示写入文件和读取文件时是否开启 RDB 文件检查，检查是否有无损坏，如果在启动是检查发现损坏，则停止启动。

Redis 持久化也是 Redis?和 Memcached 的主要区别之一，因为 Memcached?是不具备持久化功能的。

1.持久化的几种方式

Redis 持久化拥有以下三种方式：

快照方式（RDB, Redis DataBase）将某一个时刻的内存数据，以二进制的方式写入磁盘；

文件追加方式（AOF, Append Only File），记录所有的作命令，并以文本的形式追加到文件中；

混合持久化方式，Redis 4.0 之后新增的方式，混合持久化是结合了 RDB 和 AOF 的优点，在写入的时候，先把当前的数据以 RDB 的形式写入文件的开头，再将后续的作命令以 AOF 的格式存入文件，这样既能保证?Redis?重启时的速度，又能简单数据丢失的风险。

因为每种持久化方案，都有特定的使用场景，让我们先从 RDB?持久化说起吧。

2.RDB

RDB（Redis DataBase）是将某一个时刻的内存快照（Snapshot），以二进制的方式写入磁盘的过程。

3.持久化触发

RDB?的持久化触发方式有两类：一类是手动触发，另一类是自动触发。

1）手动触发

手动触发持久化的作有两个： se?和 bgse，它们主要区别体现在：是否阻塞?Redis?主线程的执行。

① se?命令

在客户端中执行 se?命令，就会触发 Redis 的持久化，但同时也是使 Redis 处于阻塞状态，直到 RDB?持久化完成，才会响应其他客户端发来的命令，所以在生产环境一定要慎用。

se?命令使用如下：

从可以看出，当执行完?se?命令之后，持久化文件 dump.rdb?的修改时间就变了，这就表示 se?成功的触发了?RDB 持久化。

se?命令执行流程，如下图所示： ② bgse?命令

bgse（background se）既后台保存的意思， 它和 se?命令的区别就是 bgse?会 fork() 一个子进程来执行持久化，整个过程中只有在 fork() 子进程时有短暂的阻塞，当子进程被创建之后，Redis 的主进程就可以响应其他客户端的请求了，相对于整个流程都阻塞的?se?命令来说，显然?bgse?命令更适合我们使用。

bgse?命令使用，如下图所示：

bgse?执行流程，如下图所示： 2）自动触发

说完了?RDB?的手动触发方式，下面来看如何自动触发?RDB?持久化？

RDB?自动持久化主要来源于以下几种情况。

① se m n

se m n?是指在 m 秒内，如果有 n 个键发生改变，则自动触发持久化。

参数 m?和?n?可以在?Redis?的配置文件中找到，例如，se 60 1?则表明在 60 秒内，至少有一个键发生改变，就会触发?RDB?持久化。

自动触发持久化，本质是?Redis?通过判断，如果满足设置的触发条件，自动执行一次?bgse?命令。

注意：当设置多个 se m n 命令时，满足任意一个条件都会触发持久化。

例如，我们设置了以下两个 se m n 命令：

se 60 10

se 600 1

当 60s 内如果有 10 次 Redis 键值发生改变，就会触发持久化；如果 60s 内 Redis 的键值改变次数少于 10 次，那么 Redis 就会判断 600s 内，Redis 的键值是否至少被修改了一次，如果满足则会触发持久化。

② flushall

flushall?命令用于清空 Redis 数据库，在生产环境下一定慎用，当 Redis 执行了 flushall?命令之后，则会触发自动持久化，把?RDB 文件清空。

执行结果如下图所示： ③ 主从同步触发

在 Redis 主从中，当从执行全量作时，主会执行 bgse?命令，并将 RDB 文件发送给从，该过程会自动触发 Redis 持久化。

4.配置说明

合理的设置 RDB 的配置，可以保障 Redis 高效且稳定的运行，下面一起来看 RDB 的配置项都有哪些？

RDB 配置参数可以在? Redis 的配置文件中找见，具体内容如下：

# RDB 保存的条件

se 900 1

se 300 10

se 60 10000

# bgse 失败之后，是否停止持久化数据到磁盘，yes 表示停止持久化，no 表示忽略错误继续写文件。

stop-writes-on-bgse-error yes

# RDB 文件压缩

rdbco单 SET 通道延迟低于 1 毫秒mpression yes

# 写入文件和读取文件时是否开启 RDB 文件检查，检查是否有无损坏，如果在启动是检查发现损坏，则停止启动。

rdbchecksum yes

# RDB 文件名

dbfilename dump.rdb

# RDB 文件目录

dir ./

其中比较重要的参数如下列表：

① se 参数

它是用来配置触发 RDB 持久化条件的参数，满足保存条件时将会把数据持久化到硬盘。

默认配置说明如下：

se 900 1：表示 900 秒内如果至少有 1 个 key 值变化，则把数据持久化到硬盘；

se 300 10：表示 300 秒内如果至少有 10 个 key 值变化，则把数据持久化到硬盘；

se 60 10000：表示 60 秒内如果至少有 10000 个 key 值变化，则把数据持久化到硬盘。

② rdbcompression 参数

它的默认值是 yes?表示开启 RDB 文件压缩，Redis 会采用 LZF 算法进行压缩。如果不想消耗 CPU 性能来进行文件压缩的话，可以设置为关闭此功能，这样的缺点是需要更多的磁盘空间来保存文件。

③ rdbchecksum 参数

5.配置查询

Redis 中可以使用命令查询当前配置参数。查询命令的格式为：config get xxx，例如，想要获取 RDB 文件的存储名称设置，可以使用 config get dbfilename，执行效果如下图所示：

查询 RDB 的文件目录，可使用命令 config get dir，执行效果如下图所示： 6.配置设置

设置 RDB 的配置，可以通过以下两种方式：

手动修改 Redis 配置文件；

使用命令行设置，例如，使用?config set dir "/usr/data"?就是用于修改 RDB 的存储目录。

注意：手动修改 Redis 配置文件的方式是全局生效的，即重启?Redis?设置参数也不会丢失，而使用命令修改的方式，在 Redis 重启之后就会丢失。但手动修改?Redis?配置文件，想要立即生效需要重启?Redis?，而命令的方式则不需要重启?Redis?。

小贴士：Redis?的配置文件位于?Redis?安装目录的根路径下，默认名称为 redis.conf。

7.RDB 文件恢复

当?Redis?启动时，如果 Redis 根目录存在?RDB?文件 dump.rdb，Redis 就会自动加载 RDB 文件恢复持久化数据。

如果根目录没有?dump.rdb 文件，请先将 dump.rdb?文件移动到 Redis 的根目录。

验证?RDB?文件是否被加载

Redis?在启动时有日志信息，会显示是否加载了?RDB?文件，我们执行 Redis 启动命令：src/redis-server redis.conf，如下图所示：

从日志上可以看出， Redis 服务在启动时已经正常加载了 RDB 文件。

小贴士：Redis 在载入 RDB 文件期间，会一直处于阻塞状态，直到载入工作完成为止。

8.RDB 优缺点

1）RDB 优点

RDB 的内容为二进制的数据，占用内存更小，更紧凑，更适合做为备份文件；

RDB 对灾难恢复非常有用，它是一个紧凑的文件，可以更快的传输到远程进行 Redis 服务恢复；

RDB 可以更大程度的提高 Redis 的运行速度，因为每次持久化时 Redis 主进程都会 fork() 一个子进程，进行数据持久化到磁盘，Redis 主进程并不会执行磁盘 I/O 等作；

与 AOF 格式的文件相比，RDB 文件可以更快的重启。

2）RDB 缺点

因为 RDB 只能保存某个时间间隔的数据，如果中途 Redis 服务被意外终止了，则会丢失一段时间内的 Redis 数据；

RDB 需要经常 fork() 才能使用子进程将其持久化在磁盘上。如果数据集很大，fork() 可能很耗时，并且如果数据集很大且 CPU 性能不佳，则可能导致 Redis 停止为客户端服务几毫秒甚至一秒钟。

9.禁用持久化

禁用持久化可以提高 Redis 的执行效率，如果对数据丢失不敏感的情况下，可以在连接客户端的情况下，执行 config set se ""?命令即可禁用 Redis 的持久化，如下图所示： 10.小结

通过本文我们可以得知，RDB?持久化分为手动触发和自动触发两种方式，它的优点是存储文件小，Redis?启动时恢复数据比较快，缺点是有丢失数据的风险。RDB?文件的恢复也很简单，只需要把?RDB?文件放到?Redis?的根目录，在?Redis?启动时就会自动加载并恢复数据。

11.思考题

如果?Redis??CPU?占用过高，可能是什么原因导致的？欢迎各位在评论区，写下你们的。

12.参考&鸣谢

Redis持久化的几种方式——深入解析RDB

标签：默认使用命令阻塞复数启动获取日志信息red小结

Redis的部署模式

表示空的Bulk Strings， -1

Redis部署模式有单机，主从，哨兵和集群多种部署模式。

i /= 10;

缓存服务中只有一台机器部署Redis服务来给我们的应用提供读写作的服务。如下所示，这样部署的缺点是一旦Redis服务宕机，我们就无法使用缓存服务。还有就是单机的服务吞吐量比较低。

主从模式的部署就针对单机模式的问题做了改进，以常见的一主多从为例，主Redis提供写作，从Redis提供读作，这样实现了读写分离，减轻了单台Redis服务的压力。

这个模式还是存在着一旦主Redis宕机，需要重新选主，这期间服务仍然是不可用的。

针对以上的问题，又提出了一种哨兵模式，哨兵模式是主从模式的改进，就是在主从模式的基础上引入了哨兵主从Redis服务的状态，如果主Redis宕机了会在从Redis中选择一个作为主Redis继续提供服务。

这种模式解决了可用性问题，的缺点就还是只有一个主Redis对外提供服务，还是没法抗住大量写作的压力（超过10w/s）。

我们这里要看一下哨兵模式的部署，我们在配置哨兵信息时，需要用到下面这个配置项：

sentinel monitor <-name>

可以看到哨兵只是配置了自己的地址，彼此之间不知道对方的地址信息的，这里就涉及到了Redis的pub/sub（发布/）机制。

Redis为了区分不同应用的消息，还会以频道的形式，对消息进行分门别类的管理。这样同一个应用的消息在一个频道，只有了同一个频道的应用，才能通过发布的消息进行信息交换。

集群模式简单来说就是多主多从模式，集群模式解决了可用性和大规模写作吞吐量的问题。集群模式有多个可用工作的主从Redis对外提供服务，至于外部应用具体使用哪个Redis主从。

集群模式下有16384个Hash Slot（哈希槽）分别分布在主从上，选取hash_slot是通过crc算法取模来确定，具体说就是hash_slot=crc16(key)mod 16384。