Redis

1 Redis简介

Redis 是完全开源的，遵守 BSD 协议，是一个高性能的 key-value 数据库。

Redis 与其他 key - value 缓存产品有以下三个特点：

• Redis支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。
• Redis不仅仅支持简单的key-value类型的数据，同时还提供list，set，zset，hash等数据结构的存储。
• Redis支持数据的备份，即master-slave模式的数据备份。

2 Redis特性优势

• 性能极高 – Redis能读的速度是110000次/s,写的速度是81000次/s 。
• 持久化 - 存在脑子里的知识可能忘记丢失，持久化存储到硬盘的数据才相对于最稳定。
• 丰富的数据类型 – Redis支持二进制的 Strings, Lists, Hashes, Sets 及 Sorted Sets 数据类型操作。
• 原子 – Redis的所有操作都是原子性的，意思就是要么成功执行要么失败完全不执行。单个操作是原子性的。多个操作也支持事务，即原子性，通过MULTI和EXEC指令包起来。
• 丰富的特性 – Redis同样也支持事务、流水线、发布/订阅、消息队列功能。
• 高可用以及分布式 - 主从配置简单，容易上手。可以提供基本的数据备份。在3.0以后的版本中，还提供了分布式的功能。

什么是原子性,什么是原子性操作？
举个例子：
A想要从自己的帐户中转1000块钱到B的帐户里。那个从A开始转帐，到转帐结束的这一个过程，称之为一个事务。在这个事务里，要做如下操作：
1. 从A的帐户中减去1000块钱。如果A的帐户原来有3000块钱，现在就变成2000块钱了。
2. 在B的帐户里加1000块钱。如果B的帐户如果原来有2000块钱，现在则变成3000块钱了。
如果在A的帐户已经减去了1000块钱的时候，忽然发生了意外，比如停电什么的，导致转帐事务意外终止了，而此时B的帐户里还没有增加1000块钱。那么，我们称这个操作失败了，要进行回滚。回滚就是回到事务开始之前的状态，也就是回到A的帐户还没减1000块的状态，B的帐户的原来的状态。此时A的帐户仍然有3000块，B的帐户仍然有2000块。
我们把这种要么一起成功（A帐户成功减少1000，同时B帐户成功增加1000），要么一起失败（A帐户回到原来状态，B帐户也回到原来状态）的操作叫原子性操作。
如果把一个事务可看作是一个程序,它要么完整的被执行,要么完全不执行。这种特性就叫原子性。

2.1 Redis应用场景

1.缓存 - 键过期时间

缓存session会话；缓存用户信息，找不到再去Mysql查，查到然后回写到Redis；优惠券过期时间；

2.排行榜 - 列表 & 有序集合

热度排名排行榜

发布时间排行榜

3.计数器应用 - 天然支持计数器

帖子浏览数

视频播放次数

商品浏览数

4.社交网络 - 集合

踩/赞，粉丝，共同好友/喜好，推送

5.消息队列系统 - 发布订阅

配合ELK实现日志收集

3 Redis与其他key-value存储有什么不同？

• Redis有着更为复杂的数据结构并且提供对他们的原子性操作，这是一个不同于其他数据库的进化路径。Redis的数据类型都是基于基本数据结构的同时对程序员透明，无需进行额外的抽象。
• Redis运行在内存中但是可以持久化到磁盘，所以在对不同数据集进行高速读写时需要权衡内存，因为数据量不能大于硬件内存。在内存数据库方面的另一个优点是，相比在磁盘上相同的复杂的数据结构，在内存中操作起来非常简单，这样Redis可以做很多内部复杂性很强的事情。同时，在磁盘格式方面他们是紧凑的以追加的方式产生的，因为他们并不需要进行随机访问。

4 Redis安装

下载并安装

wget http://download.redis.io/releases/redis-5.0.2.tar.gz
tar xzf redis-5.0.2.tar.gz
ln -s redis-5.0.2 redis
cd redis
make （解释：编译redis源码）

遇到问题【adlist.o】Error 127

由于Redis是C语言开发的，因此需要安装gcc编译器来编译代码，我们下载的Redis包里面是源代码，需要编译：

# 需要安装gcc
yum install gcc -y

然后再次make，又遇问题

请重新解压出Redis文件然后再次编译

安装成功之后，启动redis，并查看端口

# cd src
# ./redis-server &
# ss -lntp|grep 6379
LISTEN     0      128          *:6379                     *:*                   users:(("redis-server",pid=8990,fd=7))
LISTEN     0      128       [::]:6379                  [::]:*                   users:(("redis-server",pid=8990,fd=6))

进入redis

[root@mysql-65 redis-6.0.9]# ./redis-cli 
127.0.0.1:6379>

编辑redis服务启动文件

#1、创建redis用户并授权
[root@centos7 ~]# useradd -M -s /sbin/nologin redis
#2、创建目录和redis配置文件
[root@mysql-65 6379]# mkdir -p /data/6379/
[root@centos7 ~]# chown -R redis:redis /data/6379/ #注意目录权限
[root@mysql-65 6379]# cp -a /usr/local/redis/redis.conf /data/6379/
#3、编辑redis服务启动文件
[root@mysql-65 6379]# cat /usr/lib/systemd/system/redis.service 
[Unit]
Description=Redis
After=network.target
[Service]
Type=forking
ExecStart=/usr/local/redis/src/redis-server /data/6379/redis.conf
ExecReload=/bin/kill -s HUP $MAINPID
ExecStop=/usr/local/redis/src/redis-cli shutdown
User=redis
Group=redis
PrivateTmp=true 
[Install]
WantedBy=multi-user.target
#4、验证redis启动
[root@mysql-65 6379]# systemctl daemon-reload
[root@mysql-65 6379]# systemctl enable redis
[root@mysql-65 6379]# systemctl start redis
[root@mysql-65 6379]# ss -lntp|grep redis
LISTEN     0      511    192.168.1.65:6379                     *:*                   users:(("redis-server",pid=17478,fd=7))
LISTEN     0      511    127.0.0.1:6379                     *:*                   users:(("redis-server",pid=17478,fd=6))

4.1 Redis安装警告问题解决

1.WARNING: The TCP backlog setting of 511 cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of 128
backlog参数控制的是三次握手的时候server端收到client ack确认号之后的队列值，即全连接队列
vim /etc/sysctl.conf
net.core.somaxconn = 1024
然后执行sysctl -p
2.WARNING overcommit_memory is set to 0! Background save may fail under low memory condition. To fix this issue add 'vm.overcommit_memory = 1' to /etc/sysctl.conf and then reboot or run the command 'sysctl vm.overcommit_memory=1' for this to take effect
0：表示内核将检查是否有足够的可用内存供应用进程使用。如果有足够的可用内存，内存申请允许。否则，内存申请失败，并把错误返回给应用程序
1：表示内核允许分配所有的物理内存，而不管当前的内存状态如何
2：表示内核允许分配超过所有物理内存和交换空间总和的内存
vim /etc/sysctl.conf
vm.overcommit_memory = 1
然后执行sysctl -p
3.WARNING you have Transparent Huge Pages (THP) support enabled in your kernel. This will create latency and memory usage issues with Redis. To fix this issue run the command 'echo madvise > /sys/kernel/mm/transparent_hugepage/enabled' as root, and add it to your /etc/rc.local in order to retain the setting after a reboot. Redis must be restarted after THP is disabled (set to 'madvise' or 'never')
警告：你在内核中启用了透明大页面(THP)支持。这将在Redis中造成延迟和内存使用问题。要解决此问题，请以根用户身份运行命令“echo never> / sys / kernel / mm / transparent_hugepage / enabled”，并将其添加到你的/etc/rc.local中，以便在重启后保留设置。禁用THP后，必须重新启动Redis
echo never > /sys/kernel/mm/transparent_hugepage/enabled
echo 'echo never > /sys/kernel/mm/transparent_hugepage/enabled' >> /etc/rc.d/rc.local
chmod +x /etc/rc.d/rc.local
然后重启redis即可

5 Redis基础配置文件介绍

[root@mysql-65 redis]# cd /data/6379/
[root@mysql-65 6379]# egrep -v "^#|^$" /data/6379/redis.conf 
bind 127.0.0.1 192.168.1.65
protected-mode yes
port 6379
tcp-backlog 511
timeout 300
tcp-keepalive 300
daemonize yes
supervised no
pidfile /data/6379/redis.pid
loglevel notice
logfile "/data/6379/redis.log"
databases 16
always-show-logo yes
save 900 1
save 300 10
save 60 10000
stop-writes-on-bgsave-error yes
rdbcompression yes
rdbchecksum yes
dbfilename dump.rdb
rdb-del-sync-files no
dir /data/6379
replica-serve-stale-data yes
replica-read-only yes
repl-diskless-sync no
repl-diskless-sync-delay 5
repl-diskless-load disabled
repl-disable-tcp-nodelay no
replica-priority 100
acllog-max-len 128
lazyfree-lazy-eviction no
lazyfree-lazy-expire no
lazyfree-lazy-server-del no
replica-lazy-flush no
lazyfree-lazy-user-del no
oom-score-adj no
oom-score-adj-values 0 200 800
appendonly no
appendfilename "appendonly.aof"
appendfsync everysec
no-appendfsync-on-rewrite no
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb
aof-load-truncated yes
aof-use-rdb-preamble yes
lua-time-limit 5000
slowlog-log-slower-than 10000
slowlog-max-len 128
latency-monitor-threshold 0
notify-keyspace-events ""
hash-max-ziplist-entries 512
hash-max-ziplist-value 64
list-max-ziplist-size -2
list-compress-depth 0
set-max-intset-entries 512
zset-max-ziplist-entries 128
zset-max-ziplist-value 64
hll-sparse-max-bytes 3000
stream-node-max-bytes 4096
stream-node-max-entries 100
activerehashing yes
client-output-buffer-limit normal 0 0 0
client-output-buffer-limit replica 256mb 64mb 60
client-output-buffer-limit pubsub 32mb 8mb 60
hz 10
dynamic-hz yes
aof-rewrite-incremental-fsync yes
rdb-save-incremental-fsync yes
jemalloc-bg-thread yes
配置文件说明：
daemonize yes  #Redis默认不是以守护进程的方式运行，可以通过该配置项修改，使用 yes 启用守护进程
protected-mode yes #redis3.2之后加入的新特性，在没有设置bind IP和密码的时候，redis只允许访问127.0.0.1:6379，可以远程连接，但当访问将提示警告信息并拒绝远程访问
port 6379  #指定Redis监听端口，默认端口为6379
tcp-backlog 511 #三次握手的时候server端收到client ack确认好之后的队列值，即全队列长度
tcp-keepalive 300 #tcp会话保持时间300s
supervised no #和OS相关参数，可设置通过upstart和systemd管理Redis守护进程，centos7后都使用systemd
logfile /data/6379/redis.log  #日志文件位置
dir /data/6379  #指定本地数据库存放目录
dbfilename dump.rdb  #指定本地数据库文件名，默认值为dump.rdb
pidfile /data/6379/redis.pid #当rdis以守护进程方式运行时，redis会生成redis.pid文件，可以通过pidfile指定
bind 192.168.1.65 127.0.0.1 #绑定主机地址，可以使本机IP也可以127.0.0.1
timeout 300 #当客户端闲置超时时间默认单位为秒，默认为0，表示永不超时
loglevel verbose #日志级别
databases 16 #设置数据库的数量，默认数据库为0-15，共16个库
always-show-logo yes #在启动redis时是否显示redis的logo
save 900 1 #持久化同步到数据文件的配置，表示在900秒内有一个键内容发生更改就会触发快照机制
stop-writes-on-bgsave-error yes #yes时因空间满等原因快照无法保存出错时，禁止redis写入操作，建议为no
rdbcompression yes #存储到本地数据文件是否压缩，默认为yes，redis采用LZF压缩，当数据量较小，为节省CPU可以考虑关闭。数据较大时，考虑磁盘空间以及I/O性能进行选择。
rdbchecksum yes #是否对备份文件开启RC64校验，默认是开启
dbfilename dump.rdb #指定本地数据库文件名，默认值为dump.rdb
dir /data/6379 #指定本地数据库存放目录
replica-serve-stale-data yes 
#当从库同主库失去连接或者复制正在进行，从库有两种运行方式：
#1.设置为yes(默认设置)，从库会继续响应客户端的读请求，此为建议值
#2.设置为no，除去指定的命令之外的任何请求都会返回一个错误"SYNC with master in progress"
replica-read-only yes #是否设置从库只读，建议值为yes，否则主库同步从库时可能会覆盖数据，造成数据丢失
repl-diskless-sync no #是否使用socket方式复制数据(无盘同步)，新slave连接连接时候需要做数据的全量同步，redis server就要从内存dump出新的RDB文件，然后从master传到slave，有两种方式把RDB文件传输给客户端：
#1、基于硬盘（disk-backed）：为no时，master创建一个新进程dump生成RDB磁盘文件，RDB完成之后由父进程（即主进程）将RDB文件发送给slaves，此为推荐值
#2、基于socket（diskless）：master创建一个新进程直接dump RDB至slave的网络socket，不经过主进程和硬盘基于硬盘（为no），RDB文件创建后，一旦创建完毕，可以同时服务更多的slave，但是基于socket(为yes)， 新slave连接到master之后得逐个同步数据。当磁盘I/O较慢且网络较快时，可用diskless(yes),否则使用磁盘(no)
repl-diskless-sync-delay 30 #diskless时复制的服务器等待的延迟时间，设置0为关闭，在延迟时间内到达的客户端，会一起通过diskless方式同步数据，但是一旦复制开始，master节点不会再接收新slave的复制请求，直到下一次同步开始才再接收新请求。即无法为延迟时间后到达的新副本提供服务，新副本将排队等待下一次RDB传输，因此服务器会等待一段时间才能让更多副本到达。推荐值：30-60
repl-ping-replica-period 10 #slave根据master指定的时间进行周期性的PING master 监测master状态
repl-timeout 60 #复制连接的超时时间，需要大于repl-ping-slave-period，否则会经常报超时
repl-disable-tcp-nodelay no #是否在slave套接字发送SYNC之后禁用 TCP_NODELAY，如果选择"yes"，Redis将合并多个报文为一个大的报文，从而使用更少数量的包向slaves发送数据，但是将使数据传输到slave上有延迟，Linux内核的默认配置会达到40毫秒，如果 "no" ，数据传输到slave的延迟将会减少，但要使用更多的带宽
repl-backlog-size 512mb #复制缓冲区内存大小，当slave断开连接一段时间后，该缓冲区会累积复制副本数据，因此当slave 重新连接时，通常不需要完全重新同步，只需传递在副本中的断开连接后没有同步的部分数据即可。只有在至少有一个slave连接之后才分配此内存空间。
repl-backlog-ttl 3600 #多长时间内master没有slave连接，就清空backlog缓冲区
replica-priority 100 #当master不可用，Sentinel会根据slave的优先级选举一个master，此值最低的slave会当选master，而配置成0，永远不会被选举，一般多个slave都设为一样的值，让其自动选择
min-replicas-to-write 3  #至少有3个可连接的slave，mater才接受写操作，并同步到slave中
min-replicas-max-lag 10  #和上面至少3个slave的ping延迟不能超过10秒，否则master也将停止写操作
slaveof <masterip> <masterport> #主从配置时的选项，设置为本机为slav服务时，通过配置好的master地址以及端口，在slave启动时，它会自动从master进行数据同步
masterauth <master-password> #当master服务设置了密码保护时，slav服务连接master的密码，一般很少设置密码，特殊情况下使用
requirepass foobared #设置redis连接密码，如果配置了连接密码，客户端在连接redis时需要通过AUTH<password>命令提供密码，默认关闭
rename-command FLUSHALL SUPER_FLUSHALL #重命名一些高危命令，示例：rename-command FLUSHALL "" 禁用命令
maxclients 10000 #设置同一时间最大客户端连接数，当前默认查询为10000.
maxmemory 4294967296 #redis使用的最大内存，单位为bytes字节，0为不限制，建议设为物理内存一半，8G内存的计算方式8(G)*1024(MB)1024(KB)*1024(Kbyte)，需要注意的是缓冲区是不计算在maxmemory内。
appendonly no #指定是否在每次更新操作后进行日志记录，看数据的重要性，如果一条记录都不允许丢失的话，建议开启。
appendfilename appendonly.aof #指定AOF文件名，默认为appendonly.aof
appendfsync everysec #指定更新日志条件，共有3个可选值：
    #no：表示等操作系统进行数据缓存同步到磁盘（快）
    #always：表示每次更新操作后手动调用fsync()将数据写到磁盘(慢，安全)
    #everysec：表示每秒同步一次(折中，默认值)
no-appendfsync-on-rewrite no #在aof rewrite期间,是否对aof新记录的append暂缓使用文件同步策略,主要考虑磁盘IO开支和请求阻塞时间。默认为no,表示"不暂缓",新的aof记录仍然会被立即同步，Linux的默认fsync策略是30秒，如果为yes 可能丢失30秒数据，但由于yes性能较好而且会避免出现阻塞因此比较推荐。
vm-enabled no #指定是否启用虚拟内存机制，默认值为0
vm-swap-file /tmp/redis.swap #虚拟内存文件路径
vm-max-memory 0 #设置开启虚拟内存后，redis将使用的最大物理内存的大小，默认为0
include /path/to/local.conf #指定包含其他的配置文件
auto-aof-rewrite-percentage 100 # 当Aof log增长超过指定百分比例时，重写AOF文件， 设置为0表示不自动重写Aof 日志，重写是为了使aof体积保持最小，但是还可以确保保存最完整的数据
auto-aof-rewrite-min-size 64mb #触发aof rewrite的最小文件大小
aof-load-truncated yes #是否加载由于其他原因导致的末尾异常的AOF文件(主进程被kill/断电等)，建议yes
aof-use-rdb-preamble yes #redis4.0新增RDB-AOF混合持久化格式，在开启了这个功能之后，AOF重写产生的文件将同时包含RDB格式的内容和AOF格式的内容，其中RDB格式的内容用于记录已有的数据，而AOF格式的内存则用于记录最近发生了变化的数据，这样Redis就可以同时兼有RDB持久化和AOF持久化的优点（既能够快速地生成重写文件，也能够在出现问题时，快速地载入数据）。
lua-time-limit 5000 #lua脚本的最大执行时间，单位为毫秒
cluster-enabled yes #是否开启集群模式，默认是单机模式
cluster-config-file nodes-6379.conf #由node节点自动生成的集群配置文件名称
cluster-node-timeout 15000 #集群中node节点连接超时时间，超过此时间，会踢出集群
cluster-replica-validity-factor 10 #在执行故障转移的时候可能有些节点和master断开一段时间数据比较旧，这些节点就不适用于选举为master，超过这个时间的就不会被进行故障转移，计算公式：(node-timeout * replica-validity-factor) + repl-ping-replica-period 
cluster-migration-barrier 1 #集群迁移屏障，一个主节点至少拥有一个正常工作的从节点，即如果主节点的slave节点故障后会将多余的从节点分配到当前主节点成为其新的从节点。
cluster-require-full-coverage yes #集群请求槽位全部覆盖，如果一个主库宕机且没有备库就会出现集群槽位不全，那么yes情况下redis集群槽位验证不全就不再对外提供服务，而no则可以继续使用但是会出现查询数据查不到的情况(因为有数据丢失)。建议为no
cluster-replica-no-failover no #如果为yes,此选项阻止在主服务器发生故障时尝试对其主服务器进行故障转移。 但是，主服务器仍然可以执行手动强制故障转移，一般为no
#Slow log 是 Redis 用来记录超过指定执行时间的日志系统， 执行时间不包括与客户端交谈，发送回复等I/O操作，而是实际执行命令所需的时间（在该阶段线程被阻塞并且不能同时为其它请求提供服务）slow log 保存在内存里面，读写速度非常快，因此可放心地使用，不必担心因为开启 slow log 而影响 Redis 的速度
slowlog-log-slower-than 10000 #以微秒为单位的慢日志记录，为负数会禁用慢日志，为0会记录每个命令操作。
slowlog-max-len 128 #最多记录多少条慢日志的保存队列长度，达到此长度后，记录新命令会将最旧的命令从命令队列中删除，以此滚动删除

5.1 生产环境配置文件

#生产环境的redis.conf配置信息
bind 10.4.61.63 127.0.0.1
protected-mode yes
port 9005
tcp-backlog 511
timeout 0
tcp-keepalive 300
daemonize yes
supervised no
pidfile /var/run/redis_9005.pid
loglevel notice
logfile /var/log/redis_9005.log
databases 16
always-show-logo yes
save ""
stop-writes-on-bgsave-error no
rdbcompression yes
rdbchecksum yes
dbfilename dump.rdb
dir /var/lib/redis/9005
replica-serve-stale-data yes
replica-read-only yes
repl-diskless-sync no
repl-diskless-sync-delay 5
repl-disable-tcp-nodelay no
replica-priority 100
maxmemory 4294967296
lazyfree-lazy-eviction no
lazyfree-lazy-expire no
lazyfree-lazy-server-del no
replica-lazy-flush no
appendonly no
appendfilename "appendonly.aof"
appendfsync everysec
no-appendfsync-on-rewrite no
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb
aof-load-truncated yes
aof-use-rdb-preamble yes
lua-time-limit 5000
cluster-enabled yes
cluster-config-file nodes-9005.conf
cluster-node-timeout 15000
cluster-require-full-coverage no
slowlog-log-slower-than 10000
slowlog-max-len 128
latency-monitor-threshold 0
notify-keyspace-events ""
hash-max-ziplist-entries 512
hash-max-ziplist-value 64
list-max-ziplist-size -2
list-compress-depth 0
set-max-intset-entries 512
zset-max-ziplist-entries 128
zset-max-ziplist-value 64
hll-sparse-max-bytes 3000
stream-node-max-bytes 4096
stream-node-max-entries 100
activerehashing yes
client-output-buffer-limit normal 0 0 0
client-output-buffer-limit replica 256mb 64mb 60
client-output-buffer-limit pubsub 32mb 8mb 60
hz 10
dynamic-hz yes
aof-rewrite-incremental-fsync yes
rdb-save-incremental-fsync yes
rename-command FLUSHALL SUPER_FLUSHALL
rename-command FLUSHDB  SUPER_FLUSHDB

配置好文件之后，我们重启redis：

[root@mysql-65 6379]# ss -lntp|grep redis
LISTEN     0      128          *:6379                     *:*                   users:(("redis-server",pid=8990,fd=7))
LISTEN     0      128       [::]:6379                  [::]:*                   users:(("redis-server",pid=8990,fd=6))
[root@mysql-65 ~]# systemctl restart redis
[root@mysql-65 ~]# systemctl status redis
● redis.service - Redis
   Loaded: loaded (/usr/lib/systemd/system/redis.service; enabled; vendor preset: disabled)
   Active: active (running) since 四 2020-12-10 11:18:29 CST; 4s ago
  Process: 17555 ExecStop=/usr/local/redis/src/redis-cli shutdown (code=exited, status=0/SUCCESS)
  Process: 17558 ExecStart=/usr/local/redis/src/redis-server /data/6379/redis.conf (code=exited, status=0/SUCCESS)
 Main PID: 17559 (redis-server)
   CGroup: /system.slice/redis.service
           └─17559 /usr/local/redis/src/redis-server 127.0.0.1:6379
12月 10 11:18:29 mysql-65 systemd[1]: Stopped Redis.
12月 10 11:18:29 mysql-65 systemd[1]: Starting Redis...
12月 10 11:18:29 mysql-65 systemd[1]: Started Redis.

6 Redis安全配置

• redis没有用户概念，只能设置密码
• redis默认工作在保护模式下，不允许远程用户登录

所以为了可以实现远程访问，我们需要加入以下几个配置：

[root@mysql-65 redis]# cat /data/6379/redis.conf 
bind 192.168.1.65 127.0.0.1  #绑定远程服务器IP地址
requirepass 123456  #设置密码
#配置好之后，重启我们的redis
[root@mysql-65 6379]# systemctl restart redis
--------------- 验证 ---------------
[root@mysql-65 redis]# ./src/redis-cli -h 192.168.1.65 -a 123456
192.168.1.65:6379> set name zhangsan
OK
192.168.1.65:6379> get name
"zhangsan"
192.168.1.65:6379>

7 Redis的单线程架构

Redis使用了单线程架构和I/O多路复用模型来实现高性能的内存数据库服务

7.1 单线程模型

现在开启三个redis-cli客户端同时执行命令

客户端1设置一个字符串键值对：

10.4.60.96:7001> set hello world

客户端2对counter做自增操作：

10.4.60.96:7001> incr counter

客户端3对counter做自增操作：

10.4.60.96:7001> incr counter

Redis客户端与服务端的模型如下图所示，每次客户端调用都经历了发送命令、执行命令、返回结果三个过程。

其中第二步是重点讨论的，因为Redis是单线程来处理命令的，所以一条命令从客户端达到服务端不会立刻被执行，所有命令都会进入一个队列中，然后逐个被执行。所以上面3个客户端命令的执行顺序是不确定的，如下图所示：

但是可以确定不会有两条命令被同时执行，如下图所示：

所以两条incr命令无论怎么执行最终结果都是2，不会产生并发问题，这就是Redis单线程的基本模型。

7.2 为什么单线程还能这么快

通常来说，单线程的处理能比要比多线程差，但是为什么Redis使用单线程模型会达到每秒万级别的处理能力呢？可以将其归结为三点：

• 纯内存访问，Redis将所有数据放在内存中，内存的响应时长大约为100纳秒，这是Redis达到每秒万级别访问的重要基础。
• 非阻塞I/O，Redis使用epoll作为I/O多路复用技术的实现，再加上Redis自身的事件处理模型将epoll中的连接、读写、关闭都转换为事件，不在网络I/O上浪费过多的时间，如下图所示：

• 单线程避免了线程切换和竞态产生的消耗。

8 Redis的数据结构

Redis主要支持的数据类型有5种：String、Hash、List、Set以及Sorted Set。

8.1 String字符串类型

String是Redis中最基本的数据类型，一个key对应的一个value。

String类型是二进制安全的，意思是redis的string可以包含任何数据。如数字，字符串，jpg图片或者序列化的对象。当然这个值也是有限制的，最大值不能超过512M。

#1.创建key用set，查看用get
192.168.1.65:6379> set key1 hello
OK
192.168.1.65:6379> set key2 123
OK
192.168.1.65:6379> get key1
"hello"
192.168.1.65:6379> get key2
"123"
PS：如果当前key的值存在的话，则会覆盖
#2.批量插入mset和批量查询mget
192.168.1.65:6379> mset key3 three key4 four key5 five
OK
192.168.1.65:6379> mget key3 key4 key5
1) "three"
2) "four"
3) "five"
PS：批量插入数据或者批量查询数据可以减少网络的开销
#3.追加append与del删除
192.168.1.65:6379> append key1 world
(integer) 10
192.168.1.65:6379> get key1
"helloworld"
192.168.1.65:6379> del key1 #删除key
(integer) 1
192.168.1.65:6379> get key1
(nil)
#4.其他操作
#对key+1，自增
192.168.1.65:6379> set key2 124
OK
192.168.1.65:6379> get key2
"124"
192.168.1.65:6379> incr key2 #对key进行+1的操作，非int类型会报错
(integer) 125
192.168.1.65:6379> get key2
"125"
#对key+N
192.168.1.65:6379> incrby key2 10 #对key进行+N的操作
(integer) 135
192.168.1.65:6379> get key2
"135"
#对key-1，自减
192.168.1.65:6379> decr key2 #对key进行-1的操作
(integer) 134
192.168.1.65:6379> get key2
"134"
#对key-N
192.168.1.65:6379> decrby key2 5 #对key进行-N的操作
(integer) 129
192.168.1.65:6379> get key2
"129"
#计算字符串key长度
192.168.1.65:6379> SET name wang
OK
192.168.1.65:6379> STRLEN name #返回字符串key长度
(integer) 4
#判断key是否存在，0不存在，1存在
192.168.1.65:6379> SET name wang
OK
192.168.1.65:6379> EXISTS NAME #大小写敏感
(integer) 0
192.168.1.65:6379> EXISTS name
(integer) 1
#查看key的过期时间
ttl #查看key的剩余生存时间
-1 #负一为永不过期，默认创建的key是永不过期，重新对key赋值，也会从有剩余生命周期变成永不过期
-2 #为没有此key
num #key的剩余有效期
127.0.0.1:6379> TTL key1
(integer) -1
127.0.0.1:6379> SET name wang EX 100
OK
127.0.0.1:6379> TTL name
(integer) 96
127.0.0.1:6379> TTL name
(integer) 93
127.0.0.1:6379> SET name mage #重新设置，默认永不过期
OK
127.0.0.1:6379> TTL name
(integer) -1
127.0.0.1:6379> SET name wang EX 200
OK
127.0.0.1:6379> TTL name
(integer) 198
127.0.0.1:6379> GET name
"wang"
#重新设置key的过期时间
127.0.0.1:6379> TTL name
(integer) 148
127.0.0.1:6379> EXPIRE name 1000
(integer) 1
127.0.0.1:6379> TTL name
(integer) 999
127.0.0.1:6379>
#取消key的过期时间
127.0.0.1:6379> TTL name
(integer) 999
127.0.0.1:6379> PERSIST name
(integer) 1
127.0.0.1:6379> TTL name
(integer) -1

实战场景：

1.缓存：经典实用场景，把常用信息，字符串，图片或者视频等信息放到redis中，redis作为缓存层，mysql做持久化层，降低mysql的读写压力

2.计数器：redis是单线程模型，一个命令执行完才会执行下一个，同时数据可以一步落地到其他的数据源

3.session：常见方案spring session + redis实现session共享。

8.2 List列表类型

Redis列表是一个双向可读写的管道，其头部是左侧，尾部是右侧，一个列表最多可以包含2^32-1个元素，下标0表示列表的第一个元素，以1表示列表的第二个元素，以此类推。也可以使用负数下标，以-1表示列表的最后一个元素，-2表示列表的倒数第二个元素，元素值可以重复，常用于存入日志等场景，此数据类型比较常用。

#1.列表的增删改查
192.168.1.65:6379> rpush list1 1 #增加数字1
(integer) 1
192.168.1.65:6379> rpush list1 2 #增加数字2
(integer) 2
192.168.1.65:6379> rpush list1 3 #增加数字3
(integer) 3
192.168.1.65:6379> rpush list1 4 #增加数字4
(integer) 4
192.168.1.65:6379> lrange list1 0 1 #lrange获取list下标0到1
1) "1"
2) "2"
192.168.1.65:6379> lindex list1 1 #获取1编号的元素
"2"
192.168.1.65:6379> lrange list1 0 -1 #获取所有元素
1) "1"
2) "2"
3) "3"
4) "4"
192.168.1.65:6379> linsert list1 after 2 6 #在2之后插入6这个数据
(integer) 5
192.168.1.65:6379> lrange list1 0 -1
1) "1"
2) "2"
3) "6"
4) "3"
5) "4"
192.168.1.65:6379> linsert list1 before 2 8 #在2之前插入8这个一个数据
(integer) 6
192.168.1.65:6379> lrange list1 0 -1
1) "1"
2) "8"
3) "2"
4) "6"
5) "3"
6) "4"
192.168.1.65:6379> lpop list1 #lpop从左侧开始移除一个元素
"1"
192.168.1.65:6379> lrange list1 0 -1
1) "8"
2) "2"
3) "6"
4) "3"
5) "4"
192.168.1.65:6379> rpop list1  #从右侧开始移除一个元素
"4"
192.168.1.65:6379> lrange list1 0 -1
1) "8"
2) "2"
3) "6"
4) "3"
192.168.1.65:6379> ltrim list1 1 3 #保留下标1到3其余删除
OK
192.168.1.65:6379> lrange list1 0 -1
1) "2"
2) "6"
3) "3"
192.168.1.65:6379> llen list1 #列表长度
(integer) 3
192.168.1.65:6379> lset list1 1 hello  #替换下标1的元素
OK
192.168.1.65:6379> lrange list1 0 -1
1) "2"
2) "hello"
3) "3"
192.168.1.65:6379> rpush list1 h e l #从右边添加数据，已添加的向左移
(integer) 6
192.168.1.65:6379> lrange list1 0 -1
1) "2"
2) "hello"
3) "3"
4) "h"
5) "e"
6) "l"
#从左边添加数据，已添加的需向右移
127.0.0.1:6379> LPUSH list1 jack tom john #根据顺序逐个写入list1，最后的john会在列表的最左侧。
(integer) 3
#删除list
127.0.0.1:6379> DEL list1
(integer) 1
127.0.0.1:6379> EXISTS list1
(integer) 0

实战场景：

微博的时间轴，有人发布微博，用lpush加入时间轴，展示新的列表信息

8.3 Sets集合

在Redis中Set和list都是字符串的集合。但是Set是无序的集合，集合中的元素都是唯一的，是不允许出现重复数据的，常用于取值判断，统计，交集等场景。

192.168.1.65:6379> sadd set1 1 #生成一个集合key
(integer) 1
192.168.1.65:6379> sadd set1 2 3 4 5 #增加多个元素
(integer) 4
192.168.1.65:6379> smembers set1 #查看集合中所有元素
1) "1"
2) "2"
3) "3"
4) "4"
5) "5"
192.168.1.65:6379> sismember set1 3 #查看值是否在集合中，并返回1
(integer) 1
192.168.1.65:6379> sismember set1 6 #查看值是否在集合中，并返回0
(integer) 0
192.168.1.65:6379> sadd set1 a b c d
(integer) 4
192.168.1.65:6379> srem set1 2 #删除某个元素
(integer) 1
192.168.1.65:6379> srem set1 a
(integer) 1
192.168.1.65:6379> srem set1 b 4 #同时删除多个元素
(integer) 2
192.168.1.65:6379> smembers set1
1) "c"
2) "1"
3) "5"
4) "3"
5) "d"
192.168.1.65:6379> scard set1 #查询集合中有多少个元素
(integer) 5
192.168.1.65:6379> srandmember set1 #随机获取一个元素
"3"
192.168.1.65:6379> srandmember set1
"c"
192.168.1.65:6379> sadd set2 1 2 3 4 5 6
(integer) 6
192.168.1.65:6379> smove set1 set2 3 #从set1中移除，存放到set2中
(integer) 1
192.168.1.65:6379> smembers set1
1) "c"
2) "1"
3) "5"
4) "d"
192.168.1.65:6379> smembers set2
1) "1"
2) "2"
3) "3"
4) "4"
5) "5"
6) "6"
192.168.1.65:6379> sunion set1 set2 #查看两个set的并集，输出不同值
1) "4"
2) "5"
3) "6"
4) "c"
5) "3"
6) "2"
7) "1"
8) "d"
192.168.1.65:6379> sinter set1 set2 #查看set1 set2的交集，共同拥有的值
1) "1"
2) "5"
192.168.1.65:6379> sdiff set1 set2 #对比set1和set2差异（以set1为基准）
1) "d"
2) "c"
192.168.1.65:6379> sdiff set2 set1 #对比set2和set1的差异（以set2为基准）
1) "2"
2) "3"
3) "4"
4) "6"

实战场景：

1.标签，给用户添加标签，或者用户给消息添加标签，这样有同一标签或者类似标签的可以给推荐关注的事或者关注的人

2.点赞，或点踩，可以放到set中实现

8.4 Hash

hash是一个string类型的field和value的映射表。redis中每个hash可以存储2^32-1键值对，类似于字典，存放了多个k/V对，hash特别适合用于存储对象场景

192.168.1.65:6379> hset hash1 name guzhou #创建并插入单个值
(integer) 1
192.168.1.65:6379> hset hash1 aget 30
(integer) 1
192.168.1.65:6379> hget hash1 name #获取hash表中键值为name的值
"guzhou"
192.168.1.65:6379> hset hash1 name guzhou1 #原来已存在，插入则是修改
(integer) 0
192.168.1.65:6379> hget hash1 name
"guzhou1"
192.168.1.65:6379> hlen hash1  #查看元素数量
(integer) 2
192.168.1.65:6379> hexists hash1 name #判断键值name是否存在，真为1
(integer) 1
192.168.1.65:6379> hexists hash1 sex
(integer) 0
192.168.1.65:6379> hset hash1 sex man
(integer) 1
192.168.1.65:6379> hget hash1 sex
"man"
192.168.1.65:6379> hdel hash1 sex name #删除1个或者多个键值
(integer) 2
192.168.1.65:6379> hgetall hash1 #获取hash表内所有键值和数据
1) "aget"
2) "30"
192.168.1.65:6379> hmset hash1 name guzhou sex man phone 15221111111 #插入多个键值和数据
OK
192.168.1.65:6379> hmget hash1 name phone #查看hash表中多个键值对
1) "guzhou"
2) "15221111111"
192.168.1.65:6379> hkeys hash1 #查看hash表中所有的key
1) "aget"
2) "name"
3) "sex"
4) "phone"
192.168.1.65:6379> hvals hash1 #查看hash表中所有的value
1) "30"
2) "guzhou"
3) "man"
4) "15221111111"

实战场景：

缓存：能直观，相比string更节省空间，如用户信息，视频信息等

8.5 Sorted Sets有序集合

Redis有序集合和集合一样也是string类型元素的集合，且不允许重复的元素。

不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。

有序集合的成员是唯一的，但分数(score)却可以重复，集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是O(1)， 集合中最大的成员数为 2^32 – 1 (4294967295, 每个集合可存储40多亿个成员)，经常用于排行榜的场景

注意：数据插入的时候值不可以重复，分数可以重复。可以理解为权重、值，两个部分组成，权重可以相同，值一定不能相同。否则插入时会覆盖。

192.168.1.65:6379> zadd zset 1 peiking #插入分支和数据，可以多个
(integer) 1
192.168.1.65:6379> zadd zset 2 shanghai
(integer) 1
192.168.1.65:6379> zadd zset 3 guangzhou
(integer) 1
192.168.1.65:6379> zadd zset 4 shenzhen
(integer) 1
192.168.1.65:6379> zadd zset 5 tianjin
(integer) 1
192.168.1.65:6379> zadd zset 6 beijing
(integer) 1
192.168.1.65:6379> zrange zset 0 -1 withscores #显示指定集合内所有key和value值
 1) "peiking"
 2) "1"
 3) "shanghai"
 4) "2"
 5) "guangzhou"
 6) "3"
 7) "shenzhen"
 8) "4"
 9) "tianjin"
10) "5"
11) "beijing"
12) "6"
192.168.1.65:6379> zrange zset 0 1 withscores #显示下标0到1的元素
1) "peiking"
2) "1"
3) "shanghai"
4) "2"
192.168.1.65:6379> zrevrange zset 0 -1 #倒序排序后显示集合内所有的key
1) "beijing"
2) "tianjin"
3) "shenzhen"
4) "guangzhou"
5) "shanghai"
6) "peiking"
192.168.1.65:6379> zcard zset #统计集合中有多少元素
(integer) 6
192.168.1.65:6379> zcount zset 1 5 #统计权重1到5之间有多少元素
(integer) 5
192.168.1.65:6379> zincrby zset 5 guangzhou #为广州这个元素增加5个权重
"8"
192.168.1.65:6379> zrank zset shanghai  #返回某个数值的索引
(integer) 1
192.168.1.65:6379> zscore zset shanghai #获取集合元素中shanghai的权重
"2"
192.168.1.65:6379> zrevrank zset shanghai #获取元素的索引、下标，从大到小排序
(integer) 4
192.168.1.65:6379> zrem zset beijing #删除集合中一个元素或者多个元素
(integer) 1
192.168.1.65:6379> zrevrange zset 0 -1 
1) "guangzhou"
2) "tianjin"
3) "shenzhen"
4) "shanghai"
5) "peiking"

实战场景：

1.排行榜：有序集合经典实用场景。列如小说视频等网站需要对用户上传的小说视频做排行榜，榜单可以按照用户关注数，更新时间，字数等打分，做排行。

9 Redis基础命令

9.1 auth

解锁redis密码，比如我们通过配置文件中requirepass这个值设置了密码，我们在使用redis时，需要通过auth这个命令来解锁。否则提示未认证。也可以登录时，使用-a参数，指定密码。

[root@mysql-65 redis]# ./src/redis-cli -h 192.168.1.65
192.168.1.65:6379> auth root123
OK
192.168.1.65:6379> set name xujun
OK
[root@mysql-65 redis]# ./src/redis-cli -h 192.168.1.65 -a root123
Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.
192.168.1.65:6379>

9.2 select

我们在其他数据库。列如mysql的使用中，有数据库的概念，我们启动的是一个实列，具体使用某个库，需要use 某某数据库才行。

select命令就是在redis实列中，选择一个库。

选择这个库之后，才可以使用我们存储的数据，进行查询，或者创建修改等等。数据库编号，需要使用数字表示，这个索引的起始值为0，select 0的时候，就是我们默认登录的这个数据库。

在正式的生产环境中，建议一个Redis只使用一个库，总结起来有以下三点：

• Redis是单线程的。如果使用多个数据库，那么这些数据库仍然是使用一个CPU，彼此之间还是会受到影响的
• 多数据库的使用方式，会让调试和运维不同业务的数据库变得困难，假如有一个慢查询存在，依然会影响到其他数据库，这样会使得别的业务定位问题变得非常困难
• 部分Redis的客户端根本就不支持这种方式。即使支持，在开发的时候来回切换数字形式的数据库，很容易弄乱

所以以上总结就是，如果要使用多个数据库功能，完全可以在一台机器上部署多个Redis实例，彼此用端口来做区分，因此现代计算机或者服务器通常是有多个CPU的。这样既保证了业务之间不会受到影响，又合理地使用了CPU资源。

192.168.1.65:6379> keys * #在默认数据库0里面查看所有的key
 1) "hash1"
 2) "a"
 3) "key3"
 4) "list2"
 5) "kye1"
 6) "set2"
 7) "set1"
 8) "key5"
 9) "key4"
10) "kye2"
11) "key2"
12) "name"
13) "list1"
14) "zset"
15) "set"
192.168.1.65:6379> select 1 #切换到索引为1的数据库
OK
192.168.1.65:6379[1]> keys * #在索引为1的数据库里面查看key，发现为空，说明不切换回0，是看不到数据的
(empty array)
192.168.1.65:6379[1]> select 0 #切换回到默认的数据库里
OK

9.3 info

我们可以通过info命令查看我们redis的全部信息。也可以查看指定的信息，比如输入info cpu就可以看到CPU信息，或者info Replication可以查看目前主从复制的信息等等，输入info后不跟任何关键字，默认显示全部。

192.168.1.65:6379> info
# Server
redis_version:6.0.9
redis_git_sha1:00000000
redis_git_dirty:0
redis_build_id:35cd6ca328855102
redis_mode:standalone
os:Linux 3.10.0-1062.el7.x86_64 x86_64
arch_bits:64
multiplexing_api:epoll
atomicvar_api:atomic-builtin
gcc_version:9.3.1
process_id:9160
run_id:466b444bc200909c9d593544e08e1d36af4c7939
tcp_port:6379
uptime_in_seconds:3430704
uptime_in_days:39
hz:10
configured_hz:10
lru_clock:13644761
executable:/usr/local/redis-6.0.9/./src/redis-server
config_file:/data/6379/redis.conf
io_threads_active:0

9.4 config get和config set

查看数据库配置信息，比如config get *则是显示全部配置，如果config get save后边输入某一个配置项，则输出配置项信息

在redis中，如何去配置或者重新设置我们的redis的配置选项，我们可以通过config set命令来实现。比如config set maxmemory 1024

[root@mysql-65 redis]# ./src/redis-cli -h 192.168.1.65 -a 123456
192.168.1.65:6379> config get *  #查看所有redis配置信息，奇数行为键，偶数行为值
  1) "rdbchecksum"
  2) "yes"
  3) "daemonize"
  4) "yes"
  5) "io-threads-do-reads"
  6) "no"
  7) "lua-replicate-commands"
  8) "yes"
  9) "always-show-logo"
 10) "no"
 .....
192.168.1.65:6379> config set requirepass root123  #设置redis远程登录密码
OK
192.168.1.65:6379> quit
[root@mysql-65 redis]# ./src/redis-cli -h 192.168.1.65 -a 123456  #用之前的密码登录，设置key和value失败
Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.
Warning: AUTH failed
192.168.1.65:6379> set a b  #用之前的密码登录，设置key和value失败
(error) NOAUTH Authentication required.
192.168.1.65:6379> quit
[root@mysql-65 redis]# ./src/redis-cli -h 192.168.1.65 -a root123  #用新设置的密码登录，成功
Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.
192.168.1.65:6379> set a b
OK
192.168.1.65:6379>

9.5 KEYS

查看当前库下的所有key，此命令慎用！

1 27.0.0.1:6379[15]> SELECT 0
OK
127.0.0.1:6379> KEYS *
1) "9527"
2) "9526"
3) "paihangbang"
4) "list1"
127.0.0.1:6379> SELECT 1
OK
127.0.0.1:6379[1]> KEYS *
(empty list or set)
127.0.0.1:6379[1]>

9.6 其他命令

1.client list
查看当前连接的客户端
2.client kill
ip:port可以杀掉某个连接，需要输入ip和端口
3.flushdb
删除当前库内所有数据，慎重执行，命令不会有确认提示。执行一定成功。flushdb只对当前库生效，不会删除整个实列内全部的数据
4.flushall
删除实列中所有数据，更慎重使用，针对实列生效，执行完成之后，将全部数据被删除。
5.bgsave
在后台异步保存当前数据库的数据到硬盘。在我们执行bgsave命令的时候，会直接返回OK。
redis会fork出一个新的子进程来处理这个请求，原来的父进程会继续处理客户端请求，子进程把数据保存完成后退出。数据量较大时，可以通过ps命令查看子进程信息。
这个操作并不会生成新的文件，而是会重写原来的rdb文件，也可以通过ls -lrt的命令，查看rdb文件的更新时间。
6.LASTSAVE
这个命令查看上次执行的bgsave命令完成时间。返回的为Unix的时间戳
7.SAVE
命令保存当前redis实列的所有数据快照到磁盘，生产rdb文件的形式保存。
这个命令执行时，和bgsave不同，save为同步操作，为阻塞客户端所有操作，直接由redis进程完成。
导致在生产环境中，几乎不使用。简单来说，save在执行保存rdb文件的过程中，redis是不可访问的。由于这个特性，很少使用。
8.DBSIZE
返回当前库下的所有key数量
192.168.1.65:6379> DBSIZE
(integer) 15

10 Redis消息队列

10.1 消息队列模式

消息队列主要分为两种，这两种模式Redis都支持

• 生产者/消费者模式
• 发布者/订阅者模式

10.1.1 生产者消费者模式

在生产者/消费者模式下，上层应用接受到的外部请求后开始处理其当前步骤的操作，在执行完成后将已经完成的操作发送至指定的频道当中，并由其下层的应用监听该频道并继续下一步的操作，如果其处理完成后没有下一步的操作就直接返回数据给外部请求，如果还有下一步的操作就再将任务发布给另外一个频道，由另外一个消费者继续监听和处理。此模式应用广泛。

10.1.1.1 模式介绍

生产者消费者模式下，多个消费者同时监听一个队列，但是一个消息只能被最先抢到消息的消费者消费，即消息任务是一次性读取和处理，此模式在分布式业务架构中很常用，比较常用的消息队列软件还有RabbitMQ、Kafka、RocketMQ、ActiveMQ等。

10.1.1.2 队列介绍

队列当中的 消息由不同的生产者写入，也会有不同的消费者取出进行消费处理，但是一个消息一定是只能被取出一次也就是被消费一次。

10.1.1.3 生产者发布消息

[root@redis-s4 ~]# redis-cli
127.0.0.1:6379> AUTH 123456
OK
127.0.0.1:6379> LPUSH channel1 msg1 #从管道的左侧写入
(integer) 1
127.0.0.1:6379> LPUSH channel1 msg2
(integer) 2
127.0.0.1:6379> LPUSH channel1 msg3
(integer) 3
127.0.0.1:6379> LPUSH channel1 msg4
(integer) 4
127.0.0.1:6379> LPUSH channel1 msg5
(integer) 5

10.1.1.4 查看队列所有消息

127.0.0.1:6379> LRANGE channel1 0 -1
1) "msg5"
2) "msg4"
3) "msg3"
4) "msg2"
5) "msg1"

10.1.1.5 消费者消费消息

127.0.0.1:6379> RPOP channel1 #从管道的右侧消费，用于消息的先进先出
"msg1"
127.0.0.1:6379> RPOP channel1
"msg2"
127.0.0.1:6379> RPOP channel1
"msg3"
127.0.0.1:6379> RPOP channel1
"msg4"
127.0.0.1:6379> RPOP channel1
"msg5"
127.0.0.1:6379> RPOP channel1
(nil)

10.1.1.6 再次验证队列消息

127.0.0.1:6379> LRANGE channel1 0 -1
(empty list or set) #队列中的消息已经被已全部消费完毕

10.1.2 发布者订阅模式

10.1.2.1 模式简介

在发布者订阅者模式下，发布者将消息发布到指定的channel里面，凡是监听该channel的消费者都会收到同样的一份消息，这种模式类似于是收音机的广播模式，即凡是收听某个频道的听众都会收到主持人发布的相同的消息内容。此模式常用语群聊天、群通知、群公告等场景。

• Publisher：发布者
• Subscriber：订阅者
• Channel：频道

10.1.2.2 订阅者监听频道

[root@redis-s4 ~]# redis-cli
127.0.0.1:6379> AUTH 123456
OK
127.0.0.1:6379> SUBSCRIBE channel1 #订阅者事先订阅指定的频道，之后发布的消息才能收到
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "channel1"
3) (integer) 1

10.1.2.3 发布者发布消息

127.0.0.1:6379> PUBLISH channel1 test1 #发布者发布消息
(integer) 2
127.0.0.1:6379> PUBLISH channel1 test2
(integer) 2

10.1.2.4 发布者发布消息

10.1.2.5 订阅多个频道

#订阅指定的多个频道
127.0.0.1:6379> SUBSCRIBE channel1 channel2

10.1.2.6 订阅所有频道

127.0.0.1:6379> PSUBSCRIBE *  #支持通配符*

10.1.2.7 订阅匹配的频道

127.0.0.1:6379> PSUBSCRIBE chann* #匹配订阅多个频道

11 Redis持久化

Redis虽然是一个内存级别的缓存程序，也就是redis是使用内存进行数据的缓存的，但是其可以将内存的数据按照一定的策略保存到硬盘上，从而实现数据持久保存的目的，目前redis支持两种不同方式的数据持久化保存机制，分别是RDB和AOF。

11.1 RDB模式

RDB：基于时间的快照，其默认只保留当前最新的一次快照，特点是执行速度比较快，缺点是可能会丢失从上次快照到当前时间点之间未做快照的数据。

RDB实现的具体过程Redis从master主进程先fork出一个子进程，使用写时复制机制，子进程将内存的数据保存为一个临时文件，比如dump.rdb.temp，当数据保存完成之后再将上一次保存的RDB文件替换掉，然后关闭子进程，这样可以保证每一次做RDB快照的时候保存的数据是完整的，因为直接替换RDB文件的时候可能会出现突然断电等问题而导致RDB文件还没有保存完整就突然关机停止保存而导致数据丢失的情况，可以手动将每次生成的RDB文件进程备份，这样可以最大化保存历史数据。

11.1.1 RDB模式触发机制

手动触发分别对应save和bgsave命令：

save命令：阻塞当前Redis服务器，直到RDB过程完成为止，对于内存比较大的实例会造成长时间阻塞，线上环境不建议使用。

bgsave命令：Redis进程执行fork操作创建子进程，RDB持久化过程由子进程负责，完成后自动结束。阻塞只发生在fork阶段，一般时间很短。

所以在日常的生产环境中，Redis内部所有的涉及RDB的操作都采用bgsave的方式，而save命令已经废弃。

11.2 RDB模式的优缺点

优点：RDB快照保存了某个时间点的数据，可以通过脚本执行bgsave（非阻塞，后台执行）或者save（阻塞，不推荐）命令自定义时间点备份，可以保留多个备份，当出现问题可以恢复到不同时间点的版本。

可以最大化IO的性能，因为父进程在保存RDB文件的时候唯一要做的是fork出一个子进程，然后操作都会有这个子进程操作，父进程无序任何的IO操作，RDB在大量数据比如几个G的数据，恢复的速度比AOF的快。

缺点：不能实时保存数据，会丢失自上一次执行RDB备份到当前的内存数据。数据量非常大的时候，从父进程fork的时候需要一点时间，可能是毫秒或者秒或者分钟，取决于磁盘IO性能。

daemonize yes
port 6666
requirepass 123
logfile ./redislog_louie.log
dir ./
bind 192.168.250.132 127.0.0.1 #  0.0.0.0
save 20 1  # 自动保存策略，20秒内有一个key发生变化就自动保存
dbfilename rdb_louie.rdb  #  rdb文件名
stop-writes-on-bgsave-error yes #  发生错误中断写入，建议开启
rdbcompression yes  # 数据文件压缩，建议开启
rdbchecksum yes # 开启crc64错误校验，建议开启

11.3 AOF模式(推荐方案)

AOF：按照操作顺序依次将操作追加到指定的日志文件末尾。

AOF和RDB一样使用了写时复制机制，AOF默认为每秒钟fsync一次，即将执行的命令保存到AOF文件当中，这样即使redis服务器发生故障的话最多只丢失1秒钟之内的数据，也可以设置不同的fsync策略，或者设置每次执行命令的时候执行fsync，fsync会在后台实行线程，所以主线程可以继续处理用户的正常请求而不受到写入AOF文件的IO影响。

注：如果RDB与AOF同时存在的情况下，Redis默认优先使用AOF进行数据恢复。

11.4 AOF模式的优缺点

优点：

• 数据安全性相对较高，根据所使用的fsync策略（fsync是同步内存中redis所有已经修改的文件到存储设备）默认是appendfsync everysec，即每秒执行一次fsync。
• 由于该机制对日志文件的写入操作采用的是append模式，因此在写入过程中即使出现宕机现象，也不会破坏日志文件中已经存在的内容。然而如果我们本次操作只是写入了一半数据就出现了系统崩溃问题，不用担心，在Redis下一次启动之前，我们可以通过redis-check-aof工具来帮助我们解决数据一致性的问题。
• 如果日志过大，Redis可以自动启用rewrite机制。即Redis以append模式不断的将修改数据写入到老的磁盘文件中，同时Redis还会创建一个新的文件用于记录此期间有哪些修改命令被执行。因此在进行rewrite切换时可以更好的保证数据安全性。
• AOF包含一个格式清晰、易于理解的日志文件用于记录所有的修改操作。事实上，我们也可以通过该文件完成数据的重建。

缺点：

• 即使有些操作是重复的也会全部记录，AOF的文件大小要大于RDB格式的文件
• RDB 在恢复大数据集时的速度比 AOF 的恢复速度要快

daemonize yes
port 6666
requirepass 123
logfile ./redislog_louie.log
dir ./
bind 192.168.250.132 127.0.0.1 # 0.0.0.0
appendonly yes  # 开启aof
appendfilename aof_louie.aof  # aof 日志文件名
appendfsync everysec  #  每秒记录一次日志，建议everysec
no-appendfsync-on-rewrite yes  # 重写过程中是否向日志文件写入，yes 代表rewrite过程中，不向aof文件中追加信息，rewrite结束后再写入，no 代表rewrite执行的同时，也向aof追加信息
auto-aof-rewrite-percentage 100 # 触发重写文件增长百分比 默认100%
auto-aof-rewrite-min-size 64mb  # 触发重写最小aof文件尺寸

看到上面的配置，大家会有疑问，为什么会有 重写，主要是因为要压缩数据，产生的文件更小，防止同样的相同命令占用空间，比如如下：用最简短的命令来操作数据

12 Redis高可用与集群

为什么我们需要主从复制呢？

以下三点说明：

• Redis单机一旦故障，可以通过从服务器上进行恢复数据
• Redis要达到高可用、高并发，只有单个Redis是不够的，单个Redis也就只能支持几万的QPS，所以必须以集群的形式提供服务，而集群中又以多个主从组成
• 主从是多个Redis集合在一起，以一个master多个slave为模式对外提供服务，master主要以写为主，slave提供读，即使读写分离的情况，以读多写少为准。比如电商网站中的商品，读的多，写的少。

总的来说，单机版Redis问题概括：

• 机器故障
• 容量瓶颈
• QPS瓶颈

12.1 那么主从复制的原理是什么呢？

上面已经说明了为什么需要主从复制，现在我们来说说原理

主从复制分为全量同步和增量同步：

A、全量同步

Redis全量复制一般发生在Slave初始化阶段，这时Slave需要将Master上的所有数据都复制一份。具体步骤如下：

• 从服务器连接主服务器，发送SYNC命令。
• 主服务器接收到SYNC命令后，开始执行BGSAVE命令生成RDB文件并使用缓冲区记录此后执行的所有写命令。
• 主服务器BGSAVE执行完后，向所有从服务器发送快照文件，并在发送期间继续记录被执行的写命令。
• 从服务器收到快照文件后丢弃所有旧数据，载入收到的快照。
• 主服务器快照发送完毕后开始向从服务器发送缓冲区中的写命令
• 从服务器完成对快照的载入，开始接受命令请求，并执行来自主服务器缓冲区的写命令。

完成上面几个步骤后就完成了从服务器数据初始化的所有操作，从服务器此时可以接受来自用户的读请求。

B、增量同步

Redis增量复制是指Slave初始化后开始正常工作时主服务器发生的写操作同步到从服务器的过程。增量复制的过程主要是主服务器每执行一个写命令就会向从服务器发送相同的写命令，从服务器接收并执行收到的写命令。

C、Redis主从同步策略