# Redis 6.2.5 配置文件示例
#
# 最大占用内存
maxmemory 104857600
#
# 连接密码
requirepass redispass
#
# 最大连接数
maxclients 10000
#
#
# 注意：为了顺利读取配置，Redis 第一个参数必须为配置文件名：
#
# ./redis-server /path/to/redis.conf

# 调整内存大小通常使用 1k 5GB 4M 形式：
#
# 1k => 1000 bytes
# 1kb => 1024 bytes
# 1m => 1000000 bytes
# 1mb => 1024*1024 bytes
# 1g => 1000000000 bytes
# 1gb => 1024*1024*1024 bytes
#
# 单位不区分大小写，所以1GB 1GB 1GB都是一样的。

################################## 引入 ###################################

# 引入一个或多个配置文件。如果你有一个适用于所有 Redis 服务器的标准模板，
# 但需要自定义其它服务器配置，这将是有用的。
# 被包含的文件，也可以包含其它文件，你要留意这一点。

# 引入的文件不会被管理员或 Redis 哨兵的 "CONFIG REWRITE" 重写。
# 由于 Redis 总是使用最后处理的行作为配置指令值，
# 你最好把引入的文件放在头部，以避免在运行时被覆盖。
#
# 相反，要覆盖配置，你需要在文件最后一行引入配置文件。
#
# include /path/to/local.conf
# include /path/to/other.conf

################################## 组件 #####################################
# 在启动时加载模块。
# 如果服务器无法加载模块，它将中止。可以使用多个 loadmodule 指令。
#
# loadmodule /path/to/my_module.so
# loadmodule /path/to/other_module.so

################################## 网络 #####################################

# 默认情况下，如果没有指定 "bind" 配置，Redis 将监听服务器上所有可用的网络连接。
# 可以使用 "bind" 配置指令监听一个或多个地址，后跟一个或多个IP地址。
#
# 示例：
#
# bind 192.168.1.100 10.0.0.1
# bind 127.0.0.1 ::1
#
# ~~~ 警告 ~~~
# 如果运行 Redis 的计算机直接暴露在互联网上，绑定到所有地址是危险的，会暴露实例给网络上的所有人。
# 所以默认情况下，我们取消注释下面的 bind，这将迫使 Redis 只监听本机地址（这意味着 Redis 将只接受本地的访问）。

# 如果你确定你想让你的实例监听所有的地址，只需注释下面的行。
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
bind 0.0.0.0

# 保护模式是一层安全保护，以避免 Redis 实例在网络上被访问和利用。
#
# 1) 服务器没有绑定地址，使则使用 "bind"
# 2) 没有配置密码
#
# 服务器只接受客户端的连接
# IPv4 和 IPv6 回环地址 127.0.0.1 和 ::1，来自 Unix 域套接字。
#
# 默认启用保护模式。
# 只有你确定允许其他主机的客户端连接到 Redis 时，
# 即使没有配置身份验证，也没有使用 "bind" 配置特定地址，才应该禁用它。
protected-mode yes

# 在指定的端口上接受连接，默认是 6379 (IANA #815344)。
# 如果为 0， Redis 将不会监听。
port 6379

# TCP listen() 完整连接队列
# 参见：
# redis tcp-backlog配置 https://www.cnblogs.com/Alight/p/4027733.html
# 在高并发环境中，为了避免客户端连接速度慢，你需要设置较高的 backlog。
# 请注意，Linux 内核将截断为 /proc/sys/net/core/somaxconn 的值，
# 因此你需要调整 somaxconn 和 tcp_max_syn_backlog 的值，以获得预期的效果。
tcp-backlog 511

# Unix 套接字
#
# 指定将用于侦听传入连接的 Unix 套接字路径。
# 没有默认值，所以当没有指定时，Redis 将不会监听 unix 套接字。
#
# unixsocket /tmp/redis.sock
# unixsocketperm 700

# 在客户端空闲N秒（0 禁用）后关闭连接
timeout 0

# TCP 保持
#
# 如果不为零，在没有通信的情况下，使用 SO_KEEPALIVE 向客户端发送 TCP ACK。

# 原因是：
# 1) 检测连通
# 2) 从中间网络设备的角度来看，连接是活动的。
#
# 在 Linux 上，指定的值（以秒为单位）是用于发送 ACK 的时间段。
# 请注意，关闭连接需要两倍的时间。
# 在其他内核上，周期取决于内核配置。
# 这个选项的合理值是 300 秒，这是新功能
# 默认从 Redis 3.2.1 开始有效
tcp-keepalive 300

################################# 常规 #####################################

# 默认情况下 Redis 不以守护进程方式运行。使用 yes，来启用。
# Redis 将在 /var/run/redis.pid 中写入 pid 来监控。
daemonize yes

# 如果从 upstart 或 systemd 运行 Redis，
# 那么，Redis 可以与 supervision 进行交互。选项：
#   supervised no      - 无交互
#   supervised upstart - 通过将 Redis 设置为 SIGSTOP 模式发出信号
#   supervised systemd - 通过将 READY=1 写入 $NOTIFY_SOCKET 来通知 systemd
#   supervised auto    - 基于 upstart_job 或 NOTIFY_SOCKET 环境变量检测 upstart 或 systemd 方法

# 注意：
# 这些仅表示"进程已就绪"。它们不能持续 ping 回应 supervisor

supervised no

# 如果指定了 PID 文件，Redis 启动时写入指定位置，并在退出后删除。
#
# 服务器以非守护方式运行时，如果配置中未指定 PID 文件，则不会创建 PID 文件。
# 当服务器以守护方式运行时，即使未指定，也会使用 PID 文件，默认为 "/var/run/redis.pid"。

# 创建PID文件是最好的做法：如果 Redis 无法创建该文件，则服务器将正常启动和运行。
pidfile /www/server/redis/redis.pid

# 指定服务器调试级别。
# 值有：
# debug   （大量信息，在开发/测试中有用）
# verbose （很多信息，但不会像调试级别那样多）
# notice  （适用，在生产环境中使用）
# warning （仅记录非常重要/严重的消息）
loglevel notice

# 指定日志文件名。此外，空字符串还可以用于强制 Redis 到标准输出。
# 请注意，如果以守护方式运行，使用标准输出，那么日志将被发送到 /dev/null
logfile "/www/server/redis/redis.log"


# 要使用系统日志记录器，只需将 'syslog-enable' 设置为 yes，
# 并可选择更新其他系统日志参数以满足您的需要。
# syslog-enabled no

# 指定 syslog 标识
# syslog-ident redis

# 指定 syslog 功能。必须是 USER 或介于 LOCAL0-LOCAL7 之间。
# syslog-facility local0

# 设置数据库数量。默认数据库为 DB 0，你可以使用 SELECT 选择一个不同的数据库，
# 其中 dbid 是介于 0 和 'databases'-1 之间的数字。
databases 16

# 默认情况下，Redis 仅在登录到标准输出是 TTY 时才显示 ASCII 艺术徽标。这意味着通常在交互式会话中显示徽标。

# 可以通过设置为 yes 来强制显示，在 4.0 之前始终显示 ASCII 艺术徽标。
always-show-logo yes

################################ 快照  ################################
#
# 保存数据到磁盘
#
#   save <秒数> <次数>
#
#   在给定的秒数下超过指定写入次数，那么将执行保存操作
#
#   下面的示例中，将会触发保存：
#   900 秒后（15分钟），超过 1 次修改
#   300 秒后（5分钟），超过 10 次修改
#   60 秒后，超过 10000 次修改
#
#   注意：你可以通过注释掉所有 "save" 行来禁用保存。
#
#   也可以通过添加一个带有空字符串参数的 save，来删除之前配置的所有保存点，
#   比如:
#
#   save ""

save 900 1
save 300 10
save 60 10000


# 默认情况下，如果启用了 RDB 快照（至少一个保存点），并且后台保存失败了，那么，Redis 将禁止写入操作。
# 这让用户意识到（以一种艰难的方式）数据没有正确地保存在磁盘上，否则很可能没有人会注意到它，以至于发生一些灾难。
#
# 如果后台保存操作恢复正常，Redis 将自动允许写入。
#
# 但是，如果你已经设置了对 Redis 服务器和持久性的监控，那么你可能需要禁用此功能，以便 Redis 继续照常工作，即使存在磁盘、权限等问题。
stop-writes-on-bgsave-error yes

# 使用 LZF 算法存储 .rdb 数据？
# 默认设置为 'yes'，因为它总是成功。
# 要在保存时节省一些 CPU，请将其设置为 'no'，如果存在可压缩的键值，数据集可能会很大。
rdbcompression yes

# 从 RDB 5 后，CRC64 校验和被放置在文件的末尾。
# 这使得格式更能抵抗损坏，但在保存和加载 RDB 文件时会降低性能（大约 10%），因此可以禁用它来获得最佳性能。
#
# 在禁用的情况下创建的 RDB 文件校验和为零，这将告诉加载代码跳过检查。
rdbchecksum yes

# 转储数据库文件名
dbfilename dump.rdb

# 工作目录
#
# 数据将写入到此目录中，文件名使用 'dbfilename' 配置。
#
# 附加文件也将在此目录中创建。
#
# 注意这里必须指定目录，而不是文件名。
dir /www/server/redis/

################################# 同步 #################################

# 主从复制。使用 replicaof 使 Redis 实例成为另一个 Redis 服务器的副本。你需要尽快了解 Redis 复制的一些事项。
#
#   +------------------+      +---------------+
#   |      Master      | ---> |    Replica    |
#   |     (写操作)     |      |   (复制操作)  |
#   +------------------+      +---------------+
#
# 1) Redis 复制是异步的，但你可以配置主机，
#    如果它没有连接到至少给定数量的副本，则停止接受写入。
#
# 2) 如果复制链路丢失的时间相对较短，Redis 副本可以重新同步。
#    你需要配置 backlog 大小（请参阅本文的后续部分）。
#
# 3) 复制是自动的，不需要用户干预。
#    在网络分区之后，副本服务器会自动尝试重新连接到主服务器并与它们重新同步。
#
# replicaof <主 IP> <主端口>

# 如果主服务器是受密码保护的（需要配置 requirepass），
# 那么在启动复制时需要身份验证，否则主机将拒绝副本请求。
#
# masterauth <主密码>


# 当从服务器与主服务器连接断开时，或者当复制过程仍在进行时，副本服务器可以通过两种不同的方式工作：
#
# 1) 如果 replica-serve-stale-data 设置为 'yes'（默认值），
#    则从服务器仍将回复客户端请求（可能包含过期数据），如果这是第一次同步，则数据集可能为空。
#
# 2) 如果 replica-serve-stale-data 设置为 'no'，
     那么，从服务器将返回 'SYNC with master in progress'。
#    除了 INFO, replicaOF, AUTH, PING, SHUTDOWN, REPLCONF, ROLE, CONFIG,
#    SUBSCRIBE, UNSUBSCRIBE, PSUBSCRIBE, PUNSUBSCRIBE, PUBLISH, PUBSUB,
#    COMMAND, POST, HOST 和 LATENCY 以外所有命令。
#
replica-serve-stale-data yes

# 你可以将副本实例配置为接受或不接受写入。
# 针对副本实例的写入对于存储一些临时数据可能很有用（因为在与主服务器重新同步后，写入副本的数据很容易被删除），
# 但如果客户端由于配置错误而写入它，也可能会导致问题。
#
# 自 Redis 2.6 后，副本默认是只读的。
#
# 注意：只读副本不会暴露给互联网上不受信任的客户端。它只是防止滥用实例的保护层。
# 默认情况下，只读副本仍会导出所有管理命令，例如 CONFIG、DEBUG 等。在有限的范围内，
# 你可以使用 'rename-command' 来隐藏所有管理/危险命令，从而提高只读副本的安全性。
replica-read-only yes

# 复制同步策略：disk 或 socket。
#
# -------------------------------------------------------
# 警告：无盘复制目前处于实验阶段
# -------------------------------------------------------
#
# 新副本和重新连接的副本无法继续仅接收差异的复制过程，需要执行 "full synchronization"。
# RDB 文件从主服务器传输到副本。
# 传输可以使用两种不同的方式：
#
# 1) Disk-backed: Redis 主节点创建一个将 RDB 文件写入磁盘的新进程。
#                 稍后，文件由父进程以增量方式传输到副本。
#
# 2) Diskless: Redis 主节点创建一个新进程，直接将 RDB 文件写入副本套接字，完全不接触磁盘。
#
# 使用 disk-backed 复制，当生成 RDB 文件时，只要生成 RDB 文件的当前子节点完成其工作，就可以将更多的副本排队并使用 RDB 文件服务。
# 而使用无磁盘复制，一旦传输开始，到达的新副本将排队，当前传输终止时，新的传输将开始。
#
# 当使用无盘复制时，主服务器在开始传输之前等待一段时间（可配置，以秒为单位），
# 希望多个副本能够到达并且传输可以并行。
#
# 对于速度较慢的磁盘和快速（大带宽）网络，无盘复制效果更好。
repl-diskless-sync no

# 当启用无磁盘复制时，可以配置服务器等待时间，以便生成通过套接字将 RDB 传输到副本的子节点。
#
# 这很重要，因为一旦传输开始，就不可能为到达的新副本提供服务，
# 这些副本将排队等待下一次 RDB 传输，因此服务器会等待延迟以便让更多副本到达。
#
# 延迟以秒为单位指定，默认为 5 秒。要完全禁用它，只需将其设置为 0 ，传输将尽快开始。
repl-diskless-sync-delay 5

# 副本以预定义的时间间隔向服务器发送 PING。
# 可以使用 repl_ping_replica_period 选项更改此间隔。默认值为 10 秒。
#
# repl-ping-replica-period 10

# 以下选项设置复制超时：
#
# 1) 从复制副本的角度来看，同步期间的批量传输 I/O。
# 2) 从副本（数据、ping）的角度看，主超时。
# 3) 从主服务器的角度看副本超时（REPLCONF ACK Ping）。
#
#
# 务必确保此值大于 repl-ping-replica-period 指定的值，
# 否则每次主服务器和副本服务器之间的通信量较低时都会检测到超时。
#
# repl-timeout 60

# 是否在同步后禁用副本套接字上的 TCP_NODELAY？
#
# 如果设置为 "yes"，Redis 将使用更少的 TCP 包和更少的带宽来发送数据到副本。
# 但是，这会出现同步延迟问题。使用默认配置的 Linux 内核，最高可达 40 毫秒。
#
# 设置为 "no"，数据同步时延迟将会减少，但这会使用更多的带宽。
#
# 默认情况下，我们针对低延迟进行了优化，但在流量非常高的情况下，
# 或者当主节点和副本相差很多时，将其设置为 "yes" 或许是个好主意。
repl-disable-tcp-nodelay no

# 设置复制积压大小。
# backlog 是一个缓冲区，当副本断开一段时间后，会积累副本数据，
# 这样当一个副本想要重新连接时，往往不需要完全重新同步，重新部分同步就可以了，
# 只需传递副本在断开连接时丢失的那部分数据即可。
#
# 复制积压越大，副本重连后同步的时间就越长。
#
# 只有在至少连接一个副本时才会分配积压。
#
# repl-backlog-size 1mb

# 主服务器与副本断开一段时间后，积压的数据将被释放。
# 以下选项配置从上次副本断开连接开始，释放 backlog 缓冲区所需的秒数。
#
# 请注意，副本永远不会因超时而释放积压，因为它们可能在稍后被提升为主服务器，
# 并且应该能够正确地与副本“部分重新同步”：因此，它们应该始终累积积压。
#
# 0 意味着永远不释放
#
# repl-backlog-ttl 3600

# 副本优先级是 Redis 在 INFO 输出中发送的整数。
# 如果主服务器不再正常工作，Redis 哨兵会使用它来选出主服务器。
#
# 优先级较低的副本被认为更适合升级，
# 例如，有三个优先级为 10、100、25 的副本，哨兵将选择优先级为 10 的副本，即最低的。
#
# 优先级为 0，那么将不会被哨兵提升为主服务器。
#
# 默认情况下，优先级为 100
replica-priority 100

# 如果连接的副本少于 N 个，并且延迟小于或等于 M 秒，则主节点可能会停止接受写入。
#
# N 个副本需要处于“在线”状态。
#
# 延迟以秒为单位，必须 <= 指定的值
# 它根据从副本接收到的最后一次 ping 计算得出的，通常每秒发送一次。
#
# 这个选项并不保证 N 个副本将接受写操作，
# 但是在没有足够的副本可用的情况下，会暴露丢失写操作的窗口限制在指定的秒数。
#
# 例如，要求至少 3 个延迟小于等于 10 秒的复制副本，请使用：
#
# min-replicas-to-write 3
# min-replicas-max-lag 10
#
# 将其中一个设置为 0，将禁用该特性。
#
# 默认情况下，min-replicas-to-write 设置为 0（禁用功能），min-replicas-max-lag 设置为 10。

# Redis 主节点能够以不同方式列出附加副本的地址和端口。
# 例如，"INFO replication" 部分提供了此信息，Redis 哨兵使用该信息以及其他工具来发现副本实例。
# 此信息可用的另一个地方是主服务器 "ROLE" 命令的输出。
#
# 副本报告的 IP 和地址通过以下方式获得：
#
#   IP：通过检查副本用于与主服务器连接套接字的对等地址来自动检测地址。
#
#   端口：端口在握手期间由副本通信，通常是副本用于侦听连接的端口。
#
# 但是，当使用端口转发或网络地址转换 (NAT) 时，实际上可以通过不同的 IP 和端口访问副本。
# 副本可以使用以下两个选项来向其主机报告一组特定的 IP 和端口，以便 INFO 和 ROLE 报告这些值。
#
# 如果你只需要覆盖端口或 IP 地址，则不需要同时使用这两个选项。
#
# replica-announce-ip 5.5.5.5
# replica-announce-port 1234

################################## 安全 ###################################

# 要求客户端在处理命令之前发出 AUTH <PASSWORD>。
# 这在你不信任其他人访问 redis-server 主机时很有用。
#
# 为了向后兼容，它应该被注释掉，因为大多数人不需要身份验证（例如，运行在自己的服务器上）。
#
# 警告：由于 Redis 速度非常快，一个外部用户每秒最多可以尝试 15 万个密码。
# 这意味着你应该使用非常强的密码，否则很容易被破解。
#
# requirepass foobared

# 命令重命名。
#
# 可以在共享环境中更改危险命令的名称。
# 例如，CONFIG 命令可能会被重命名为难以猜测的内容，以便仍可以在内部使用，但它不适用于一般客户端。
#
# 示例：
#
# rename-command CONFIG b840fc02d524045429941cc15f59e41cb7be6c52
#
# 也可以通过将命令重命名为空字符串来还原：
#
# rename-command CONFIG ""
#
# 请注意，更改登录到 AOF 文件或传输到副本命令的名称可能会导致问题。

################################### 客户端 ####################################

#
# 设置同时连接的最大客户端数量。默认情况下，此限制设置为 10000 个客户端。
# 如果 Redis 无法将进程文件限制配置为允许的数量，
# 则最大客户端数量将设置为当前文件限制减去 32（因为 Redis 保留了一些文件描述符供内部使用）。
#
# 一旦达到限制，Redis 将关闭所有新连接，并发送错误 'max number of clients reached'（已达到最大客户端数）。
#
# maxclients 10000

############################## 内存管理 ################################

# 限制内存使用为指定的字节数。
# 当达到内存限制时，Redis 将根据选择的驱逐策略尝试删除键（参见 maxmemory-policy）。
#
# 如果 Redis 无法根据策略删除键，或者策略设置为 'noeviction'，
# Redis 会对使用更多内存的命令（如 SET、LPUSH 等）返回错误信息，只读类命令不受影响（像 GET）。
#
# 当使用 Redis 作为 LRU 或 LFU 缓存时，此选项通常很有用，或者为实例设置硬内存限制（使用 'noeviction' 策略）。
#
# 如果将副本附加到具有最大内存的实例上，
# 从使用的内存计数中减去提供副本所需的输出缓冲区的大小，
# 这样，网络问题/重新同步不会触发关键被驱逐的循环，
# 反过来，副本的输出缓冲区已满，删除键的 DEL 会触发删除更多键，
# 依此类推，直到数据库完全清空为止。
#
# 总之……
# 如果附加了副本，建议为 maxmemory 设置一个较低的限制，
# 以便在系统上有一些空闲内存用于副本输出缓冲区（但如果策略是 'noeviction'，则不需要这样做）。
#
# maxmemory 节字

# MAXMEMORY 策略：当达到 maxmemory 时，Redis 将如何选择要删除的内容。
#
# 参见：
# Redis中的LRU淘汰策略分析 https://www.cnblogs.com/linxiyue/p/10945216.html
# Redis的缓存淘汰策略LRU与LFU https://www.jianshu.com/p/c8aeb3eee6bc
#
# 你可以从五种行为中进行选择：
#
# volatile-lru      -> 加入时，从设置了过期时间的集合中，删除最久未使用的内容
# allkeys-lru       -> 加入时，首先通过 LRU 算法删除最久未使用的内容
# volatile-lfu      -> 从所有配置了过期时间的内容中，删除使用频率最少的
# allkeys-lfu       -> 删除使用频率最少的内容
# volatile-random   -> 加入时，从过期键的集合中随机删除
# allkeys-random    -> 加入时，从所有中随机删除
# volatile-ttl      -> 删除快过期的内容
# noeviction        -> 不删除任何内容，只在写入时返回错误。
#
# LRU 意思是 最近使用最少（Least Recently Used）
# LFU 意思是 使用频率最低（Least Frequently Used）
#
# LRU、 LFU 和 volatile-ttl 均采用近似随机算法实现。
#
#
# 注意：在上述任何一种策略下，当没有合适的 key 可以驱逐时，Redis 都会返回写操作错误。
#
# 在编写本文时，这些命令是：
# set setnx setex append incr decr rpush lpush rpushx lpushx linsert lset rpoplpush
# sadd sinter sinterstore sunion sunionstore sdiff sdiffstore zadd zincrby zunionstore
# zinterstore hset hsetnx hmset hincrby incrby decrby getset mset msetnx exec sort
#
# 默认的是：
#
# maxmemory-policy noeviction

# LRU、LFU 和最小 TTL 算法不是精确算法而是近似算法（为了节省内存），因此你可以对其进行调整以提高速度或准确性。
# 对于默认 Redis 将检查五个键并选择最近使用较少的一个，你可以使用以下配置指令更改样本大小。
#
# 默认值 5 会产生足够好的结果。
# 10 非常接近真实的 LRU，但花费更多的 CPU。3 更快，但不是很准确。
#
# maxmemory-samples 5

# 从 Redis 5 开始，默认情况下，副本将忽略其 maxmemory 设置（除非在故障转移后或手动将其提升为主）。
# 这意味着密钥的驱逐将仅由主控方处理，将 DEL 命令发送到副本作为主控方的密钥驱逐。
#
# 这种行为确保主副本和副本保持一致，这通常是您想要的，但是如果您的副本是可写的，
# 或者您希望副本具有不同的内存设置，并且你确定对副本执行的所有写入都是幂等的，
# 你可以改变这个默认值（但一定要了解你在做什么）。
#
# 请注意，默认情况下副本不会驱逐，因此它最终可能会使用比通过 maxmemory 设置的内存更多的内存（副本上的某些缓冲区可能更大，
# 或者数据结构有时可能会占用更多内存等等）。因此，请确保监控的副本并确保它们有足够的内存，
# 以免在主服务器达到配置的 maxmemory 设置之前遇到真正的内存不足情况。
#
# replica-ignore-maxmemory yes

############################# 惰性删除 ####################################

# Redis有两个基本的删除键。
# 一个是 DEL，它是对象的阻塞删除。这意味着服务器停止处理新命令，以便以同步方式回收与对象关联的所有内存。
# 如果删除的键与一个小对象相关联，执行 DEL 命令所需的时间非常小，可以与 Redis 中的大多数其他 O(1) 或 O(log_N) 命令相媲美。
# 但是，如果键与包含数百万个元素的聚合值相关联，服务器可能会阻塞很长时间（甚至几秒）以完成操作。
#
# 基于上述原因，Redis 还提供了非阻塞删除，如 UNLINK（非阻塞 DEL）、FLUSHALL 和 FLUSHDB 命令的 ASYNC 选项，以便在后台回收内存。
# 这些命令在固定时间内执行。另一个线程将在后台以尽可能快的速度逐步释放该对象。
#
# FLUSHALL 和 FLUSHDB 的 DEL、UNLINK 和 ASYNC 选项是用户控制的。
# 由应用程序的设计来了解何时使用一种或另一种是个好主意。
# 然而，Redis 服务器有时不得不删除键或刷新整个数据库作为其他操作的副作用。
# 具体来说，Redis 在以下场景中独立于用户调用删除对象：
#
# 1) 在删除时，由于 maxmemory 和 maxmemory 策略配置，以便为新数据腾出空间，而不会超过指定的内存限制。
# 2) 因为过期：当一个键具有关联的生存时间（请参阅 EXPIRE 命令）必须从内存中删除。
# 3) 由于将数据存储在可能已经存在的键上的命令的副作用。
#    例如，RENAME 命令可能会在旧密钥内容被另一个内容替换时删除旧密钥内容。
#    同样，带有 STORE 选项的 SUNIONSTORE 或 SORT 可能会删除现有的键。
#    SET 命令本身删除指定键的任何旧内容，以便用指定的字符串替换它。
# 4) 在复制期间，当副本与其主服务器执行完全重新同步时，整个数据库的内容将被删除，以便加载刚刚传输的 RDB 文件。
#
# 在上述所有情况下，默认是以阻塞方式删除对象，就像调用 DEL 一样。
# 但是，你可以使用以下配置指令专门配置每种情况，以便以非阻塞方式释放内存，就像调用 UNLINK 一样：

lazyfree-lazy-eviction no
lazyfree-lazy-expire no
lazyfree-lazy-server-del no
replica-lazy-flush no

############################## 仅附加模式 ###############################
#
# 参考：
# 搞懂Redis RDB和AOF持久化及工作原理 https://www.cnblogs.com/GrimMjx/p/10695512.html
# Redis配置数据持久化---APPEND ONLY MODE https://blog.csdn.net/ljl890705/article/details/51039015
#
# Redis 默认采用异步的方式将数据存放到磁盘上，这个模式对大部份应用来说是足够好的，
# 但是在 Redis 进程或电源发生故障的情况下，可能会造成小部份的数据丢失，这取决于配置的保存时间点。
#
# Appendonly 是一种能够提供非常好的持久化的模式，例如使用默认的 Fsync 方案，
# Redis 能在发生服务器电源故障或操作系统仍然正常运行但 Redis 进程莫名挂掉的情况下，只丢失1秒的数据。
#
# AOF 与 RDB 模式可以同时启用，这并不冲突。如果 AOF 是可用的，那 Redis 启动时将自动加载 AOF，这个文件能够提供更好的持久性保障。
#
# 更多信息请访问 http://redis.io/topics/persistence

appendonly no

# 文件名称（默认："appendonly.aof"）

appendfilename "appendonly.aof"

# fsync() 调用告诉操作系统将数据真实的写入磁盘而不是放到缓冲区中，一些操作系统会真实的执行请求，还有一些操作系统只会尽力的尝试。

# Redis 支持3种不同的模式：
# no：不即时同步，由操作系统控制何时刷写到磁盘上，这种模式速度最快；
# always：每次只写日志，速度较慢，但最安全；
# everysec：每秒钟同步一次，折中的方案。
#
# 默认的模式是 "everysec"，它通常是在速度和数据安全之间折中的方法。
# 如果你可以控制操作系统在 Redis 需要的时候去刷写缓冲区那可以使用 "no" 模式，
# 能够提供更好的性能（但如果你能接受一些数据丢失，可以考虑默认的持久化模式–快照方式），
# 相反，使用 "always" 模式很慢，但是它比 "everysec" 模式要安全一点。
#
#
# 更多详情请查看以下文章:
# http://antirez.com/post/redis-persistence-demystified.html
# 中文：
# https://www.cnblogs.com/hanhuilee/p/5221306.html
# https://www.cnblogs.com/hanhuilee/p/5221305.html
#
# 如果不确定，就使用 "everysec"。

# appendfsync always
appendfsync everysec
# appendfsync no

# 当使用 AOF 的 fsync 方案设置为 "always" 或 "everysec" 时，
# 后台的存储进程会执行大量的磁盘 I/O 操作，在一些 Linux 架构中，Redis 在 fsync() 调用时可能会阻塞很久。
# 这个问题当前并没有修复，即使是在一个不同的线程执行 fsync 也将会阻塞我们的同步写调用。
#
# 为了缓解这个问题，可以使用以下选项，它将会在有一个 BGSAVE 或 BGREWRITEAOF 正在运行时，阻止主进程调用 fsync()。
#
# 这意味着有另一个子进程在存储时，Redis 的持久性等同于 "appendfsync none"。
# 在实践中，意味着在最坏的情况下它可能丢失多达30秒的日志（默认的 Linux 设置）。

# 如果你有潜在的问题需要更改它为 "yes"。否则从持久性的观点来看 "no" 是最安全的选择。

no-appendfsync-on-rewrite no

# 自动重写 append only 文件。
# 当 AOF 日志的大小根据指定的百分比增长时，Redis 会暗中调用 BGREWRITEAOF 去自动重写日志文件。
#
# 工作原理：Redis 记忆 AOF 文件最后一次重写的大小（如果重启后没有重写发生，AOF 的大小在启动时会被使用）。
#
# 基本大小对比当前大小。如果当前大小比指定的百分比大，触发重写。
# 并且你要为 AOF 文件指定一个最小的尺寸去重写，这对于避免重写 AOF 文件是有用的，即使达到了百分比增长率但它仍然是非常小的。

# 指定百分比为0以便禁用自动 AOF 重写。

auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb

# 可能发现一个 AOF 文件在 Redis 启动过程中被截断，当 AOF 数据被加载回内存时。
# 这可能发生在系统中 Redis 运行崩溃，尤其是挂载一个 EXT4 文件系统而没有使用 "data=ordered" 选项时
#（但是这不会发生在 Redis 自身崩溃或中断而操作系统仍然正常运行的时候）。

# 当有一个错误发生时 Redis 要么退出，要么加载尽可能多的数据（当前默认）启动，如果 AOF 文件最后发现被截断。以下选项控制这个行为。

# 如果 aof-load-truncated 被设置为 "yes"，一个被截断的 AOF 文件将会被加载，
# Redis 服务启动发出一个日志告知用户这个事件。如果这个选项设置为 "no"，服务器中止一个错误并拒绝启动。
# 当选项被设置为 "no"，用户需要在重启服务之前使用 "redis-check-aof" 功能确定 AOF 文件。
#
# 需要注意的是如果 AOF 文件被发现是损坏的，那服务器仍然会以一个错误退出。
# 这个选项仅适用于 Redis 希望读取更多的数据但是没有发现足够的字节时。
aof-load-truncated yes

# 在重写 AOF 文件时，Redis 能够使用 AOF 文件中的 RDB 前导码来加快重写和恢复速度。
# 当这个选项打开时，重写的 AOF 文件由两个不同的部分组成：
#
#   [RDB file][AOF tail]
#
# 加载 Redis 时识别到 AOF 文件以 "REDIS" 字符串开头，加载带前缀的 RDB 文件，继续加载 AOF 尾部。
aof-use-rdb-preamble yes

################################ LUA 脚本  ###############################
# Redis使用Lua脚本 https://www.cnblogs.com/kaituorensheng/p/11098194.html

# Lua 脚本最大执行时间（以毫秒计）
#
# 如果达到最大执行时间 Redis 将记录，脚本仍在执行中，并回复带有错误的查询。
#
# 当脚本超过最大执行时间时，只有 SCRIPT KILL 和 SHUTDOWN NOSAVE 命令可用。
# 第一个可用于停止尚未调用写入命令的脚本。
# 第二个是在脚本已经发出写入命令但用户不想等待脚本自然终止的情况下关闭服务器的唯一方法。
#
# 将其设置为 0 或负值，表示无限执行且没有警告。
lua-time-limit 5000

################################ REDIS 集群 ###############################
# Redis集群以及自动故障转移测试 https://www.cnblogs.com/wy123/p/10325904.html
# Redis 源码分析之故障转移 https://segmentfault.com/a/1190000018141929

# 普通 Redis 实例不能成为 Redis 集群的一部分；只有作为集群启动的节点才可以。
# 要将 Redis 实例作为集群节点启动，请启用集群支持，取消注释以下内容：
#
# cluster-enabled yes

# 每个集群节点都有一个集群配置文件。此文件不适合手动编辑。它由 Redis 节点创建和更新。
# 每个 Redis 集群节点都需要不同的配置文件。
# 确保在同一系统中运行的实例没有重叠的集群配置文件名。
#
# cluster-config-file nodes-6379.conf

# 集群节点超时，指节点无法访问达到指定毫秒数，则视为处于故障状态。
# 大多数内部时间限制是节点超时的倍数。
#
# cluster-node-timeout 15000

# 发生故障的副本将避免在其数据看起来太旧时启动故障转移。
#
# 副本没有简单的方法来判定太旧，因此通过以下两项检查：
#
# 1) 如果有多个副本能够进行故障转移，它们就会交换消息，
#    以尽量使副本具有最好的复制偏移量（处理更多来自主服务器的数据）。
#
# 2) 每个副本都要计算与主节点最后一次交互的时间。
#    这可以是收到的最后一个 ping 或命令（如果主服务器仍处于“已连接”状态），
#    或者与主服务器断开连接后经过的时间（如果复制链接当前已关闭）。
#    如果上次交互太旧，副本将根本不会尝试进行故障转移。
#
# 用户可以调整第 2 项。
# 具体来说，如果自上次与主服务器交互以来，经过的时间大于以下时间，则副本将不会执行故障转移：
#
#   (node-timeout * replica-validity-factor) + repl-ping-replica-period
#
# 如 node-timeout（节点超时）为 30 秒，replica-validity-factor（副本有效性因子）为 10，并假设默认的 repl-ping-replica-period（副本 ping 间隔）为 10 秒，
# 则副本服务器无法与主服务器进行超过 310 秒的通信，则不会尝试故障转移。
#
# 较大的 replica-validity-factor（副本有效性因子）可能允许具有太旧数据的副本对主服务器进行故障转移，
# 而过小的值可能会阻止集群能够选择一个副本。
#
# 为了获得最大可用性，可以将 replica-validity-factor（副本有效性因子）设置为 0，
# 这意味着副本将始终尝试对主服务器进行故障转移，无论它们上次与主服务器交互的时间如何。
# （但是，他们总是会尝试应用与其偏移等级成正比的延迟）。
#
# 0 是唯一能够保证当所有分区恢复时集群将始终能够继续运行的值。
#
# cluster-replica-validity-factor 10

# 群集副本可以迁移到孤立的主服务器，即没有工作副本的主服务器。
# 这提高了集群抵御故障的能力，否则，如果孤立的主服务器没有工作副本，则在发生故障时不能进行故障转移。
#
# 只有当它们的旧主节点仍有给定数量的副本时，副本才会迁移到孤立的主节点。
# 这个数字就是 "migration barrier"（障碍迁移）。1 意味着副本只有在其主副本至少有 1 个时才会迁移，
# 依此类推。它通常反映了集群中每个主节点所需的副本数量。
#
# 默认值为 1（副本仅在其主节点保留至少一个副本时才迁移）。
# 要禁用迁移，只需将其设置为一个非常大的值。
# 可以设置 0 ，但仅用于调试并且在生产中存在风险。
#
# cluster-migration-barrier 1

# 默认情况下，如果 Redis 集群节点检测到至少有一个哈希槽未被覆盖（没有可用的节点为其提供服务），它们将停止接受查询。
# 这样，如果集群部分关闭（例如不再覆盖一定范围的哈希槽），所有集群最终都将变得不可用。
# 一旦所有插槽再次被覆盖，它就会自动返回可用。
#
# 但是，有时你需要正在工作集群的子集，继续接受对覆盖密钥空间部分的查询。
# 为此，只需将 cluster-require-full-coverage 选项设置为 no。
#
# cluster-require-full-coverage yes

# 此选项设置为 yes 时，可防止副本服务器在主服务器故障期间尝试对其主服务器进行故障转移。
# 但是，如果强制执行，主服务器仍然可以执行手动故障转移。
#
# 这在不同的场景中很有用，尤其是在多个数据中心操作的情况下，
# 如果不是在完全 DC 故障的情况下，我们希望一方永远不会被提升。
#
# cluster-replica-no-failover no

# 关于集群设置，请务必阅读 http://redis.io 网站提供的文档。

########################## 集群 DOCKER/NAT 支持  ########################

# 在某些部署中，Redis 群集节点地址发现失败，因为地址是 NAT 的，或者端口是转发的（典型情况是 Docker 和其他容器）。
#
# 为了让 Redis Cluster 在这样的环境中工作，需要一个静态配置，每个节点都知道自己的公共地址。
# 以下两个选项用于此范围，它们是：
#
# * cluster-announce-ip
# * cluster-announce-port
# * cluster-announce-bus-port
#
# 每个都向节点指示其地址、客户端端口和集群消息总线端口。
# 然后在总线数据包的报头中发布信息，以便其他节点能够正确映射发布信息的节点地址。
#
# 如果不使用上述选项，则将使用 Redis Cluster 自动检测。
#
# 请注意，重新映射时，总线端口可能不在客户端端口 + 10000 的固定偏移处，
# 因此你可以使用重新映射的方式指定任何端口和总线端口。
# 如果未设置总线端口，则使用固定端口号 + 10000。
#
# 示例：
#
# cluster-announce-ip 10.1.1.5
# cluster-announce-port 6379
# cluster-announce-bus-port 6380

################################## 慢日志 ###################################

# Redis 慢日志是一种记录查询时间超时的系统。执行时间不包括与客户端交互、发送回复等 I/O 操作，
# 但只是实际执行命令所需的时间（这是命令执行的唯一阶段，线程被阻塞并且在此期间无法为其他请求提供服务）。
#
# 你可以使用两个参数配置慢日志：一个告诉 Redis 超时时间是多少，以微秒为单位，以便命令被记录，
# 另一个参数是慢日志的长度。当记录新命令时，从记录命令队列中删除最旧的命令。

# 单位：微秒。所以 1000000 相当于一秒。
# 请注意，负数会禁用日志，而零值会强制记录每个命令。
slowlog-log-slower-than 10000

# 这个长度没有限制。请注意，它会消耗内存。
# 你可以使用 SLOWLOG RESET 回收慢日志使用的内存。
slowlog-max-len 128

################################ 延迟监视 ##############################

# Redis 延迟监控子系统在运行时对不同的操作进行采样，以收集与 Redis 实例的相关数据。
#
# 通过 LATENCY 命令，用户可以使用这些信息来打印图形和获取报告。
#
# 系统只记录大于等于 delay-monitor-threshold 指定的毫秒内执行的操作。
# 当设置为零时，延迟监视关闭。
#
# 默认情况下，延迟监控是禁用的，因为如果没有延迟问题，它通常不需要；
# 并且收集数据对性能有影响，虽然非常小，但可以在大负载下进行测量。
# 如果需要，可以在运行时使用命令 "CONFIG SET latency-monitor-threshold <毫秒>" 轻松启用延迟监控。
latency-monitor-threshold 0

############################# 事件通知 ##############################
# Redis事件通知 https://www.cnblogs.com/tangxuliang/p/10659439.html
# 键空间通知http://redisdoc.com/topic/notification.html
#
# Redis 可以通知发布/订阅客户端在 keyspace 事件。
# 该特性的文档在 http://redis.io/topics/notifications 上
#
# 如，启用了 keyspace 事件通知，客户端对存储在数据库0中的 "foo" 执行 DEL 操作，则会发送消息到发布/订阅上：
#
# PUBLISH __keyspace@0__:foo del
# PUBLISH __keyevent@0__:del foo
#
# 可以从一组类中选择 Redis 将通知的事件。每个类都由单个字符标识：
#
#  K     Keyspace 事件，使用 __keyspace@<db>__ 前缀发布。
#  E     关键事件，使用 __keyevent@<db>__ 前缀发布。
#  g     通用命令（非特定于类型），如 DEL、EXPIRE、RENAME...
#  $     String 命令
#  l     List 命令
#  s     Set 命令
#  h     Hash 命令
#  z     Sorted set 命令
#  x     过期事件（每次键过期时生成的事件）
#  e     逐出事件（为 maxmemory 逐出键时生成的事件）
#  A     g$lshzxe 的别名，因此 "AKE" 字符串表示所有事件。
#
#  "notify-keyspace-events" 将一个由零个或多个字符组成。
#  空字符串表示禁用通知。
#
#  示例：要启用列表和通用事件，从事件名称的角度来看，使用：
#
#  notify-keyspace-events Elg
#
#  示例2：
#  获取订阅频道名称 __keyevent@0__: 的过期键：
#
#  notify-keyspace-events Ex
#
# 默认情况下，所有通知都被禁用，因为大多数用户不需要此功能并且该功能有一些开销。
# 请注意，如果您没有指定 K 或 E 中的至少一个，则不会传递任何事件。
notify-keyspace-events ""

############################### 高级配置 ###############################

# 当散列具有少量条目并且最大条目不超过给定阈值时，使用内存高效的数据结构对哈希进行编码。
# 可以使用以下指令配置这些阈值。
hash-max-ziplist-entries 512
hash-max-ziplist-value 64

# 列表以特殊方式编码可以节省大量空间。
# 每个内部列表节点允许的条目数可以指定为固定大小或最大元素数。
# 对于固定的最大大小，使用 -5 到 -1，意思是：
# -5: 最大： 64 Kb  <-- 不推荐用于正常的工作负载
# -4: 最大： 32 Kb  <-- 不推荐
# -3: 最大： 16 Kb  <-- 可能不推荐使用
# -2: 最大： 8 Kb   <-- 推荐
# -1: 最大： 4 Kb   <-- 推荐
# 正数意味着每个列表节点最多存储 _exactly_ 元素数量。
# 性能最高的选项通常是 -2（8 Kb 大小）或 -1（4 Kb 大小），
# 但如果你的用例是独一无二的，请根据需要调整设置。
list-max-ziplist-size -2

# 列表也可以被压缩。
# 压缩深度是从列表的 *每一* 侧到 *排除* 压缩的 quicklist ziplist 节点的数量。
# 对于快速推送/弹出操作，列表的头部和尾部总是未压缩的。设置是：
# 0: 禁用所有列表压缩
# 1: 深度 1 表示“直到 1 个节点进入列表后才开始压缩，从头部或尾部开始”
#    所以：[头]->结点->结点->...->结点->[尾]
#    [头], [尾] 将始终未压缩；内部节点会压缩。
# 2: [头]->[下]->结点->结点->...->结点->[上]->[尾]
     指的是：不要压缩 [头] 或 [头]>[下] 或 [尾]->[上] 或 [尾]，而是压缩它们之间的所有节点。
# 3: [头]->[下]->[下]->结点->结点->...->结点->[上]->[上]->[尾]
# 等等
list-compress-depth 0

# 在一种情况下，集合是一种特殊编码：当一个集合恰好是 64 位有符号整数范围内基数为 10 的整数组成的字符串时。
#
# 以下配置设置设置了集合大小的限制，以便使用这种特殊的内存节省编码。
set-max-intset-entries 512

# 与散列和列表类似，排序集合也经过特殊编码以节省大量空间。仅当排序集合的长度和元素低于以下限制时才使用此编码：
zset-max-ziplist-entries 128
zset-max-ziplist-value 64

# HyperLogLog 稀疏表示字节限制。限制包括 16 字节的头。
# 当使用稀疏表示的 HyperLogLog 超过这个极限时，它被转换为稠密表示。

# 大于 16000 的值是完全无用的，因为在那一点上，密集表示的内存效率更高。
#
# 建议的值为 3000，以便在不降低 PFADD 太多速度的情况下获得空间有效编码，而稀疏编码的 PFADD 为 O(N)。
# 当不考虑 CPU 而考虑空间时，该值可以提高到 10000，且数据集由许多 HyperLogLogs 组成，基数在 0 - 15000 之间。
hll-sparse-max-bytes 3000

# 流宏节点数量。
# 流数据结构是一个大节点的基数树，其中对多个项目进行编码。
# 使用此配置，可以配置单个节点的大小（以字节为单位），以及在附加新流条目时切换到新节点之前它可能包含的最大项目数。
# 如果以下任何设置设置为零，则该限制将被忽略；例如可以通过将 max-bytes 设置为 0 并将 max-entries 设置为所需值来仅设置最大整数限制。
stream-node-max-bytes 4096
stream-node-max-entries 100

# Redis 每 100 毫秒 CPU 时间使用 1 毫秒，以重新 hash（将顶级键映射到值）。
# Redis 使用哈希表（参见 dict.c）执行惰性哈希：hash 操作越多，重新计算“步骤”也越多，
# 如果服务器空闲，hash 永远不会完成，它使用更多的内存。
#
# 默认值是每秒钟使用 10 毫秒，以便主动重新散列主字典，尽可能释放内存。
#
# 如果不确定:
# 当你的使用场景中，有非常严格的实时性需要，
# 不能够接受 Redis 时不时的对请求有 2 毫秒的延迟的话，把这项配置为 no。
# 如果没有这么严格的实时性要求，可以设置为 yes，以便能够尽可能快的释放内存。

activerehashing yes

# 客户端输出缓冲区限制可用于强制断开由于某些原因而导致从服务器读取数据的速度不够快的客户端。
# 一个常见原因是发布/订阅客户端无法以发布者生成消息的速度使用消息。
#
# 可以为三种不同类别的客户端设置不同的限制：
#
# 普通 -> 普通客户端，包括监视器客户端。
# 复制副本 -> 复制副本客户端。
# 订阅了至少一个发布订阅频道或模式的发布订阅客户端
#
# 每个 CLIENT-OUTPUT-BUFFER-LIMIT 指令的语法如下：
#
# client-output-buffer-limit <类> <硬限制> <软限制> <秒数>
#
# 一旦达到硬限制，或者达到软限制并保持达到指定的秒数（连续），客户端将立即断开连接。
# 例如，如果硬限制是 32M 字节，软限制是 16M 字节/10秒，
# 如果输出缓冲区的大小达到 32M 字节，客户端将立即断开连接，但如果客户端达到 16M 字节并连续超过限制 10 秒，也会断开连接。
#
# 默认情况下，普通客户端不受限制，因为它们不会在不询问的情况下（以推送方式）接收数据，而是在请求之后，
# 因此只有异步客户端可能会创建请求数据比读取数据更快的场景。
#
# 相反，发布订阅和副本客户端有一个默认限制，因为订阅者和副本以推送方式接收数据。
#
# 硬限制或软限制都可以通过将它们设置为零来禁用。
client-output-buffer-limit normal 0 0 0
client-output-buffer-limit replica 256mb 64mb 60
client-output-buffer-limit pubsub 32mb 8mb 60

# 客户端查询缓冲区会累积新命令。
# 默认情况下，它们被限制为固定数量，以避免协议不同步（例如由于客户端中的错误）将导致查询缓冲区中未绑定的内存使用。
# 但是，如果有非常特殊的需求，例如巨大的 multi/exec 请求或类似需求，你可以在此处配置它。
#
# client-query-buffer-limit 1gb

# 在 Redis 协议中，批量请求，即表示单个字符串的元素，通常限制为 512 mb。
# 但是，你可以在此处更改限制。
#
# proto-max-bulk-len 512mb

# Redis 调用一个内部函数来执行后台任务，例如超时关闭客户端的连接，清除从未请求过的过期键，等等。
#
# 并非所有任务都以相同的频率执行，但 Redis 会根据指定的 "hz" 值检查要执行的任务。
#
# 默认情况下，"hz" 设置为 10。提高该值将在 Redis 空闲时使用更多 CPU，
# 但同时会让 Redis 在有许多键同时过期时更灵敏，并且可以更精确地处理超时。
#
# 范围在 1 到 500 之间，但是超过 100 的值通常不是一个好主意。
# 大多数用户应该使用默认值 10，并仅在需要极低延迟的环境中将其提高到 100。
hz 10

# 通常，拥有一个连接客户端数量成正比的 HZ 值是有用的。
# 例如，这对于每个后台任务调用处理太多客户端以避免延迟峰值非常有用。
#
# 由于默认的 HZ 值保守地设置为 10，Redis 提供并默认启用使用自适应 HZ 值的能力，
# 当有很多连接的客户端时，这将暂时提高。
#
# 启用动态 HZ 时，实际配置的 HZ 将用作基线，
# 但一旦连接更多客户端，将根据需要实际使用配置 HZ 值的倍数。
# 通过这种方式，空闲实例将使用很少的 CPU 时间，而繁忙的实例将响应更快。
dynamic-hz yes

# 当重写 AOF 文件时，如果启用以下选项，则文件将每生成 32 MB 数据进行 fsync-ed。
# 这对于以增量方式将文件提交到磁盘并避免大的延迟峰值很有用。
aof-rewrite-incremental-fsync yes

# Redis 保存 RDB 文件时，如果启用以下选项，文件将每生成 32 MB 数据进行 fsync-ed。
# 这对于以增量方式将文件提交到磁盘并避免大的延迟峰值很有用。
rdb-save-incremental-fsync yes

# 可以调整 Redis LFU 驱逐（请参阅 maxmemory 设置）。
# 但是，最好从默认设置开始，仅在研究如何提高性能以及按键 LFU 如何随时间变化后才更改它们，
# 这可以通过 OBJECT FREQ 命令进行检查。
#
# Redis LFU 实现中有两个可调参数：计数器对数因子和计数器衰减时间。
# 在更改这两个参数之前，了解这两个参数的含义很重要。
#
# LFU 计数器每个键只有 8 位，最大值为 255，因此 Redis 使用具有对数行为的概率增量。
# 给定旧计数器的值，当访问一个键时，计数器以这种方式递增：
#
# 1. 抽取一个介于 0 和 1 之间的随机数 R。
# 2. 概率 P 计算为 1/(old_value*lfu_log_factor+1)。
# 3. 计数器仅在 R < P 时递增。
#
# 默认的 lfu-log-factor 为 10。这是一个表，说明频率计数器如何随着不同对数因子的不同访问次数而变化：
#
# +--------+------------+------------+------------+------------+------------+
# | 因子   | 100 次     | 1000 次    | 10万次     | 1百万次      | 1千万次  |
# +--------+------------+------------+------------+------------+------------+
# | 0      | 104        | 255        | 255        | 255        | 255        |
# +--------+------------+------------+------------+------------+------------+
# | 1      | 18         | 49         | 255        | 255        | 255        |
# +--------+------------+------------+------------+------------+------------+
# | 10     | 10         | 18         | 142        | 255        | 255        |
# +--------+------------+------------+------------+------------+------------+
# | 100    | 8          | 11         | 49         | 143        | 255        |
# +--------+------------+------------+------------+------------+------------+
#
# 注意：上表是通过运行以下命令获得的：
#
#   redis-benchmark -n 1000000 incr foo
#   redis-cli object freq foo
#
# 注2：计数器的初始值是 5，以便为新对象提供累积命中的机会。
#
# 计数器衰减必须经过的时间，以分钟为单位，
# 以便将关键计数器除以 2（或者如果它的值小于 <= 10，则递减）。
#
# lfu-decay-time 的默认值是 1。一个特殊的值 0，表示每次碰巧被扫描时衰减计数器。
#
# lfu-log-factor 10
# lfu-decay-time 1

########################### 主动碎片整理 #######################
# 参见：
# 玩转Redis-删除了两百万key，为什么内存依旧未释放？ https://blog.csdn.net/xiaomanong123/article/details/109058827
# Redis性能篇（四）Redis内存碎片 https://www.cnblogs.com/liang24/p/14232890.html
#
# 警告此功能是实验性的。
# 甚至在生产中也进行了压力测试，并由多名工程师手动测试了一段时间。
#
# 什么是主动碎片整理？
# -------------------------------
#
# 碎片整理允许 Redis 服务器压缩内存中数据分配和释放之时留下的空间，
# 从而允许回收内存。
#
# 分片是每个分配器（但幸运的是 Jemalloc 较少）和某些工作负载发生的自然过程。
# 通常需要重新启动服务器以减少碎片，或者至少清除所有数据并重新创建它。
# 然而，由于 Oran Agra 为 Redis 4.0 实现的这个功能，
# 这个过程可以在运行时以“热”方式发生，而服务器正在运行。
#
# 基本上，当碎片超过一定程度时（请参阅下面的配置选项），
# Redis 将开始通过利用某些特定的 Jemalloc 功能在连续内存区域中创建值的新副本
#（以便判断是否导致碎片并分配它在一个更好的地方），同时，将释放数据的旧副本。
# 这个过程，对所有键递增重复，将导致碎片回落到正常值。
#
# 需要了解的重要事项：
#
# 1. 默认情况下，此功能处于禁用状态，并且仅当编译 Redis 以使用我们随 Redis 源代码一起提供的 Jemalloc 副本时才有效。
#    这是 Linux 构建的默认设置。
#
# 2. 如果没有碎片问题，则永远不需要启用此功能。
#
# 3. 一旦遇到碎片，你可以在需要时使用命令 "CONFIG SET activedefrag yes" 启用此功能。
#
# 配置参数能够微调碎片整理过程的行为。
# 如果不确定它们的含义，最好保持默认值。

# 启用主动碎片整理
# activedefrag yes

# 内存碎片的字节数达到 100MB 时开始整理
# active-defrag-ignore-bytes 100mb

# 内存碎片空间占操作系统分配给 Redis 的总空间比例达到 10% 时，开始整理
# active-defrag-threshold-lower 10

# 内存碎片超过 100%，则尽最大努力整理
# active-defrag-threshold-upper 100

# 整理时最低占用 CPU（百分比）
# active-defrag-cycle-min 5

# 整理时最高占用 CPU（百分比）
# active-defrag-cycle-max 75

# 碎片整理扫描时，仅当 set/hash/zset/list 的长度小于此阀值时，才会将此 key 加入碎片整理
# active-defrag-max-scan-fields 1000

# 相关：
# redis 常见配置/操作及注意事项 https://www.cnblogs.com/fanggege/p/10315227.html
# redis配置文件详解 https://www.cnblogs.com/pqchao/p/6558688.html
# 吊打面试官系列：Redis 性能优化的 13 条军规大全 https://www.cnblogs.com/a609251438/p/12751828.html
# Redis 命令参考 http://redisdoc.com/index.html
# Redis 缓存雪崩、击穿、穿透 https://segmentfault.com/a/1190000022029639
# REDIS缓存穿透，缓存击穿，缓存雪崩原因+解决方案 https://www.cnblogs.com/xichji/p/11286443.html
# Redis 的高级应用 https://www.cnblogs.com/abeam/p/14724005.html