数据库（3）Redis基础

2016-07-13

一、概要

背景

文件，是全量IO扫描，放硬盘上，吞吐只有百MB/s，寻址时间ms级别。
mysql等数据库，通过datapage分治，把索引（B+Tree）放内存，内存中寻址ns级别。当并发大的时候，吞吐还是受硬盘影响。
同一数据，内存占用的大小会比磁盘小。

那么，能不能把全部数据都放内存里？关系数据库可以做到，例如SAP HANA，太贵。都放磁盘上，太慢。

上述两个极端，折中，可选用非关系型数据库是redis、memcache。将最频繁使用的部分热点数据放redis，不常用的放mysql。

介绍

『Redis』，叫做远程字典服务（REmote DIctionay Server取首字母），是一种开源的NoSQL（非关系型数据库）数据库。由antirez开发，是c语言编写的一款开源的基于内存的数据结构存储器，常用于数据库、缓存和消息中间件。
Redis结构丰富，提供字符串、散列、列表、集合、有序集合、HyperLogLog、位图、流、坐标等一系列丰富的数据结构。用户可通过流水线、事务、Lua脚本、模块等内置的特性拓展自定义数据结构。
Redis功能完备，提供自动过期、流水线、事务、数据持久化、发布和订阅（消息中间件）、主从复制、集群高可用（Sentinel和Cluster）等附加功能，可用作分布式锁。
Redis性能优秀，它将所有数据存储在内存中，读写速度非常快，支持并发10W QPS。并且实现数据结构和特性时选用高效的算法来处理操作并节省内存。
Redis单进程单线程，是线程安全的，采用IO多路复用机制（EPOLL）。避免了不必要的上下文切换，不用去考虑各种锁的性能消耗。可用来实现并行的串行化。但从6.x开始，开始支持io多线程。
Redis支持广泛，无论大小公司，或者不同编程语言，都可方便的使用。

安装

免安装运行，访问『Try Redis』](https://try.redis.io/)，可以在线运行大部分操作命令。

Linux安装：

$ sudo yum install gcc make #安装依赖工具

$ wget http://download.redis.io/releases/redis-5.0.9.tar.gz
$ tar xzvf redis-5.0.9.tar.gz
$ cd redis-5.0.9

# $ sudo yum install git #安装依赖工具
# $ git clone https://github.com/antirez/redis.git #也可以去git里clone
# $ cd redis
$ make #编译Makefile
$ make test #测试，如报错可能需要安装tcl最新版本
$ make PREFIX=/opt/redis5 install # 可不执行，直接进入src目录使用。用于安装到其他目录。
$ cd /src
$ ./redis-server #启动服务器，可指定配置
$ ./redis-server --port 10086 #启动服务器，可指定端口
$ ./redis-server ../redis.conf  #启动服务器，可指定配置文件
$ ./reids-cli # 启动客户端

#追踪redis进程和内核的调用
$ yum install -y strace
$ strace -ff -o ~/tmp/out ./redis-server

常用环境配置

# 配置redis环境变量
$ vi /etc/profile
export REDIS_HOME=/opt/redis5
export PATH=$PATH:$REDIS_HOME/bin
$ . /etc/profile #生效，等价于source /etc/profile
$ redis-cli # 可用

# 开机启动
$ cd utils/
$ ./install_server.sh #如报错systemd，需要修改脚本
Selected config: #设置参数
Port           : 6379
Config file    : /etc/redis/6379.conf
Log file       : /var/log/redis_6379.log
Data dir       : /var/lib/redis/6379
Executable     : /opt/redis5/bin/redis-server
Cli Executable : /opt/redis5/bin/redis-cli
Copied /tmp/6379.conf => /etc/init.d/redis_6379
Installing service...
Successfully added to chkconfig!
Successfully added to runlevels 345!
Installation successful!
$ service redis_6379 status #查看状态
$ service redis_6379 start #启动redis
$ service redis_6379 stop #关闭redis，如设置了密码可能无法关闭，需要更改脚本/etc/init.d/redis_6379，设置密码
$ service redis_6379 restart #重启redis

mac和win10安装，推荐docker。

$ docker run --name redis -d -p 6379:6379 redis:latest
$ docker run --name redis -d -p 6379:6379 redis:latest -v $PWD/redis.conf:/etc/redis/redis.conf -v /myredis/conf/redis.conf:/usr/local/etc/redis/redis.conf # 映射本地conf文件
$ docker run -it redis /bin/bash
root@960ff74cda00:/data# redis-cli -h 127.0.0.1 -p 6379 -a 123456 # redis-cli为客户端，-p为端口，-h为redis地址，-a为密码
$ auth 123456 #如设置密码可这样校验

mac本地安装

1
2
3

$ brew install redis #brew安装
$ cat /usr/local/etc/redis.conf  #修改配置文件
$ /usr/local/bin/redis-server /usr/local/etc/redis.conf #本地启动redis

连通测试

redis-cli客户端连通测试：

$ docker exec -it 960f /bin/bash
root@960ff74cda00:/data# redis-cli
127.0.0.1:6379> ping #命令
PONG #命令回复，代表正常
> clear #清屏
> quit #退出

python代码测试使用

# redis-py客户端，安装命令：pip install redis
from redis import Redis

client = Redis() # 如需要自定义配置，client = Redis(host='x.x.x.x',password="xxx",port=6379)

if client.ping() is True:
    print("connecting")
else:
    print("disconnecting")

如果使用可视化客户端，推荐官方RedisInsight
如果需要监控redis，可使用Grafana

配置文件

include /path/to/local.conf #可通过include引用配置
loadmodule /path/to/my_module.so #通过loadmodule自定义模块

#网络监听相关NETWORK
bind 127.0.0.1 -::1 #如需要外部访问，需要注释掉
protected-mode no #关闭保护模式
port 6379 #监听端口
timeout 0 #客户端超时时间，0关闭
tcp-keepalive 300 # 周期性的使用SO_KEEPALIVE检测客户端是否还处于健康状态
requirepass 123456 # 密码设置

# 通用GENERAL
daemonize no #是否以守护进程启动
pidfile /var/run/redis_6379.pid #配置PID文件路径
loglevel notice # 日志级别，默认为notice适量，warning为重要，verbose为较多，debug为大量。
logfile "" # 日志文件路径
databases 16 # 有16个数据库，默认为0

# 持久化SNAPSHOTTING
#save "" #save为空，代表无持久化，单纯用作缓存
save 900 1 #表示900秒内如果至少有1个key 的值变化，则保存
save 300 10 #表示300秒内如果至少有10个key的值变化，则保存
save 60 10000 #表示60秒内如果至少有10000个key的值变化，则保存
stop-writes-on-bgsave-error yes #当启用了RDB且最后一次后台保存数据失败，Redis是否停止接收数据
rdbcompression yes #在存储快照后，我们还可以让redis使用CRC64算法来进行数据校验
dbfilename dump.rdb #设置快照的文件名
dir ./ #设置快照文件的存放路径，当前目录

#赋值REPLICATION，slave都换成了replica
replica-serve-stale-data yes #复制正在进行或中断时，replica仍会响应请求
replica-read-only yes #replica是否为只读Redis
epl-diskless-sync no #主从数据复制是否使用无硬盘复制功能

#安全SECURITY
requirepass 123456 #密码
rename-command FLUSHDB "" #重命名命令-清空数据库
rename-command FLUSHALL "" #重命名命令-清空记录

#客户端CLIENT
maxclients 10000 #设置客户端最大并发连接数，默认无限制

#内存管理MEMORY MANAGEMENT
maxmemory <bytes> #设置Redis的最大内存，如果设置为0表示不作限制。
maxmemory-policy noeviction #当内存使用达到maxmemory设置的最大值时，redis使用的内存清除策略，有以下6种。
# volatile-lru，利用LRU算法移除设置过过期时间的key
# allkeys-lru，利用LRU算法移除任何key 
# volatile-random，移除设置过过期时间的随机key 
# allkeys-random，移除随机key
# volatile-ttl，移除即将过期的key(minor TTL) 
# noeviction，不移除任何key，只是返回一个写错误 ，默认选项
# redis4增加了LRU的策略。LRU（Least Recently Used）是淘汰最长时间没有被使用的key。LFU（Least Frequently Used）是淘汰一段时间内，使用次数最少的key。
maxmemory-samples 5 #随机样本检测

#APPEND ONLY MODE
appendonly no #默认值为no，即使用的是rdb方式持久化。但是redis如果中途宕机，会导致可能有几分钟的数据丢失，根据save来策略决定。
#Append Only File是另一种持久化方式，可以提供更好的持久化特性。Redis会把每次写入的数据在接收后都写入appendonly.aof文件，每次启动时Redis都会先把这个文件的数据读入内存里，先忽略RDB文件。
appendfilename "appendonly.aof" #aof文件名
auto-aof-rewrite-min-size 64mb #设置触发自动AOF文件重写所需的最小AOF文件体积
auto-aof-rewrite-percentage 100 #设置触发自动AOF文件重写所需的文件体积增大比例
# aof-use-rdb-preamble yes # 当appendonly是yes时，且打开了这行，则为RDB-AOF混合持久化模式

#Lua脚本LUA SCRIPTING
lua-time-limit 5000 #lua脚本执行的最大时间，单位为ms

#集群REDIS CLUSTER
cluster-enabled no #集群开关，默认是不开启集群模式。
cluster-config-file nodes-6379.conf #集群配置文件的名称，文件由redis自动更新
cluster-node-timeout 15000 #节点互连超时的阀值，集群节点超时毫秒数
cluster-replica-validity-factor 10 #用来判断slave节点与master断线的时间是否过长
cluster-migration-barrier 1 #master的slave数量大于该值，slave才能迁移到其他孤立master上
cluster-require-full-coverage yes #集群全部的slot有节点负责，集群状态才为ok，才能提供服务

基础命令


> select 1 #根据索引切换到指定的数据库，默认为0，默认有16个库
OK
[1]> #命令行会显示当前数据库index
> move key 1 #把某个key移到库1，如同名会放弃
> swapdb 2 3 #互换数据库2和3，该命令通过指针实现，复杂度O(1)，不会阻塞
> dbsize #当前库大小
(integer) 0
> keys * #列出所有key，当数据较多时慎用。keys user::*代表user::为前缀的键，keys user::?匹配单个字符，keys user::[abc]匹配user::a或user::b或user::c。keys user::[a-c]等价keys user::[abc]
(empty list or set)
> scan 0 #渐进方式迭代数据库中的键，一般用来取代keys操作。开始的游标给0，后续根据返回值进行迭代
1) "11" #代表下次要输入scan 11进行查看。当返回为0代表已进行一次完整迭代
> scan 0 match keys::* count 10 #匹配符、期望数量
#还有hscan myhash 0，sscan myset 0，zscan myzset 0等迭代命令
> set name "herr" #设置key
> type name #key类型，字符串、HyperLogLog和位图都会返回string
string
> randomkey #获取随机key
"name"
> exists name #key是否存在
(integer) 1
> get name #获取key
"herr"
> expire name 100 #设置过期时间s，等同于用ms表示的命令pexpire name 100000，也可使用set命令的ex和px选项set后设置过期时间，将set和expire两步操作一起执行，保证原子性
(integer) 1
> expireat name 1574180000 #时间戳时间到来后自动移除，可用ms表示的pexpireat name 1574180000000
> ttl name #查询过期时间，pttl获取ms数
(integer) 98
> persist name #删除过期时间
(integer) 1
> ttl name # 获取剩余生存时间，无过期时间则为-1。如毫秒计算可使用pttl。在999ms以下，ttl会返回0，而pttl可正常返回毫秒数
(integer) -1
> del name #删除key
(integer) 1
> unlink name #以异步方式移除指定的键，del是同步方式，避免大量元素需要删除造成阻塞
> rename name new #修改键名，如键名存在会覆盖
> renamenx name new #在新键名未占用时修改
> object encoding name #查看字符串的内部编码，有可能是以下3种的一个
"int" / "embstr" / "raw"

系统信息

> help #帮助
redis-cli 6.0.6
To get help about Redis commands type:
      "help @<group>" to get a list of commands in <group>
      "help <command>" for help on <command>
      "help <tab>" to get a list of possible help topics
      "quit" to exit
> help @list #查看list的所有命令
  LPUSH key element [element ...]
  summary: Prepend one or multiple elements to a list
  since: 1.0.0
> help lpush #查看lpush命令的帮助
  LPUSH key element [element ...]
  summary: Prepend one or multiple elements to a list
  since: 1.0.0
  group: list
> info server # 一般 Redis 服务器信息
> info clients # 已连接客户端信息
> info memory # 内存信息
> info persistence # RDB 和 AOF 的相关信息
> info stats # 一般统计信息
> info replication # 主/从复制信息
> info cpu # CPU 计算量统计信息
> info commandstats # Redis 命令统计信息
> info cluster # Redis 集群信息
> info keyspace # 数据库相关的统计信息
> flushdb async #清空当前库，慎用，为同步移除，可使用async做异步移除
OK
> flushall async #清空所有库，慎用，为同步移除，可使用async做异步移除
OK
> shutdown #关闭服务器

二、常用数据类型

类型	特性	场景
string	可包含任何二进制数据，最大512MB	缓存、计数、限流、共享session、分布式锁
hash	键值对，适合存储对象	用户信息、页面访问量、聚合数据
list	双向链表，元素有序可重复（最多2^32-1个），两端都可插入弹出元素	消息队列（lpush+rpop，队列可阻塞，不支持ack）、栈（lpush+lpop）、文章列表（分页）
set	哈希表实现，元素无序不重复（最多2^32-1个），提供交集、并集、差集操作	共同标签（好友），点赞等唯一性操作、已中奖的无法再抽奖spop
zset	增加score权重，元素按score有序排列	排行榜、带权重的消息队列
HyperLogLog	计算集合的基数而创建的概率算法	ip统计等，每周/每月/每年计数器pfmerge
GEO	地理位置坐标相关操作	坐标存取、距离计算、范围查找
bitmap	本质还是个string，通过一个bit位来表示某元素状态	大量用户的签到、在线等统计

string（字符串）

内部编码有3种

int，8个字节的长整型，redis启动时会建立10000个0-9999的redisObject变量作为共享变量
embstr，小于等于44个字节的字符串，包括浮点数，embedded string，sds结构体和redisObject对象分配在连续的内存空间
raw，大于44个字节的字符串，内存空间不连续

> set name  "herr" # 设置值
OK
> set name  "iherr" # 覆盖值
OK
> get name # 获取值
"iherr"
> set pwd "123" NX #在键没有值的情况下设置，等同于setnx pwd "123"
OK
> set pwd "123456" NX # 无法
(nil)
> get pwd
"123"
> set pwd "123456" XX #在键有值的情况下覆盖
OK
> get pwd
"123456"
> set pwd1 "123456" XX #无法
(nil)
> get pwd1 # 如没有值则返回空值
(nil)
> getset pwd "123" #获取旧值并设置新值，如旧值不存在则返回空值
"123456"

> set city "bj" EX 10 #设置过期时间，EX是秒，PX为毫秒，等同于set city "bj" px 10000
OK
> setex city 10 "bj" #等同于上一句
OK
> append city "-china" #追加，bj-china。如key值不存在，则执行set操作
(integer) 8
> strlen city
(integer) 8
> incr age #递增
(integer) 19
> decr age #递减
(integer) 18
> incrby age 10 #设置步长
(integer) 28
> decrby age 10
(integer) 18

> mset name herr sex male #批量设置
OK
> mget name sex #批量获取
1) "herr"
2) "male"
> getrange name 1 -1 #字符串截取，1和-1为索引，在redis中，正数索引从开头的0开始，负数索引从结尾的-1开始
"err"
> setrange name 2 oo #字符串range替换，从索引2开始替换，替换的长度取决于新内容的长度。如果索引大于长度，则代表会扩充字符串，扩充的长度等于索引。
(integer) 4
> get name
"heoo"

hash（哈希，字典）

哈希类型的内部编码有两种：

ziplist（压缩列表）：当哈希类型元素个数小于hash-max-ziplist-entries配置（默认512个）同时所有值都小于hash-max-ziplist-value配置（默认64字节）时使用。ziplist使用更加紧凑的结构实现多个元素的连续存储，所以比hashtable更加节省内存。
hashtable（哈希表）：当ziplist不能满足要求时，会使用hashtable。

hash较string优缺点：

1、优点：当数据量大，如使用hash会导致key值变少，在执行持久化，统计、查找等操作时，减少内存和cpu消耗。
2、缺点，hash命令较string少，且无法给某个属性单独设置过期时间。

> hset myhash name herr #设置
(integer) 1
> hget myhash name #获取
"herr"
> hmset myhash age 18 sex "male" #批量设置
OK
> hmget myhash age sex #批量获取
1) "18"
2) "male"
> hgetall myhash #取所有键值，无序存储，可能会得到不同结果
1) "name"
2) "herr"
3) "age"
4) "18"
5) "sex"
6) "male"
> hkeys myhash #只取key
1) "name"
2) "age"
3) "sex"
> hvals myhash #只取value
1) "herr"
2) "18"
3) "male"
> hlen myhash #长度
(integer) 3
> hdel myhash sex #删除
(integer) 1
> hincrby myhash age 2 #递增2
(integer) 20
> hexists myhash age #是否存在
(integer) 1
> hsetnx myhash age 10 #设置失败
(integer) 0

list（列表）

列表的内部编码有两种：

ziplist（压缩列表）：当哈希类型元素个数小于list-max-ziplist-entries配置（默认512个）同时所有值都小于list-max-ziplist-value配置（默认64字节）时使用。ziplist使用更加紧凑的结构实现多个元素的连续存储，所以比hashtable更加节省内存。
linkedlist（链表）：当ziplist不能满足要求时，会使用linkedlist。

> lpush mylist a b c #左侧推入，有lpushx命令，只对已存在的列表执行左侧推入
(integer) 3
> rpush mylist x y z #右侧推入，有rpushx命令，只对已存在的列表执行右侧推入
(integer) 6
> lrange mylist 0 -1 #数据集合
1) "c"
2) "b"
3) "a"
4) "x"
5) "y"
6) "z"
> lpop mylist #左侧弹出
"c"
> rpop mylist #右侧弹出
"z"
> llen mylist #长度
(integer) 4
> lrem mylist 0 b # 移除，count > 0 : 从表头开始向表尾搜索，count < 0 : 从表尾开始向表头搜索，移除相等的元素count个。count = 0 : 移除所有相等的值。
(integer) 1
> lrange mylist 0 -1
1) "a"
2) "x"
3) "y"
> lindex mylist 1 #根据index查询
"x"
> lset mylist 1 xx #根据index设置，只能对已存在的索引进行设置
OK
> lrange mylist 0 -1
1) "a"
2) "xx"
3) "y"
> ltrim mylist 0 1 # 根据index范围截取，可ltrim key 1 0用于删除
OK
> lrange mylist 0 -1
1) "a"
2) "xx"
> linsert mylist before a 1 #在元素a前面插入1，只会处理第1个值
(integer) 3
> linsert mylist after a 2 #在元素a后面插入2
(integer) 4
> lrange mylist 0 -1
1) "1"
2) "a"
3) "2"
4) "xx"
> ltrim mylist 0 2 # 根据索引修剪列表
OK
> lrange mylist 0 -1
1) "1"
2) "a"
3) "2"
> rpoplpush mylist mylist2 #mylist右侧pop，左侧push到mylist2。当两个列表相同时，则代表将列表最右侧元素移到列表最左侧。
> sort mylist asc|desc STORE sorted-mylist #返回排序后的list，原有mylist保持不变。可对list、set、zset的键的值进行排序。可选择将排序结果1保存到另一个key中
> blpop mq 10 #阻塞式左侧弹出。会先阻塞，直到mq里有值或者超过时效
1) "mq" #如超过时效会返回空
2) "1"
(7.19s) #提示阻塞了多久
> rpush mq 1
(integer) 1
> brpop mq 10 #阻塞式右侧弹出。会先阻塞，直到mq里有值或者超过时效
              #会一直阻塞

set（集合）

集合类型的内部编码有两种：

intset（整数集合）：当集合中的元素都是整数且元素个数小于set-max-intset-entries配置（默认512个）时，redis会选用intset来作为集合的内部实现，从而减少内存的使用。
hashtable（哈希表）：当intset不能满足要求时，会使用hashtable。

如数据集可以无序且不重复，优先使用set，添加删除的复杂度为O(1)，效率比list高。
如数据集有序且不重复，优先使用zset。
如数据集有序且可重复，只能使用list。

> sadd myset t1 t2 t3 #添加数据
(integer) 3
> smembers myset #数据集合
1) "t2"
2) "t1"
3) "t3"
> scard myset #个数
(integer) 3
> srem myset t2 #删除
(integer) 1
> scard myset #删除后个数
(integer) 2
> sismember myset t2 #成员是否存在
(integer) 0
> srandmember myset #随机获取集合中的元素，可指定数量
"t3"
> smembers myset #srandmember不会影响集合的值
1) "t1"
2) "t3"
> spop myset #从集合中随机弹出一个元素，可指定数量
"t1"
> smembers myset #spop会影响集合的值
1) "t3"
> smove myset myset2 t3 #元素t3移动
(integer) 1
> smembers myset
(empty array)
> smembers myset2
1) "t3"
#inter为交集，union为并集，diff为差集
> sadd s1 a b c d
(integer) 4
> sadd s2 c d e f
(integer) 4
> sinter s1 s2 #执行交集
1) "c"
2) "d"
> sinterstore s1-inter-s2 s1 s2 #执行交集后存储
(integer) 2
> smembers s1-inter-s2
1) "c"
2) "d"
> sunion s1 s2 #执行并集
1) "c"
2) "b"
3) "d"
4) "e"
5) "a"
6) "f"
> sdiff s1 s2 #执行差集
1) "a"
2) "b"

zset（sorted set，有序集合）

有序集合类型的内部编码有两种：

ziplist（压缩列表）：当有序集合的元素个数小于list-max-ziplist-entries配置（默认128个）同时所有值都小于list-max-ziplist-value配置（默认64字节）时使用。ziplist使用更加紧凑的结构实现多个元素的连续存储，更加节省内存。
skiplist（跳跃表）：当不满足ziplist的要求时，会使用skiplist。

> zadd myzset 1 z1
> zadd myzset 2 z2
> zadd myzset 3 z3
> zrange myzset 0 -1 #根据范围获取数据集合，可使用withscores参数一并获取分数
1) "z1"
2) "z2"
3) "z3"
> zscore myzset z2 #获取分数
"2"
> zrangebyscore myzset 2 5 #获取指定分数范围的值，可使用withscores和limit参数
1) "z2"
2) "z3"
> zrevrangebyscore myzset 5 2 #获取指定分数范围的值，逆序
1) "z3"
2) "z2"
> zcard myzset #获取元素数量
(integer) 3 
> zcount myzset 2 5 #获取指定分数范围的元素数量
(integer) 2
> zincrby myzset 1 z1 #增加某元素分数
"2"
> zrem myzset z1 #删除一个或多个元素
(integer) 1
> zrank myzset z3 #查看某元素排名（升序）
(integer) 1
> zrevrank myzset z3 #查看某元素排名（降序）
(integer) 0
> zremrangebyscore myzset 0 2 #按照分数范围删除元素
(integer) 1
> zremrangebyrank myzset 0 1 #按照排名范围删除元素
(integer) 1

> zpopmax z1 2 #弹出分值最高的2个成员
> zpopmin z1 2 #弹出分值最低的2个成员
> bzpopmax z1 10 #阻塞式最大元素弹出，时效为10s
> bzpopmmin z1 10 #阻塞式最小元素弹出，时效为10s

> zadd zset1 1 a 1 b 1 c
(integer) 3
> zadd zset2 2 c 2 d 2 e
(integer) 3
> zunionstore unionzset 2 zset1 zset2
(integer) 5
> zinterstore interzset 2 zset1 zset2
(integer) 1

# 字典序，如分值相同，则按照字典序进行排序。
> zrangebylex words - + #代表字典序从无穷小到无穷大的正序
> zrevrangebylex words + [b #代表字典序从b到无穷大的逆序
> zlexcount words [a (c #代表字典序为a和b范围的成员数量
> zremrangebylex words [b (c #代表移除字典序为b的成员

Geo

Redis 3.2版本添加的新特性
可以将经纬度格式的地理坐标存储到redis中，并进行距离计算、范围查找等计算

> geoadd mygeo 116.401394 39.916263 tiananmen 116.433015 39.909179 beijingxizhan 116.417851 39.914271 wangfujing 116.392267 39.913994 zhongnanhai 116.404341 39.906633 qianmen #添加地理位置坐标
(integer) 5
> geopos mygeo tiananmen #获取地理位置坐标
1) 1) "116.40139371156692505"
   2) "39.91626286262923884"
> geodist mygeo tiananmen beijingxizhan km #计算两个位置的距离
"2.8106"
> georadius mygeo 116.404341 39.912666 2 km #根据经纬度坐标获取指定范围内的坐标集合
1) "zhongnanhai"
2) "tiananmen"
3) "qianmen"
4) "wangfujing"
> georadiusbymember mygeo tiananmen 2 km #根据某个位置对象获取指定范围内的坐标集合
1) "zhongnanhai"
2) "tiananmen"
3) "qianmen"
4) "wangfujing"
> geohash mygeo tiananmen #返回位置对象的Geohash值。GeoHash是一种地址编码方法。他能够把二维的空间经纬度数据编码成一个字符串
1) "wx4g0f8cj40"
#本质是个zset
> zrange mygeo 0 -1
1) "qianmen"
2) "beijingxizhan"
3) "zhongnanhai"
4) "tiananmen"
5) "wangfujing"
> zrem mygeo qianmen #删除qianmen
(integer) 1

HyperLogLog

Redis在2.8.9版本添加了HyperLogLog结构
HyperLogLog是用来做基数(不重复元素)统计的概率算法，统计出的是近似值而不是实际值
在输入元素的数量或者体积非常非常大（2^64个）时，计算基数所需的空间总是固定的、并且是很小的（12KB内存），比单独存储所有元素并进行统计操作，占用的内存小的多

> pfadd mypf "redis" #添加指定元素
(integer) 1
> pfadd mypf "mysql"
(integer) 1
> pfadd mypf "oracle"
(integer) 1
> pfcount mypf #计算基数估算值
(integer) 3
> pfadd mypf2 "redis" "mongo" #添加多个指定元素
(integer) 2
> pfmerge mypf mypf2 #将mypf2合并到mypf中
OK
> pfcount mypf #计算最新基数估算值
(integer) 4

Stream

Stream是Redis 5.0版本新增加的数据结构，是基于RadixTree（基数树）数据结构实现的。
Stream主要用于消息队列，借鉴了kafka。Redis本身是有一个发布订阅 (pub/sub) 来实现消息队列的功能，但它有个缺点就是消息无法持久化，如果出现网络断开、宕机等，消息就会被丢弃。列表可实现消息队列，但查找需要遍历整个列表，效率不高。有序集合可高效的进行范围查找，但没有列表和发布订阅提供的阻塞弹出。而且以上3种结构，他们的元素都只能是单个值。Stream是上面3种数据结构的综合体，是实现消息队列应用的最佳选择。
Stream提供了消息的持久化和主备复制功能，可以让任何客户端访问任何时刻的数据，并且能记住每一个客户端的访问位置，还能保证消息不丢失。

每个Stream都有唯一的名称，它就是Redis的key，在我们首次使用xadd指令追加消息时自动创建。
每个Stream都可以挂多个消费组，每个消费组会有个游标last_delivered_id在Stream数组之上往前移动，表示当前消费组已经消费到哪条消息了。
每个消费组(Consumer Group)都有一个Stream内唯一的名称，消费组不会自动创建，它需要单独的指令xgroup create进行创建，需要指定从Stream的某个消息ID开始消费，这个ID用来初始化last_delivered_id变量。
每个消费组的状态都是独立的，相互不受影响。也就是说同一份Stream内部的消息会被每个消费组都消费到。同一个消费组可以挂接多个消费者，这些消费者之间是竞争关系，任意一个消费者读取了消息都会使游标last_delivered_id往前移动。每个消费者者有一个组内唯一名称。
消费者(Consumer)内部会有个状态变量pending_ids，它记录了当前已经被客户端读取的消息，但是还没有ack。如果客户端没有ack，这个变量里面的消息ID会越来越多，一旦某个消息被ack，它就开始减少。这个pending_ids变量在Redis官方被称之为PEL，也就是Pending Entries List，这是一个很核心的数据结构，它用来确保客户端至少消费了消息一次，而不会在网络传输的中途丢失了没处理。
消费者组消息，通过xadd创建，状态为“未递送”。通过xreadgroup操作，状态变为“待处理”（pending），通过xack操作，状态变为“已确认”。

#生产消费消息
> XADD mystream * msg 1 #用于在stream（流数据）中追加消息，* 代表消息id方案，由redis生成消息ID
"1605583908280-0" #Redis生成的消息ID是保证单调递增的，通过毫秒时间+顺序编号生成，哪怕本地时间调整。
> XREAD count 1 STREAMS mystream 0 #ID为0表示从第一条消息开始。[COUNT count]用于限定获取的消息数量。默认为非阻塞模式。
1) 1) "mystream"
   2) 1) 1) "1605583908280-0"
         2) 1) "msg"
            2) "1"
> XREAD block 1000 STREAMS mystream $ #使用[BLOCK milliseconds]代表阻塞模式并设置阻塞时长。在阻塞模式中，ID可以使用特殊符号$表示从尾部开始消费，只接受新消息，当前Stream消息会全部忽略。
(nil)
(1.04s)
> XREAD BLOCK 100000 COUNT 2 STREAMS mystream 0 #id为0，数量为2，可获取，则不会阻塞，会无视count参数，直接返回1条数据
1) 1) "mystream"
   2) 1) 1) "1606738704740-0"
         2) 1) "msg"
            2) "1"
> XREAD BLOCK 100000 COUNT 2 STREAMS mystream1 0 # mystream1因为不存在会阻塞，等待推入新元素后才会显示下方信息
1) 1) "mystream1"
   2) 1) 1) "1606738930172-0"
         2) 1) "msg"
            2) "2"
(38.55s)
> XADD mystream1 * msg 2 #在mystream1阻塞时执行
"1606738930172-0"


> multi
OK
> XADD mq * msg 1
QUEUED
> XADD mq * msg 2
QUEUED
> XADD mq * msg 3
QUEUED
> XADD mq * msg 4
QUEUED
> XADD mq * msg 5
QUEUED
> exec
1) "1606149375099-0"
2) "1606149375099-1"
3) "1606149375099-2"
4) "1606149375099-3"
5) "1606149375099-4"
> XTRIM mq MAXLEN 3 #对流进行裁剪，最大长度是3
(integer) 2 #移除了2个
> XDEL mq 1606149375099-3 #根据ID移除指定元素
(integer) 1
> XLEN mq #获取流包含的元素数量
(integer) 2
> XRANGE mq - + #访问流中元素，ID从负无穷到正无穷
1) 1) "1606149375099-2"
   2) 1) "msg"
      2) "3"
2) 1) "1606149375099-4"
   2) 1) "msg"
      2) "5"
> XRANGE mq - + count 1 #只取1个
1) 1) "1606149375099-2"
   2) 1) "msg"
      2) "3"

> DEL mq #清空mq
(integer) 1
> multi
OK
> XADD mq * msg 1 
QUEUED
> XADD mq * msg 2
QUEUED
> XADD mq * msg 3
QUEUED
> XADD mq * msg 4
QUEUED
> XADD mq * msg 5
QUEUED
> exec
1) "1606738294645-0" #消息ID采用时间戳+序号的方式生成，如同一个时间戳，序号会递增
2) "1606738294645-1"
3) "1606738294645-2"
4) "1606738294645-3"
5) "1606738294645-4"
> XREAD COUNT 3 STREAMS mq 1606738290000 #从mq流中读取大于该ID的3个元素
1) 1) "mq"
   2) 1) 1) "1606738294645-0"
         2) 1) "msg"
            2) "1"
      2) 1) "1606738294645-1"
         2) 1) "msg"
            2) "2"
      3) 1) "1606738294645-2"
         2) 1) "msg"
            2) "3"
> XREAD COUNT 2 STREAMS mq 0-0 #迭代流，找起始的两个元素
1) 1) "mq"
   2) 1) 1) "1606738294645-0"
         2) 1) "msg"
            2) "1"
      2) 1) "1606738294645-1"
         2) 1) "msg"
            2) "2"

#消费者组

> XGROUP CREATE mq mqGroup 0 #用于在消息队列mq上创建消费mqGroup，最后一个参数0，表示该组从第一条消息开始消费。这个ID用来初始化last_delivered_id变量。

#三个在同一组 mpGroup 消费者consumerA、consumerB、consumerC在消费消息，id为0，3个消费者之间读取元素不受影响
> XREADGROUP group mqGroup consumerA count 1 streams mq 0 
> XREADGROUP group mqGroup consumerB count 1 streams mq 0 
> XREADGROUP group mqGroup consumerC count 1 streams mq 0 

#用于组mqGroup内消费者consumerA在队列mq中消费，符号>表示未被组内消费的起始消息，会产生互斥，消费方案为，A->1, A->2, B->3, A->4, C->5
> XREADGROUP group mqGroup consumerA count 1 streams mq > 

1) 1) "mq"
   2) 1) 1) "1605585301082-0"
         2) 1) "msg"
            2) "1"
> XREADGROUP group mqGroup consumerA count 1 streams mq >
1) 1) "mq"
   2) 1) 1) "1605585301082-1"
         2) 1) "msg"
            2) "2"
> XREADGROUP group mqGroup consumerB count 1 streams mq >
1) 1) "mq"
   2) 1) 1) "1605585301082-2"
         2) 1) "msg"
            2) "3"
> XREADGROUP group mqGroup consumerA count 1 streams mq >
1) 1) "mq"
   2) 1) 1) "1605585301082-3"
         2) 1) "msg"
            2) "4"
> XREADGROUP group mqGroup consumerC count 1 streams mq >
1) 1) "mq"
   2) 1) 1) "1605585301082-4"
         2) 1) "msg"
            2) "5"

#等待列表
> XPENDING mq mqGroup #mqGroup的Pending情况
1) (integer) 5 # 5个已读取但未处理的消息
2) "1605585301082-0" # 起始ID
3) "1605585301082-4" # 结束ID
4) 1) 1) "consumerA" # 消费者A有3个
      2) "3"
   2) 1) "consumerB" # 消费者B有1个
      2) "1"
   3) 1) "consumerC" # 消费者C有1个
      2) "1"

> XPENDING mq mqGroup - + 10 consumerA #获取具体某个消费者的Pending详情
1) 1) "1605585301082-0" #消息ID
   2) "consumerA" #消费者
   3) (integer) 1350341 #IDLE，已读取时长
   4) (integer) 3 #读取次数
2) 1) "1605585301082-1"
   2) "consumerA"
   3) (integer) 1345206
   4) (integer) 1
3) 1) "1605585301082-3"
   2) "consumerA"
   3) (integer) 1168915
   4) (integer) 1 

> XACK mq mqGroup 1605585301082-0 #通知消息处理结束，用消息ID标识
(integer) 1
> XPENDING mq mqGroup - + 10 consumerA #再次查看Pending列表，只剩2个待处理消息
1) 1) "1605585301082-1"
   2) "consumerA"
   3) (integer) 1504155
   4) (integer) 1
2) 1) "1605585301082-3"
   2) "consumerA"
   3) (integer) 1327864
   4) (integer) 1

> XCLAIM mq mqGroup consumerB 1500000 1605585301082-1 #转移超过1500s的消息1605585301082-1到消费者B的Pending列表，消息的归属权用一个消费者转移到另一个消费者
1) 1) "1605585301082-1"
   2) 1) "msg"
      2) "2"
> XPENDING mq mqGroup - + 10 consumerA #consumerA中已移除
1) 1) "1605585301082-3"
   2) "consumerA"
   3) (integer) 1459810
   4) (integer) 1
> XPENDING mq mqGroup - + 10 consumerB #已转移到consumerB
1) 1) "1605585301082-1"
   2) "consumerB"
   3) (integer) 7613 #idle会重置
   4) (integer) 2 #读取次数加1
2) 1) "1605585301082-2"
   2) "consumerB"
   3) (integer) 1468401
   4) (integer) 1

> Xinfo stream mq #对stream队列信息的监控
 1) "length"
 2) (integer) 5
 3) "radix-tree-keys"
 4) (integer) 1
 5) "radix-tree-nodes"
 6) (integer) 2
 7) "groups"
 8) (integer) 1
 9) "last-generated-id"
10) "1605585301082-4"
11) "first-entry"
12) 1) "1605585301082-0"
    2) 1) "msg"
       2) "1"
13) "last-entry"
14) 1) "1605585301082-4"
    2) 1) "msg"
       2) "5"

> XINFO groups mq #对stream消费组的监控
1) 1) "name"
   2) "mqGroup"
   3) "consumers"
   4) (integer) 3
   5) "pending"
   6) (integer) 4
   7) "last-delivered-id"
   8) "1605585301082-4"

> XINFO CONSUMERS mq mqGroup #对stream消费组成员的监控
1) 1) "name"
   2) "consumerA"
   3) "pending"
   4) (integer) 1
   5) "idle"
   6) (integer) 228227
2) 1) "name"
   2) "consumerB"
   3) "pending"
   4) (integer) 2
   5) "idle"
   6) (integer) 224307
3) 1) "name"
   2) "consumerC"
   3) "pending"
   4) (integer) 1
   5) "idle"
   6) (integer) 1681015

> xgroup delconsumer mq mqGroup consumerA #删除消费者
(integer) 3
> xgroup destroy mq mqGroup #删除消费者组
(integer) 1

bitmap

位图是由多个二进制位组成的数组，但本质上还是个string，位图通过一个bit位来表示某个元素对应的值或者状态，会极大的节省储存空间。
offset为2^32-1（分配512MB）需要300ms，offset为2^30-1(分配128MB)需要80ms，offset为2^28-1（分配32MB）需要30ms，offset为2^26-1（分配8MB）需要8ms
对位图的拓展，是以字节为单位进行的，会将未被设置的二进制位初始化为0。

# h的ascii为104，二进制01101000
# e的ascii为101，二进制01100101
> setbit mybit 1 1 
(integer) 0
> setbit mybit 2 1
(integer) 0
> setbit mybit 4 1
(integer) 0
> get mybit
"h"
> getbit mybit 2
(integer) 1
> bitcount mybit #统计为1的数量，可设置
(integer) 3
> bitpos mybit 1 #查找第1个被设置为1的二进制位值
(integer) 1
> setbit mybit 1 1 
> set bm1 h
OK
> set bm2 e
OK
> bitop and bm_and bm1 bm2
(integer) 1
> bitop or bm_or bm1 bm2
(integer) 1
> bitop xor bm_xor bm1 bm2
(integer) 1
> bitop not bm_not bm1
(integer) 1
> bitfield mybit set u8 0 123 #在位图中存储整数值，0为offset
1) (integer) 0

三、流水线与事务

流水线，redis允许客户端把任意多条命令请求打包在一起，一次性的发送给服务器质性，并一次性的将执行结果全部返回给客户端。需要客户端支持。
事务，事务中所有命令都被序列化并会按序执行，并不可打断。Readis事物是原子性的，若执行则全部执行，若失败则全部失败。功能较弱，不建议过多使用。

事务总有ACID特性，redis具备ACI特性，且在特定持久化模式下具备D特性。

原子性（Atomic），都么都成功，要么都失败
一致性（Consistent），执行成功与否，不会对数据库造成破坏
隔离性（Isolate），不同事务之间是独立的
耐久性（Durable），事务执行完毕后会存储在硬盘。停机后修改也不会丢失

> multi #开启事务
OK
> set name herr 
QUEUED #命令入队
> set age 18
QUEUED
> exec #执行事务
1) OK
2) OK
> keys * #数据改动
1) "age"
2) "name"

> flushdb #清空
OK
> multi #开启事务
OK
> set name herr
QUEUED
> discard #放弃事务
OK
> keys * #数据未改动
(empty list or set)

> watch key # 可使用watch对键进行监视，如没有发生变化，则执行事务。否则拒绝事务。可看作是事务的乐观锁机制
> unwatch key #可取消对键的监视

四、订阅与发布

Redis的发布与订阅功能，可以让客户端通过广播方式，将消息同时发送给可能存在的多个客户端，且发送客户端不需要知道接收消息的客户端的具体信息。

# 起一个客户端（订阅者）
> subscribe chat1 #订阅频道
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "chat1"
3) (integer) 1
1) "message" #当频道有消息发布时会立即收到
2) "chat1"
3) "hello"
> unsubscribe chat1 #退订频道

# 另起一个客户端（订阅模式）
> psubscribe "chat*" #凡是chat前缀的频道都会匹配
Reading messages... (press Ctrl-C to quit)
1) "psubscribe"
2) "chat*"
3) (integer) 1
1) "pmessage"
2) "chat*"
3) "chat1"
4) "hello"
> psubscribe "chat*" #退订模式

# 另起一个客户端（发布者）
> pubsub channels #查看频道
1) "chat1"
> publish chat1 "hello" #向频道发布消息
(integer) 1
> pubsub numsub chat1 #查看某个频道的订阅者数量
1) "chat1"
2) (integer) 1
> pubsub numpat #查看订阅模式的数量
(integer) 1

五、持久化机制

redis为了保证效率，数据缓存在了内存中，但是会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件中，以保证数据的持久化。Redis的持久化策略有两种：

RDB(Redis DataBase)：快照形式是直接把内存中的数据保存到一个dump的文件中，定时保存，保存策略。Redis默认是快照RDB的持久化方式。
AOF(Append Only File)：把所有的对Redis的服务器进行修改的命令都存到一个日志文件里，命令的集合。AOF需要手动开启，可以配置按实时，按秒，按内核。

既想用RDB的快速恢复，又需要AOF的恢复完整性，可使用RDB-AOF混合持久化。

RDB持久化

RDB持久化产生的文件都以.rdb后缀结尾。

> save #阻塞服务器并创建RDB文件，会创建新的RDB文件，然后替换掉已有的RDB文件
OK
> bgsave #异步方式进行，会创建一个子进程执行save命令，不阻塞服务器
Background saving started

除了手动使用命令创建RDB外，还可以通过配置文件的save选项，让redis在满足执行条件时自动执行bgsave命令。

1
2
3

save 900 1 #表示900秒内如果至少有1个key 的值变化，则保存
save 300 10 #表示300秒内如果至少有10个key的值变化，则保存
save 60 10000 #表示60秒内如果至少有10000个key的值变化，则保存

RGB文件结构包含以下7部分，

RDB文件标识符，为REDIS这5个字符
版本号，4个字符的数字
设备附加信息，redis服务器和系统信息
数据库数据，0-15个库的数据依次排列。单个数据库的结构为：数据库号码、键值对总数、带过期时间的键值对数量、键值对数据。单个键值对数据的结构如下：过期时间（可选）、LUR信息（可选）、LFU信息（可选）、类型、键、值。
Lua脚本缓存，保存Lua脚本
EOF，结束符，0xFF
CRC64校验和，校验文件是否损坏
当Redis服务器启动时，会根据RDB文件进行恢复。
当使用save命令后重启，将丢失save命令之后产生的所有数据。当使用bgsave命令后重启，丢失的数据量取决于成功执行的bgsave命令的开始时间。
RDB持久化的缺陷在于，丢失的数据取决于创建RDB文件的间隔。然后RDB是全量持久化操作，会消耗大量资源，不太可能通过增加生成频率来保证数据安全。

AOF持久化

与全量式的RDB持久化功能不同，AOF提供的是增量式的持久化功能。服务器每次执行完命令后，都会以协议文本的方式将被执行的命令追加到AOF文件的末尾。
AOF持久化需要配置文件appendonly yes来开启。

冲洗：针对硬盘的多次写操作，系统不会直接把数据写入硬盘，而是会将数据写入位于内存的缓冲区中，等到满足写入条件，会执行flush系统调用，将缓冲区的数据冲洗至硬盘。使用appendfsync来控制冲洗频率。默认为everysec（每隔1s）。其他选项有always（每执行一个写命令）、no（不主动冲洗，由操作系统决定）。

重写：当命令越来越多，AOF文件会越来越大，redis可以将冗余命令进行合并重写，会生成一个全新的AOF文件。可以执行bgrewriteaof命令显式的触发重写操作，为异步命令。也可以通过配置文件的两个参数auto-aof-rewrite-min-size和auto-aof-rewrite-percentage进行设置。

AOF持久化优点：安全性高。但缺点也很明显：存储的是协议文本，文件体积会大。需要根据命令恢复，效率不高。重写也需要消耗大量资源。

RDB-AOF混合持久化

下面为RDB和AOF的比较，Redis在4.0引入了混合持久化模式。之前版本可以同时使用RDB和AOF。总的来说，在数据持久化的问题上，4.0以后的版本优先使用混合持久化。4.0前版本优先选用AOF作为数据持久化手段，把RDB作为辅助的备份手段。

名称	RDB持久化	AOF持久化
备份策略	全量备份	增量备份
保存间隔	较长	默认1秒
数据还原速度	快	一般
阻塞	save会,但bgsave或者自动不会	不会
适用性	更适合数据备份，默认开启	适合数据持久化，默认关闭
启动优先级	低	高
文件体积	小	大
恢复速度	快	慢
数据安全性	丢数据	根据策略决定
轻重	重	轻

混合持久化的配置如下，重写时会像执行BGSAVE命令一样生成RDB数据，并将这些数据写入AOF文件中，之后执行的命令会继续以协议文本的方式追加。

1 2	appendonly yes #AOF持久化模式打开 aof-use-rdb-preamble yes

当一个支持RDB-AOF混合持久化模式的Redis服务器启动并载入AOF文件时，会先检查是否包含RDB格式的内容，并优先加载后，再加载之后的AOF数据。

六、Lua脚本

redis执行lua脚本是以原子方式执行的，执行过程中其他请求会被阻塞，直到eval命令执行完毕为止。

> eval "return 'hello herr'" 0 #使用eval执行Lua脚本，0代表脚本需要处理的键数量，后面可跟key
"hello herr"
> eval "return redis.call('set',KEYS[1],ARGV[1])" 1 "msg" "herr" #KEYS数组代表传入key参数，ARGV数组代表传入arg参数，都从1开始
OK
> get msg
"herr"
> eval "return redis.pcall('set',KEYS[1],ARGV[1])" 1 "msg" "herr" #call和pcall区别在于对错误的处理，pcall会将错误包装成table返回
OK
> script load "return 'hello herr'" #可以将脚本载入脚本缓存中，生成sha1值。只执行eval也会缓存sha1值，只是不返回该值
"fe0c25e85f117b02c41823f7285a584ecd7cfcf2"
> evalsha "fe0c25e85f117b02c41823f7285a584ecd7cfcf2" 0 #根据sha1值执行脚本
"hello herr"
> script exists "fe0c25e85f117b02c41823f7285a584ecd7cfcf2" #检查脚本是否被缓存
1) (integer) 1
> script flush #移除所有已缓存脚本
OK
> script exists "fe0c25e85f117b02c41823f7285a584ecd7cfcf2" #再检查
1) (integer) 0
> script kill #强制停止正在运行的脚本，由于阻塞，因此脚本效率尽可能高。

redis在Lua5.1环境中内置了一些函数库，如4个Lua标准库base、table、string、math，以及redis（redis定制包）、bit（二进制按位操作）、struct（Lua值和C结构转换）、cjson（json编解码）、cmspack（MessagePack打包和解包）等。

脚本调试：

# cat debug.lua，lua文件 
local ping_result = redis.call("PING")
local set_result = redis.call("SET",KEYS[1],ARGV[1])
return {ping_result,set_result}

$ redis-cli --ldb --eval debug.lua "msg" , "hello herr" #使用--ldb进行异步调试。如使用--ldb-sync-mode则为同步调试。逗号前后需要有空格，否则可能会报错Lua redis() command arguments must be strings or integers
Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.
Lua debugging session started, please use:
quit    -- End the session.
restart -- Restart the script in debug mode again.
help    -- Show Lua script debugging commands.

* Stopped at 1, stop reason = step over
-> 1   local ping_result = redis.call("PING")
lua debugger> next #使用next或step命令下一步
<redis> PING #执行的命令
<reply> "+PONG" #返回的结果
* Stopped at 2, stop reason = step over #停在第2行前，等待指令
-> 2   local set_result = redis.call("SET",KEYS[1],ARGV[1])
lua debugger> print #打印已有的局部变量
<value> ping_result = {["ok"]="PONG"}
lua debugger> next #下一步
<redis> SET msg hello herr 
<reply> "+OK"
* Stopped at 3, stop reason = step over
-> 3   return {ping_result,set_result}
lua debugger> print #打印已有的局部变量
<value> ping_result = {["ok"]="PONG"}
<value> set_result = {["ok"]="OK"}
lua debugger> next

1) PONG
2) OK

(Lua debugging session ended -- dataset changes rolled back)

输出日志可用redis.debug()函数处理。调试命令如下：

Redis Lua debugger help:
[h]elp               Show this help.
[s]tep               Run current line and stop again.
[n]ext               Alias for step.
[c]continue          Run till next breakpoint.
[l]list              List source code around current line.
[l]list [line]       List source code around [line].
                     line = 0 means: current position.
[l]list [line] [ctx] In this form [ctx] specifies how many lines
                     to show before/after [line].
[w]hole              List all source code. Alias for 'list 1 1000000'.
[p]rint              Show all the local variables.
[p]rint <var>        Show the value of the specified variable.
                     Can also show global vars KEYS and ARGV.
[b]reak              Show all breakpoints.
[b]reak <line>       Add a breakpoint to the specified line.
[b]reak -<line>      Remove breakpoint from the specified line.
[b]reak 0            Remove all breakpoints.
[t]race              Show a backtrace.
[e]eval <code>       Execute some Lua code (in a different callframe).
[r]edis <cmd>        Execute a Redis command.
[m]axlen [len]       Trim logged Redis replies and Lua var dumps to len.
                     Specifying zero as <len> means unlimited.
[a]bort              Stop the execution of the script. In sync
                     mode dataset changes will be retained.

七、模块

Redis提供了流水线、事务、Lua脚本用于拓展Redis服务器的功能，但性能有损耗，编程略复杂，且可能无法满足想要的数据结构。
Redis为提升Redis的拓展性，在4.0添加了模块，允许开发者通过Redis开放的一簇API，将Redis用作网络服务和数据存储平台，通过C语言在Redis基础上构建任意的数据结构。
常用的模块有ReJSON（在Redis中存储、更新和获取JSON数据）、RediSQL（在Redis中嵌入SQLite）、RediSearch（基于Redis的全文检索）等。

$ cd /usr/local/redis/src/modules #系统自带模块
$ make #编译c后缀文件，生成so后缀的编译后文件
$ ls
gendoc.rb   helloacl.so  helloblock.c   helloblock.xo   hellocluster.so  hellodict.c   hellodict.xo  hellohook.so  hellotimer.c   hellotimer.xo  hellotype.so  helloworld.c   helloworld.xo  testmodule.c   testmodule.xo helloacl.c  helloacl.xo  helloblock.so  hellocluster.c  hellocluster.xo  hellodict.so  hellohook.c   hellohook.xo  hellotimer.so  hellotype.c    hellotype.xo  helloworld.so  Makefile       testmodule.so

> module load /usr/local/redis/redis/src/modules/helloworld.so #redis命令行中，载入某个模块
OK
> module list #列出已载入的模块
1) 1) "name"
   2) "helloworld" #名称
   3) "ver"
   4) (integer) 1 #版本号
> module unload helloworld #卸载模块
OK

ReJSON

$ git clone https://github.com/RedisLabsModules/rejson.git
$ cd rejson
$ make #编译，将so文件放入modules文件夹，也需要cargo
> module load /usr/local/redis/src/modules/rejson.so
OK
> JSON.SET user . '{"name":"herr","age":18}'
OK
> JSON.GET user
"{\"name\":\"herr\",\"age\":18}"
> JSON.GET user name
"\"herr\""

RediSQL

$ git clone https://github.com/RedBeardLab/rediSQL/
$ cargo build --release # 进入源码目录执行，用到Rust的包管理工具cargo
> module load /usr/local/redis/src/modules/libredis_sql.dylib
OK
> REDISQL.CREATE_DB test #创建数据库
OK
> REDISQL.EXEC test "create table user (name text, age int);" #创建表
1) DONE
2) (integer) 1
> REDISQL.EXEC test "insert into user values ('herr', 18);" #插入数据
1) DONE
2) (integer) 1
> REDISQL.EXEC test "select * from user;" #查询数据

RediSearch

$ git clone https://github.com/RedisLabsModules/RediSearch.git
$ cd RediSearch
$ make #编译，将so文件放入modules文件夹
> module load /usr/local/redis/src/modules/rejson.so
> FT.CREATE user SCHEMA name TEXT sex TEXT #创建了一个名为user的索引，包含两个字段
OK
> FT.ADD user user1 1.0 LANGUAGE "chinese" FIELDS name "herr" sex "male" #添加id为user1，分值为1.0，语言为汉语，归属索引为user的文档
OK
> FT.SEARCH user "herr" LANGUAGE "chinese" #查找
1
user1
name
herr
sex
male

八、多机

主从复制(master-slave replication)

Redis开启复制功能后，存储目标数据库的服务器被称为主服务器（master server），存储数据副本的服务器被称为从服务器（replica）。
一个主服务器可以拥有任意多个从服务器，且可以通过多级从服务器形成树状服务器结构。
主服务器既可以执行写操作，也可以执行读操作。而从服务器只能执行读操作。
主服务器每次执行写操作之后，都会与所有从服务器进行数据同步，以保持主从服务器之间的数据一致性。
复制功能，可以给读性能带来线性级别的提升，且可以降低系统故障时丢失数据的可能性，配合Sentinel功能，可以为整个Redis系统提供高可用性。

当本地启动了6378和6379两个redis后，需要将6379设为主，6378设为从，便可实现主从服务器拥有相同的数据。同步流程如下：

主服务器执行BGSAVE命令，生成RDB文件，并使用缓冲区存储在BGSAVE命令后执行的所有写命令。
主服务器通过套接字将RDB文件传给从服务器。Redis2.8.18版本引入无须硬盘的复制，主库不会创建RDB文件，而是新建子进程，子进程通过套接字直接将RDB文件写入从库。配置参数为repl-diskless-sync yes
从服务器接收到RDB文件并加载所有数据
从服务器加载RDB完成后，开始上线接受命令请求，主服务器会把缓冲区中的所有写命令发送给从服务器执行
主从数据达到一致状态后，会进行在线更新，每当主服务器执行完一个写命令，会将相同命令发送给从服务器执行，该过程为异步，可能导致短暂的不一致
如因故障下线的从服务器重新上线时，需要重新进行同步，Redis2.8支持增量的部分同步方式，可避免直接进行完整同步。

$ redis-cli -p 6378
127.0.0.1:6378> replicaof 127.0.0.1 6379 #也可使用slaveof，如主库有密码，则可使用配置文件的方式。会清空从数据库并，然后通过主库同步
127.0.0.1:6379> role #主库6379查看角色
1) "master" #主库
2) (integer) 1233 #主库的复制偏移量
3) 1) 1) "127.0.0.1" #记录属下的所有从服务器
      2) "6378"
      3) "1233"
127.0.0.1:6378> role #从库6378查看角色
1) "slave" #从库
2) "127.0.0.1" #主库ip
3) (integer) 6379 #主库端口
4) "connected" #有none(未建立连接)、connect(正在握手)、connecting(成功建立连接)、sync(数据同步中)、connected(进入在线更新状态)、unknown(未知)等状态
5) (integer) 1247 #从库的复制偏移量
127.0.0.1:6378> set name t #从库写会报错。如确实需要写，配置参数为replica-read-only yes
(error) READONLY You cant write against a read only replica
127.0.0.1:6378> replicaof no one #取消复制，不会清空数据库，会保留复制产生的数据

配置文件如下：

1
2
3

replicaof 127.0.0.1 6379
# 如果主库有密码
masterauth 123456

针对lua脚本的复制，有两种方式，脚本传播模式和命令传播模式。redis允许用户在脚本中选择性的设置，可通过redis.set_repl()函数进行设置。

脚本传播模式，是主库将被执行的脚本以及参数复制到AOF文件以及从服务器中。但要求函数必须是纯函数，不能是随机结果的函数。
命令传播模式，是主库将执行脚本所产生的写命令用事务包裹起来，复制到AOF文件以及从服务器中。

哨兵(sentinel)

Redis提供了RedisSentinel工具，通过心跳检测的方式监视所有主从服务器，并在某个主服务器下线时自动对其实施故障转移，构建成新的主从关系。
sentinel会继续对下线的服务器进行心跳检测，当重新上线时，会把他变成从服务器。
可通过replica-priority选项设置从服务器优先级，较高的从服务器会优先被选择。

1	$ /opt/redis5/bin/redis-sentinel /etc/redis/sentinel.conf #运行redis-sentinel工具，指定一个可写的配置文件

配置文件内容如下：

port 26379 #sentinel端口号
sentinel monitor master_db 127.0.0.1 6379 1 #可以配置多行，监听多个主库。也可启动多个sentinel组成网络。
# 只要有1个sentinel认为主库master_db出现故障，可实施故障转移，会在从库中选出新的服务器，变成主库
# quorum参数为判定下线需要的sentinel数量，例如有3台sentinel可设置为2。有5台sentinel可设置为3。
# name参数为master_db，供后续命令行使用

Sentinel管理命令

127.0.0.1:26379> sentinel masters #查看正在监视的全部主服务器信息
127.0.0.1:26379> sentinel masters master_db #查看正在监视的特定名称的主服务器相关信息，name在配置文件中设置
127.0.0.1:26379> sentinel slaves #查看正在监视的全部主服务器的从服务器信息
127.0.0.1:26379> sentinel sentinels master_db #查看正在监视的特定名称的主服务器的sentinels信息
127.0.0.1:26379> sentinel get-master-addr-by-name master_db #根据主服务器的特定名称，查看对应的额ip和端口
127.0.0.1:26379> sentinel reset #重置主服务器状态
127.0.0.1:26379> sentinel failover master_db #强制执行故障转移
127.0.0.1:26379> sentinel ckquorum #检查可用sentinel的数量
127.0.0.1:26379> sentinel flushconfig #将sentinel的配置文件重新写入硬盘

127.0.0.1:26379> sentinel monitor master_db 127.0.0.1 6379 1 #和配置文件一致，命令的方式，监视给定主服务器
127.0.0.1:26379> sentinel remove master_db #取消对主服务器的监视
127.0.0.1:26379> sentinel set master_db quorum3 #修改配置选项的值

集群(cluster)

根据数据库概述中的AKF方法论，通过复制和sentinel，解决的是X轴的拓展，实现高可用。Y轴的拓展也很容易实现，只需要不同的模块使用自己的redis即可。那么只剩下了z轴的拓展，需要分片。
Redis集群通过将数据库分散存储到多个节点来平衡各个节点的负载压力，将数据库空间划分为16384个槽（slot）来实现数据分片（sharding），集群中的各个主节点会分别处理其中的一部分槽。
Redis集群采用无代理方式，基本无性能损耗。向集群添加新节点或移除已有节点都可以在线进行，无须停机，简单易用。

集群搭建：

#快速搭建集群
$ cd utils/create-cluster #redis提供集群创建脚本，还是位于源码的utils/create-cluster
$ ./create-cluster start #创建6个节点，端口号从30001到30006
Starting 30001
Starting 30002
Starting 30003
Starting 30004
Starting 30005
Starting 30006
$ ./create-cluster create #将上述6个节点组成集群，至少包含3个master，3个slave
>>> Performing hash slots allocation on 6 nodes...
Master[0] -> Slots 0 - 5460 #主节点分配的slot情况
Master[1] -> Slots 5461 - 10922
Master[2] -> Slots 10923 - 16383
Adding replica 127.0.0.1:30005 to 127.0.0.1:30001
Adding replica 127.0.0.1:30006 to 127.0.0.1:30002
Adding replica 127.0.0.1:30004 to 127.0.0.1:30003
>>> Trying to optimize slaves allocation for anti-affinity
[WARNING] Some slaves are in the same host as their master
M: 9004ad3ff0f3fe422fd429e150e3c35750b6d12d 127.0.0.1:30001
   slots:[0-5460] (5461 slots) master
M: 44e0d2cc975d06a1a2d094b57ae2ac1a3f636202 127.0.0.1:30002
   slots:[5461-10922] (5462 slots) master
M: 9fea26e1afc09488b655ba85df786a99b7337f80 127.0.0.1:30003
   slots:[10923-16383] (5461 slots) master
S: 90cef2907964658e53b4e7ac16b6b78d290327a9 127.0.0.1:30004
   replicates 9fea26e1afc09488b655ba85df786a99b7337f80
S: dc8aed72721847b1d7f133bc571d71cb05fd9450 127.0.0.1:30005
   replicates 9004ad3ff0f3fe422fd429e150e3c35750b6d12d
S: 340e05d82e74981acdd9ad931c2569bf8328b2f1 127.0.0.1:30006
   replicates 44e0d2cc975d06a1a2d094b57ae2ac1a3f636202
Can I set the above configuration? (type 'yes' to accept): yes #输入yes确认分配方案
>>> Nodes configuration updated
>>> Assign a different config epoch to each node
>>> Sending CLUSTER MEET messages to join the cluster
Waiting for the cluster to join
.
>>> Performing Cluster Check (using node 127.0.0.1:30001)
M: 9004ad3ff0f3fe422fd429e150e3c35750b6d12d 127.0.0.1:30001
   slots:[0-5460] (5461 slots) master
   1 additional replica(s)
M: 9fea26e1afc09488b655ba85df786a99b7337f80 127.0.0.1:30003
   slots:[10923-16383] (5461 slots) master
   1 additional replica(s)
S: 90cef2907964658e53b4e7ac16b6b78d290327a9 127.0.0.1:30004
   slots: (0 slots) slave
   replicates 9fea26e1afc09488b655ba85df786a99b7337f80
M: 44e0d2cc975d06a1a2d094b57ae2ac1a3f636202 127.0.0.1:30002
   slots:[5461-10922] (5462 slots) master
   1 additional replica(s)
S: dc8aed72721847b1d7f133bc571d71cb05fd9450 127.0.0.1:30005
   slots: (0 slots) slave
   replicates 9004ad3ff0f3fe422fd429e150e3c35750b6d12d
S: 340e05d82e74981acdd9ad931c2569bf8328b2f1 127.0.0.1:30006
   slots: (0 slots) slave
   replicates 44e0d2cc975d06a1a2d094b57ae2ac1a3f636202
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.

$ ps -ef | grep redis #可以查看已启动6个redis，3主3从
root     17701     1  0 22:09 ?        00:00:01 ../../src//redis-server *:30001 [cluster]
root     17703     1  0 22:09 ?        00:00:01 ../../src//redis-server *:30002 [cluster]
root     17705     1  0 22:09 ?        00:00:01 ../../src//redis-server *:30003 [cluster]
root     17707     1  0 22:09 ?        00:00:01 ../../src//redis-server *:30004 [cluster]
root     17709     1  0 22:09 ?        00:00:01 ../../src//redis-server *:30005 [cluster]
root     17711     1  0 22:09 ?        00:00:01 ../../src//redis-server *:30006 [cluster]

$ redis-cli -c -p 30001 # -c代表集群模式
127.0.0.1:30001> ping
PONG
127.0.0.1:30001> set name herr
-> Redirected to slot [5798] located at 127.0.0.1:30002 #该槽不是30001处理，会自动跳转到30002
OK
127.0.0.1:30001> set age 18 #这个槽碰巧是30001处理，不会跳转
OK

$ ./create-cluster stop #关闭集群
Stopping 30001
Stopping 30002
Stopping 30003
Stopping 30004
Stopping 30005
Stopping 30006
$ ./create-cluster clean #清理集群，真是简单易用

在生产环境中，一般都需要手动搭建集群，定制节点数量和槽分配。

$ mkdir redis-cluster
$ cd redi-cluster
$ mkdir node1 node2 node3 node4 node5 node6 node7 node8 node9 node10

#配置文件redis.conf如下，port从30001到30010.共5主5从
#cluster-enabled yes
#port 30001
$ redis-server redis.conf #启动10个redis
$ redis-cli --cluster create 127.0.0.1:30001 127.0.0.1:30002 127.0.0.1:30003 127.0.0.1:30004 127.0.0.1:30005 127.0.0.1:30006 127.0.0.1:30007 127.0.0.1:30008 127.0.0.1:30009 127.0.0.1:30010 --cluster-replicas 1 #创建集群，参数为1，代表每个主节点的从节点数量是1
# 后续和脚本创建的流程一致

散列标签

$ redis-cli -c -p 30001
127.0.0.1:30001> cluster keyslot user::1 
(integer) 11620
127.0.0.1:30001> cluster keyslot user::2 #属于不同的槽
(integer) 7431
127.0.0.1:30001> cluster keyslot {user}::1 #大括号包围的是子串，redis只根据这一子串计算键的散列值
(integer) 5474
127.0.0.1:30001> cluster keyslot {user}::2
(integer) 5474

127.0.0.1:30001> hmset user::1 name herr age 18
-> Redirected to slot [11620] located at 127.0.0.1:30003
OK
127.0.0.1:30003> hmset user::2 name zhangsan age 18
-> Redirected to slot [7431] located at 127.0.0.1:30002
OK
127.0.0.1:30002> hmset {user}::1 name herr age 18 #使用相同子串，不会引发redirect
OK
127.0.0.1:30002> hmset {user}::2 name zhangsan age 18
OK

127.0.0.1:30002> keys *
1) "user::2"
2) "{user}::1"
3) "{user}::2"
127.0.0.1:30003> keys *
1) "user::1"

从节点读命令

$ redis-cli -c -p 30002 #连接到主节点
127.0.0.1:30002> set name herr #设置
OK
$  redis-cli -c -p 30005 #连接到从节点
127.0.0.1:30005> get name #读时会自动跳转到主节点来读
-> Redirected to slot [5798] located at 127.0.0.1:30002
"herr"
$ redis-cli -c -p 30005
127.0.0.1:30005> readonly #可使用该方式，打开读命令执行权限
OK
127.0.0.1:30005> get name #获取时直接在从节点读
"herr"
127.0.0.1:30005> readwrite #使用该方式，关闭读命令执行权限
OK
127.0.0.1:30005> get name #从主节点来读
-> Redirected to slot [5798] located at 127.0.0.1:30002
"herr"

集群管理工具redis-cli –cluster

$ redis-cli --cluster help
Cluster Manager Commands:
  create         host1:port1 ... hostN:portN #创建集群
                 --cluster-replicas <arg>
  check          host:port
                 --cluster-search-multiple-owners
  info           host:port #查看集群
  ...
$ redis-cli --cluster info 127.0.0.1:30001 #查看集群信息，返回主节点的相关信息
127.0.0.1:30002 (d61aac3d...) -> 6 keys | 5462 slots | 1 slaves.
127.0.0.1:30003 (5a408e88...) -> 1 keys | 5461 slots | 1 slaves.
127.0.0.1:30001 (9ebce3cf...) -> 1 keys | 5461 slots | 1 slaves.
[OK] 8 keys in 3 masters.
0.00 keys per slot on average.

$ redis-cli --cluster check 127.0.0.1:30001 #检查集群
127.0.0.1:30002 (d61aac3d...) -> 6 keys | 5462 slots | 1 slaves.
127.0.0.1:30003 (5a408e88...) -> 1 keys | 5461 slots | 1 slaves.
127.0.0.1:30001 (9ebce3cf...) -> 1 keys | 5461 slots | 1 slaves.
[OK] 8 keys in 3 masters.
0.00 keys per slot on average.
>>> Performing Cluster Check (using node 127.0.0.1:30002)
M: d61aac3d0126d8dd9db03fc0764f08c53d7e8c6e 127.0.0.1:30002
   slots:[5461-10922] (5462 slots) master
   1 additional replica(s)
S: 87cee567e78f70b57b655c703434318d31a43c27 127.0.0.1:30005
   slots: (0 slots) slave
   replicates d61aac3d0126d8dd9db03fc0764f08c53d7e8c6e
M: 5a408e882742effd5c233624bee63d82653987b9 127.0.0.1:30003
   slots:[10923-16383] (5461 slots) master
   1 additional replica(s)
S: 513f23f72f89c99363d82c24e444a9c71f5918cc 127.0.0.1:30006
   slots: (0 slots) slave
   replicates 5a408e882742effd5c233624bee63d82653987b9
M: 9ebce3cf8feafb174514e60a4016b36eb227968d 127.0.0.1:30001
   slots:[0-5460] (5461 slots) master
   1 additional replica(s)
S: ae63cce88e96f2cf83c1afd8d0e67ea81389d666 127.0.0.1:30004
   slots: (0 slots) slave
   replicates 9ebce3cf8feafb174514e60a4016b36eb227968d
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.

$ redis-cli --cluster fix 127.0.0.1:30001 #修复槽错误
$ redis-cli --cluster reshard 127.0.0.1:30001 --cluster-from xxx --cluster-to xxx --cluster-slots 10 #重分片，将30001节点中的10个槽迁移到其他节点,xxx为节点id
$ redis-cli --cluster rebalance 127.0.0.1:30001 #负载均衡，重新分配各个节点的槽数量
$ redis-cli --cluster add-node 127.0.0.1:30007 127.0.0.1:30001 #添加节点，将节点30007添加到集群中
$ redis-cli --cluster del-node 127.0.0.1:30001 xxx #移除节点，xxx为节点id
$ redis-cli --cluster call 127.0.0.1:30001 ping #集群所有节点执行ping命令
$ redis-cli --cluster call 127.0.0.1:30001 dbsize #集群所有节点执行dbsize命令
$ redis-cli --cluster import 127.0.0.1:30001 --cluster-from 127.0.0.1:6379 --cluster-copy --cluster-replace #将单机数据，迁移到集群，使用复制导入，覆盖同名key

集群管理命令

$ redis-cli -c -p 30001
127.0.0.1:30001> cluster nodes #查看集群所有节点信息
ae63cce88e96f2cf83c1afd8d0e67ea81389d666 127.0.0.1:30004@40004 slave 9ebce3cf8feafb174514e60a4016b36eb227968d 0 1607439275091 1 connected
87cee567e78f70b57b655c703434318d31a43c27 127.0.0.1:30005@40005 slave d61aac3d0126d8dd9db03fc0764f08c53d7e8c6e 0 1607439275692 2 connected
5a408e882742effd5c233624bee63d82653987b9 127.0.0.1:30003@40003 master - 0 1607439275091 3 connected 10923-16383
9ebce3cf8feafb174514e60a4016b36eb227968d 127.0.0.1:30001@40001 myself,master - 0 1607439275000 1 connected 0-5460
d61aac3d0126d8dd9db03fc0764f08c53d7e8c6e 127.0.0.1:30002@40002 master - 0 1607439275692 2 connected 5461-10922
513f23f72f89c99363d82c24e444a9c71f5918cc 127.0.0.1:30006@40006 slave 5a408e882742effd5c233624bee63d82653987b9 0 1607439275692 3 connected
127.0.0.1:30001> cluster myid #查看集群当前节点的运行id
"9ebce3cf8feafb174514e60a4016b36eb227968d"
127.0.0.1:30001> cluster info #查看集群信息
cluster_state:ok
cluster_slots_assigned:16384
cluster_slots_ok:16384
cluster_slots_pfail:0
cluster_slots_fail:0
cluster_known_nodes:6
cluster_size:3
...
127.0.0.1:30001> cluster meet 127.0.0.1 30008  #将30008节点加入到30001。如果30008、30009、30010是一个集群，会合并两个集群
127.0.0.1:30001> cluster meet 127.0.0.1 xxx  #将运行id为xxx的节点从集群中移除

127.0.0.1:30001> cluster replicas 9ebce3cf8feafb174514e60a4016b36eb227968d #查看30001的所有从节点
1) "ae63cce88e96f2cf83c1afd8d0e67ea81389d666 127.0.0.1:30004@40004 slave 9ebce3cf8feafb174514e60a4016b36eb227968d 0 1607439582263 1 connected"
127.0.0.1:30001> cluster replicate 5a408e882742effd5c233624bee63d82653987b9 #查看30003这个节点变为从节点
OK
127.0.0.1:30004> cluster failover #查看30004为30001的从节点，强制执行故障转移，30004变为主节点，30001变为从节点
OK
127.0.0.1:30004> cluster reset #重置节点，只能在数据库为空时使用，默认为软重置，添加hard参数后为硬重置

槽管理命令

127.0.0.1:30001> cluster slots #查看槽与节点的关联信息
1) 1) (integer) 0 #起始槽
   2) (integer) 5460 #结束槽
   3) 1) "127.0.0.1" #主节点信息
      2) (integer) 30001
      3) "9ebce3cf8feafb174514e60a4016b36eb227968d"
   4) 1) "127.0.0.1" #从节点信息
      2) (integer) 30004
      3) "ae63cce88e96f2cf83c1afd8d0e67ea81389d666"
...

127.0.0.1:30001> cluster delslots 0 1 2 3 4 5 #撤销对节点的槽指派
OK
127.0.0.1:30001> cluster addslots 0 1 2 3 4 5 #把槽指派给节点，必须是未分配的槽
OK
127.0.0.1:30001> cluster flushslots #撤销对节点的所有槽指派
OK
127.0.0.1:30001> cluster keyslot user::1 #好看键所属的槽
(integer) 11620
127.0.0.1:30001> cluster countkeysinslot 5474 #查看5474这个槽包含的键数量
(integer) 0
127.0.0.1:30001> cluster getkeysinslot 5474 10 #查看5474这个槽包含的键，最多10个
(empty array)
127.0.0.1:30001> cluster setslot 5474 importing xxx #让5474槽进入“导入中”状态，并允许从xxx节点导入槽数据,xxx为source节点id
127.0.0.1:30001> cluster setslot 5474 migrating xxx #让5474槽进入“迁移中”状态，并允许迁移槽数据到xxx节点,xxx为destination节点id
127.0.0.1:30001> cluster setslot 5474 node xxx #将槽指派到目标节点负责，xxx为destination节点id
127.0.0.1:30001> cluster setslot 5474 stable #清楚节点指定槽的“导入中”和“迁移中”状态

九、其他

Redis开发规范

1、键值设计

key名可读性和可管理性
value选择合适数据类型，拒绝bigkey
控制key的生命周期

2、命令使用

命令返回数量N不能过多，可拿scan代替
禁用keys、flushall、flushdb等命令
monitor命令时，不要长时间使用
合理使用select库
使用pineline等批量操作提高效率
事务功能较弱，不建议过多使用

缓存故障及解决方案

1、缓存击穿

是指单个Key非常热点，在不停地扛着大量的请求，大并发集中对这一个点进行访问，当这个Key在失效的瞬间，持续的大并发直接落到了数据库上，就在这个Key的点上击穿了缓存。

可通过synchronized+双重检查机制，某个key只让一个线程查询，阻塞其它线程
设置热点数据永不过期，或者自动续期
实现互斥锁，如使用redis的SETNX实现锁效果。但存在死锁风险

2、缓存雪崩

缓存雪崩式缓存击穿的升级版。因为多个key大面积的缓存失效，打崩了DB。

每个Key的过期时间加个随机值，保证数据不会再同一时间大面积失效。
哨兵、集群等高可用
服务降级，如从应用的本地内存获取

3、缓存穿透

是指缓存和数据库中都没有的数据，所以每次查询都会查询数据库从而导致数据库崩溃。和没有缓存一样，透透的。

在接口层做参数校验
针对上亿的大数据量，利用redis的布隆过滤器
缓存空值