Redis

安装

yum/apt 安装

#centos
yum -y install redis

#Ubuntu
apt -y install redis

编译安装

源代码官网：https://download.redis.io/releases/

#安装依赖包
[root@centos8 ~]# yum -y install make gcc systemd-devel
# Ubuntu
# apt -y install make gcc libsystemd-dev


#下载并解压缩，wget下载不了需翻墙下载到本地在拷贝
[root@centos8 ~]# wget https://download.redis.io/releases/redis-6.2.6.tar.gz
[root@centos8 ~]# tar xf redis-6.2.6.tar.gz

#开始编译安装
[root@centos8 ~]# cd redis-6.2.6
#redis-6.2.6版本需要启用systemd,否则将无法使用systemd来启动redis
[root@centos8 redis-6.2.6]# make USE_SYSTEMD=yes PREFIX=/apps/redis install

#编译完成后目录
[root@centos8 ~]# tree /apps/
/apps/
└── redis
    └── bin
        ├── redis-benchmark
        ├── redis-check-aof -> redis-server
        ├── redis-check-rdb -> redis-server
        ├── redis-cli
        ├── redis-sentinel -> redis-server
        └── redis-server
2 directories, 6 files


#将二进制文件加入到PATH变量中并设置成软连接
[root@centos8 /]# ln -s /apps/redis/bin/* /usr/bin/

#创建需要的目录
[root@centos8 /]# mkdir -p /apps/redis/{etc,log,data,run}

#复制配置文件，注意复制后的配置文件权限，需修改成redis
[root@centos8 redis-6.2.6]# pwd
/usr/local/src/redis-6.2.6
[root@centos8 redis-5.0.9]# cp redis.conf /apps/redis/etc/

#创建redis账号
[root@centos8 /]# useradd -r redis -u 637 -s /sbin/nologin

#修改权限
[root@centos8 /]# chown -R redis.redis /apps/redis/

实现多实例安装

编译安装后，将配置文件修改完毕后拷贝成模板在复制粘贴并修改端口号在重新启动服务即可
假设在同一主机安装三个 redis 多实例

#编译安装过程省略...

#编译安装后的目录
[root@18 ~]# tree /apps/redis/
/apps/redis/
├── bin
│   ├── redis-benchmark
│   ├── redis-check-aof -> redis-server
│   ├── redis-check-rdb -> redis-server
│   ├── redis-cli
│   ├── redis-sentinel -> redis-server
│   └── redis-server
├── data
├── etc
│   └── redis.conf
├── log
└── run

#修改配置文件省略...（主要是指定不同的端口、PID文件、log文件）

#拷贝配置文件省略..

#指定不同的service文件...(主要是每个service文件指定不同的redis配置文件)
[root@centos8 /]# cat /usr/lib/systemd/system/redis6379.service
[root@centos8 /]# cat /usr/lib/systemd/system/redis6380.service
[root@centos8 /]# cat /usr/lib/systemd/system/redis6381.service

#启动后效果
[root@centos8 etc]$tree /apps/redis/
/apps/redis/
├── bin
│   ├── redis-benchmark
│   ├── redis-check-aof
│   ├── redis-check-rdb
│   ├── redis-cli
│   ├── redis-sentinel -> redis-server
│   └── redis-server
├── data
│   └── dump.rdb
├── etc
│   ├── redis_6379.conf
│   ├── redis_6380.conf
│   └── redis_6381.conf
├── log
│   ├── redis_6379.log
│   ├── redis_6380.log
│   └── redis_6381.log
│ 
└── run 
    ├── redis_6379.pid
    ├── redis_6380.pid
    └── redis_6381.pid

5 directories, 16 files

#全部启动服务后查看端口
[root@centos8 etc]# ss -ntl
State          Recv-Q         Send-Q                   Local Address:Port                   Peer Address:Port         
LISTEN         0              128                            0.0.0.0:6379                        0.0.0.0:*            
LISTEN         0              128                            0.0.0.0:6380                        0.0.0.0:*            
LISTEN         0              128                            0.0.0.0:6381                        0.0.0.0:* 

#注意修改权限
[root@centos8 /]# chown -R redis.redis /apps/redis/

redis service文件

多实例的情况下复制service文件并修改redis.conf的配置文件路径即可

# cat /usr/lib/systemd/system/redis.service
[Unit]
Description=Redis persistent key-value database
After=network.target

[Service]
ExecStart=/apps/redis/bin/redis-server /apps/redis/etc/redis.conf --supervised systemd
ExecStop=/bin/kill -s QUIT $MAINPID
Type=notify
User=redis
Group=redis
RuntimeDirectory=redis
RuntimeDirectoryMode=0755

[Install]
WantedBy=multi-user.target

常用命令

官方文档：https://redis.io/commands

中文文档：http://redisdoc.com/

显示信息 INFO

显示当前节点redis运行状态信息

127.0.0.1:6379> info
# Server
redis_version:5.0.3
redis_git_sha1:00000000
redis_git_dirty:0
redis_build_id:28849dbea6f07cc8
redis_mode:standalone
os:Linux 4.18.0-240.22.1.el8_3.x86_64 x86_64
arch_bits:64
multiplexing_api:epoll
atomicvar_api:atomic-builtin
gcc_version:8.3.1
process_id:34846
run_id:faa3c6db0c31195fcde2273323ae6446732acae9
tcp_port:6379
uptime_in_seconds:152030
uptime_in_days:1
hz:10
configured_hz:10
lru_clock:15876727
executable:/usr/bin/redis-server
config_file:/etc/redis.conf

# Clients
connected_clients:1
client_recent_max_input_buffer:2
client_recent_max_output_buffer:0
blocked_clients:0

# Memory
used_memory:853904
used_memory_human:833.89K
...

#显示部分信息
127.0.0.1:6379> info cluster
# Cluster
cluster_enabled:0

切换数据库 SELECT

切换数据库，相当于MySQL中的USE DBNAME执行

127.0.0.1:6379> info cluster
# Cluster
cluster_enabled:0

127.0.0.1:6379> SELECT 0
OK
127.0.0.1:6379> SELECT 5
OK
127.0.0.1:6379[5]> SELECT 15
OK
127.0.0.1:6379[15]> SELECT 16
(error) ERR DB index is out of range #超出库数量会报错

#在redis cluster模式下不支持多个数据库，会出现下面错误
127.0.0.1:6379> info cluster
# Cluster
cluster_enabled:1
127.0.0.1:6379> SELECT 0
OK
127.0.0.1:6379> SELECT 1
(error) ERR SELECT is not allowed in cluster mode

过滤当前库的key KEYS

此命令慎用！！！！！如果使用 KEY * 指令，会导致磁盘产生大量的IO以及CPU占有率会瞬间飙到100%，这时如果有用户查询数据，redis则不能及时响应，从而会导致大量用户的请求被转发到后端的MySQL进行查询，从而引起雪崩效应，导致MySQL宕机等情况发生

持久化

前言

redis虽然是一个内存级别的缓存程序，也就是redis是使用内存进行数据的缓存的，但是其可以将内存的数据按照一定的策略保存到硬盘上，从而实现数据持久保存的目的

目前redis支持两种不同的保存方式的数据持久化保存机制，分别是RDB和AOF

将内存中的数据保存到磁盘中，等下次重启时在将磁盘中的缓存数据读入到内存中，生产中建议开启，因为redis在重启后在本地磁盘中直接读入缓存数据比用户直接访问数据本身在形成缓存的效率高，所以可以起到加速的效果

RDB (快照)

RDB 概述

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

某个时间点，快速的将redis内存中的数据拷贝到到磁盘中，生成一个RDB文件(二进制格式)存放的就是redis当前数据的快照

RDB 工作原理

RDB 基于内存的快照，实现方式有两种：手动执行 save 或 bgsave、在配置文件中定义自动保存规则

save：同步方式保存快照，因为是在主进程中执行快照所以可能会阻塞其他命令的执行因此不常用
bgsave：异步方式保存快照，首先 redis 主进程会 fork() 出一个子进程，最初子进程会和父进程共享同一块内存空间，然后子进程将内存中的数据dump到RDB临时文件中，当数据写完后临时文件会覆盖掉旧的RDB文件
- 如果快照过程中父进程的内容发生更改，那么父进程就会基于写时复制机制复制一块内存空间用于存储新的数据，从而避免原有的内存数据发生变化而影响到子进程的快照执行（如果子进程存在期间，发生了大量的写操作，那可能就会出现很多的分页错误(页异常中断page-fault)，这样就得耗费不少性能在复制上。）
- 快照执行期间主进程所发生的数据修改不会保存到快照当中，因为变化的数据被写时复制机制写入到了一块独立分配的内存空间
- 当redis服务重启后，会重新读取RDB文件并将RDB文件中的数据读入到内存中
配置文件中定义：save 间隔多少秒多少个key发生变化（并且的关系）
临时文件：temp.PID.rdb
最终文件：dump.rdb

RDB 优点

RDB快照保存了某个时间点的数据，可以通过脚本执行redis指令bgsave(非阻塞，后台执行)或者save(会阻塞写操作，不建议使用)命令自定义时间点备份，可以保留多个备份，当出现问题可以恢复到不同时间的版本，很适合备份，并且此文件格式也支持有不少第三方工具可以进行后续的数据分析
RDB可以最大化redis的性能，父进程在保存rdb文件时唯一要做的就是fork出一个子进程，然后这个子进程就会处理接下来的所有保存工作，父进程无需执行任何磁盘i/o操作
RDB在大量数据，比如几个G的数据，恢复的速度比AOF的快

RDB 缺点

不能实时保存数据，可能会丢失自上一次执行RDB备份到当前的内存数据

如果需要尽量避免在服务器故障时丢失数据，那么RDB不合适。虽然redis允许设置不同的保存点（save point）来控制保存RDB文件的频率，但是，因为RDB文件需要保存整个数据集的状态，所以它并不是一个轻松的操作。因此你可能会至少5分钟才保存一次RDB文件。在这种情况下，一旦发生故障停机，那就可能会丢失好几分钟的数据

当数据量非常大的时候，从父进程fork子进程进行保存至RDB文件时需要一点时间，可能是秒或者毫秒，取决于磁盘的I/O性能；在数据集比较庞大时，fork()可能会非常耗时，造成服务器在一定时间内停止处理客户端；如果数据集非常巨大，并且CPU时间非常紧张的话，那么这种停止时间甚至可能会长达整整一秒或更久。虽然AOF重写也需要fork()，但无论AOF重写的执行间隔有多长，数据的持久性都不会有任何损失

RDB 实现方式

手动执行：

save，同步，会阻塞其他命令，不推荐使用
bgsave，异步后台执行，不影响其他命令的执行

自动执行：

需要在配置文件中自定义执行规则

RDB 相关配置

[root@aliyun ~]# vim /etc/redis.conf

# 自动保存规则（别看选项名叫 save，实际上执行的是 bgsave 命令，也就是会创建子进程来生成 RDB 快照文件。）
save "" # 只留这行，然后将下面三行注释掉，表示关闭自动保存
save 900 1 # 在900秒内有1个key内容发生更改，就执行快照机制
save 300 10 # 在300秒内有10个key内容发生更改，就执行快照机制
save 60 10000 # 在60秒内有10000个key以上的变化，就自动快照备份

dbfilename dump.rdb #快照文件名

dir ./ #rdb或aof的文件路径，示例：dir "/apps/redis/data"

stop-writes-on-bgsave-error no #默认为yes时，可能会因空间满等原因快照无法保存出错时，会禁止redis写入操作，生产建议为no，此项只针对配置文件中的自动save有效

rdbcompression yes #持久化到RDB文件时，是否压缩，"yes"为压缩，"no"则反之

rdbchecksum yes # 是否对备份文件开启rc64效验，默认是开启（使用rdb恢复数据时是否检查rdb文件是否已经损坏）

RDB 的还原

直接将备份的RDB文件拷贝到配置文件指定的路径中（即配置文件中 dir 所指向的路径），并同名同权限即可，重启后会自动还原

RDB 备份

因为RDB默认只保存最新一次的快照，所以生产中建议给RDB做备份
**生产中的备份思路：**在计划任务中写一个bgsave的备份脚本，备份完后将rdb文件拷贝到指定的备份目录中并加上时间戳，要注意bgsave并不是立刻备份完等问题，可以通过判断info的参考值是否为0来决定是否拷贝

RDB 备份脚本

此脚本可以放到计划任务中，定时执行，以达到分时备份的效果

[root@8 ~]# cat redis_rdb.sh
#!/bin/bash
#
#********************************************************************
#Author:	     	xiangzheng
#QQ: 			    767483070
#Date: 		     	2021-12-25
#FileName：		    redis_rdb.sh
#URL: 		    	https://www.xiangzheng.vip
#Email: 		    rootroot25@163.com
#Description：		The test script
#Copyright (C): 	2021 All rights reserved
#********************************************************************
HOST="10.0.0.8"
PASS="321"
SOUDIR="/apps/redis/data/"
FILE="dump.rdb"
DIR="/data/redis"
TYPE="bgsave"
redis-cli -h ${HOST} -a ${PASS} --no-auth-warning ${TYPE} &>/dev/null
RESULT=`redis-cli -h ${HOST} -a ${PASS} --no-auth-warning info persistence | grep rdb_bgsave_in_progress | awk -F: '{print $2}' | tr -dc '[:digit:]'`

until [ ${RESULT} -eq 0 ] ;do
    sleep 1
    RESULT=`redis-cli -h ${HOST} -a ${PASS} --no-auth-warning info persistence | grep rdb_bgsave_in_progress | awk -F: '{print $2}' | tr -dc '[:digit:]'`
done

DATE=`date +%F-%T`
[ -d ${DIR} ] || mkdir -p ${DIR}
cp -a ${SOUDIR}${FILE} ${DIR}/${DATE}-${FILE}

—

AOF (类似写二进制日志)

AOF 概述

AOF：AppendOnyFile，类似二进制日志，按照操作顺序依次将操作追加到指定的日志文件末尾（效率高）

配置文件

Redis 配置文件说明

/etc/redis.conf

bind 0.0.0.0 #0.0.0.0表示监听所有IP，也可以用空格隔开后监听多个IP，默认是只允许本机

protected-mode yes #redis3.2之后加入的新特性，在没有设置bind IP和密码的时候，redis只允许访问127.0.0.1:6379，可以远程连接，但当访问将提示警告信息并拒绝远程访问，yes启用 no禁用(即允许远程空密码连接)

port 6379 #redis的默认监听端口端口号 TCP/6379

tcp-backlog 511 #三次握手的时候server端收到client ack确认号之后的队列值，即全连接队列长度，建议优化内核参数
#半连接：用户发起请求报文syn，服务器响应后，用户没有第三次握手的回应（默认只能接受128个）
#全连接队列：（默认也是128个）

timeout 0 #客户端和redis服务端的连接超时时间，默认是0，0表示永不超时

tcp-keepalive 300 #tcp会话保持时间，默认300s

daemonize yes #守护进程，no表示以前台运行

loglevel notice #日志记录级别

logfile "/apps/redis/log/redis.log" #指定日志记录位置，默认没有没有，需要指定

databases 16 #设置数据库数量，默认：0-15，共16个库，通常只用0库就够了

always-show-logo yes #在启动redis时，是否显示或在日志中记录redis的logo

supervised no #和os相关参数，可设置通过upstart和systemd管理redis守护进程，centos7后都使用systemd

pidfile /var/run/redis_6379.pid #进程路径，可修改为/apps/redis/run/redis_6379.pid

# requirepass foobared
requirepass passwd #设置登录密码

# maxclients 10000
redis最大连接客户端的数量，默认10000

#重要！
# maxmemory <bytes>
redis使用的最大内存，单位为bytes字节，0为不限制，建议设置为物理内存的一半，需要注意的是缓冲区是不计算maxmemory内，生产中如果不设置此项，可能会导致OOM（内存满后乱杀进程）而redis通常是占用内存最高的程序 所以极有可能宕掉
#8G内存的计算方式：8(G)*1024(MB)*1024(KB)*1024(bytes)/2
#1G内存的计算方式：echo 2^20*1024/2|bc


#持久化策略（参阅redis持久化）
...


# 多线程
...

Redis 动态修改配置文件

config命令用于查看当前redis配置、以及不重启redis服务实现动态修改redis配置等

数据类型和操作

前言

参考链接：http://www.redis.cn/topics/data-types.html

相关命令参考：http://redisdoc.com/

字符串（Strings）

判断key是否存在 EXISTS

127.0.0.1:6379> EXISTS name
(integer) 1 #1表示存在
127.0.0.1:6379> EXISTS namee
(integer) 0 #0表示不存在

创建一个key并赋值 SET

SET key value [expiration EX seconds|PX milliseconds] [NX|XX]
#默认是不论key是否存在都进行设置(存在也会将之前的内容覆盖掉，不存在则新创建)
#EX seconds 以秒为单位设置过期时间
#PX milliseconds 以毫秒为单位设置过期时间
#NX，只在键不存在时，才对键进行设置操作（键存在则不操作）
#XX，只在键存在时，才对键进行设置操作（键不存在则不操作）

127.0.0.1:6379> SET key value  #设置一个值

#设置一个hongbao key值为100，有效期为30秒
127.0.0.1:6379> SET hongbao 100 EX 30
OK
127.0.0.1:6379> TTL hongbao
(integer) 24
127.0.0.1:6379> TTL hongbao
(integer) 23
127.0.0.1:6379> TTL hongbao
(integer) -2 #-2表示已过期或空值

#XX 和 NX
127.0.0.1:6379> set www xxx XX
(nil)
127.0.0.1:6379> GET www
(nil)
127.0.0.1:6379> set www xxx NX
OK
127.0.0.1:6379> GET www
"xxx"

获取单个值 GET

127.0.0.1:6379> GET two
"2"

设置新值并返回旧值 GETSET

127.0.0.1:6379> set name azheng
OK
127.0.0.1:6379> getset name xiangzheng
"azheng"
127.0.0.1:6379> get name
"xiangzheng"

一次设置多个key MSET

127.0.0.1:6379> KEYS *
(empty list or set)
127.0.0.1:6379> MSET one 1 two 2 three 3 #一次设置3个值
OK
127.0.0.1:6379> KEYS *
1) "two"
2) "one"
3) "three"

一次获取多个key MGET

MGET key [key ...]

127.0.0.1:6379> MGET three one
1) "3"
2) "1"

key后追加内容 APPEND

127.0.0.1:6379>  get three
"linux"
127.0.0.1:6379> APPEND three " is good"
(integer) 12 #12表示字节，而非字符串数量
127.0.0.1:6379>  get three
"linux is good"

删除一个或多个key DEL

DEL key [key ...]

127.0.0.1:6379> DEL two
(integer) 1

查看key的有效期 TTL

127.0.0.1:6379> TTL one
(integer) -1   #-1代表永久有效

127.0.0.1:6379> TTL one
(integer) 100   #100代表还有100秒失效

127.0.0.1:6379> TTL hongbao
(integer) -2 #-2表示已过期或空值

重设key的有效期 EXPIRE

EXPIRE key seconds

取消key的过期时间 PERSIST

即永不过期

PERSIST key

查看key的数据类型 TYPE

127.0.0.1:6379> TYPE three
string #字符串类型

显示字节数 STRLEN

返回字符串key对应值的字节数

127.0.0.1:6379> set 姓名 项征
OK
127.0.0.1:6379> get 姓名
"\xe9\xa1\xb9\xe5\xbe\x81"
127.0.0.1:6379> strlen 姓名
(integer) 6

数值递增 INCR

#INCR key

127.0.0.1:6379> set number 666
OK
127.0.0.1:6379> get number
"666"
127.0.0.1:6379> INCR number
(integer) 667
127.0.0.1:6379> get number
"667"
127.0.0.1:6379> INCR number
(integer) 668
127.0.0.1:6379> get number
"668"

数值递减 DECR

#DECR name

127.0.0.1:6379> set number 666
OK
127.0.0.1:6379> get number
"666"
127.0.0.1:6379> DECR number
(integer) 665
127.0.0.1:6379> get number
"665"
127.0.0.1:6379> DECR number
(integer) 664
127.0.0.1:6379> get number
"664"

数值增加 INCRBY

#INCRBY key increment

127.0.0.1:6379> set number 666
OK
127.0.0.1:6379> get number
"666"
127.0.0.1:6379> INCRBY number 10
(integer) 676
127.0.0.1:6379> get number
"676"
127.0.0.1:6379> INCRBY number 11
(integer) 687
127.0.0.1:6379> get number
"687"

#也支持负数，就是减
127.0.0.1:6379> INCRBY number -30
(integer) 657
127.0.0.1:6379> get number
"657"

数值减少 DECRBY

#DECRBY key decrement

127.0.0.1:6379> set number 666
OK
127.0.0.1:6379> get number
"666"
127.0.0.1:6379> DECRBY number 30
(integer) 636
127.0.0.1:6379> get number
"636"
127.0.0.1:6379> DECRBY number 36
(integer) 600
127.0.0.1:6379> get number
"600"

#-50等于+50
127.0.0.1:6379> DECRBY number -88
(integer) 688
127.0.0.1:6379> get number
"688"

列表（Lists）

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

列表特点：

有序
元素值可以重复
左右都可以操作

生成列表并插入数据

#左推 LPUSH
127.0.0.1:6379> LPUSH listkey a b c
(integer) 3
127.0.0.1:6379> LRANGE listkey 0 -1
1) "c"
2) "b"
3) "a"

#右推 RPUSH
127.0.0.1:6379> RPUSH listkey2 a b c
(integer) 3
127.0.0.1:6379> LRANGE listkey2 0 -1
1) "a"
2) "b"
3) "c"

获取列表长度 (元素个数) LLEN

127.0.0.1:6379> LLEN listkey
(integer) 3

取列表中的内容 LRANGE LINDEX

#取0到1号的内容
lrange name 0 1

#取所有列表的内容
lrange name 0 -1

#取最后一个元素
lindex name -1

#取某一个元素
lindex name 3

修改列表指定索引值 LSET

127.0.0.1:6379> RPUSH name a b c d e f
(integer) 6
127.0.0.1:6379> LRANGE name 0 -1
1) "a"
2) "b"
3) "c"
4) "d"
5) "e"
6) "f"
#修改指定值
127.0.0.1:6379> LSET name 2 bbb #2表示的就是3，因为是从0开始的
OK
127.0.0.1:6379> LRANGE name 0 -1
1) "a"
2) "b"
3) "bbb"
4) "d"
5) "e"
6) "f"

移除列表数据

#从左边弹
lpop
#从右边弹
rpop

#左弹
127.0.0.1:6379> LRANGE name 0 -1
1) "a"
2) "b"
3) "bbb"
4) "d"
5) "e"
6) "f"
127.0.0.1:6379> LPOP name
"a"
127.0.0.1:6379> LRANGE name 0 -1
1) "b"
2) "bbb"
3) "d"
4) "e"
5) "f"

#右弹
127.0.0.1:6379> LRANGE name 0 -1
1) "b"
2) "bbb"
3) "d"
4) "e"
5) "f"
127.0.0.1:6379> RPOP name
"f"
127.0.0.1:6379> LRANGE name 0 -1
1) "b"
2) "bbb"
3) "d"
4) "e"

#修剪
127.0.0.1:6379> LRANGE name 0 -1
1) "b"
2) "bbb"
3) "d"
4) "e"
127.0.0.1:6379> LTRIM name 1 2 #只留下1到2之间的元素
OK
127.0.0.1:6379> LRANGE name 0 -1
1) "bbb"
2) "d"

#删除全部元素
127.0.0.1:6379> DEL name
(integer) 1
127.0.0.1:6379> LRANGE name 0 -1
(empty list or set)

集合（Set）

set是string类型的无序集合
集合中的成员是唯一的，这就意味着集合中不能出现重复的数据
可以在两个不同的集合中对数据进行对比取值（取并集、交集、差集）
常用于数值判断、统计、交集等场景（可能认识的人就是取并集）

集合特点：

无序
无重复
集合间操作

生成集合key SADD

127.0.0.1:6379> SADD firends zhangsan lisi wangwu
(integer) 3
127.0.0.1:6379> SADD firends2 xiaoming xiaohong xiaoqiang
(integer) 3
127.0.0.1:6379> TYPE firends
set
127.0.0.1:6379> TYPE firends2
set

追加数值 SADD

#追加时，只能追加不存在的数值，不能追加已存在的数值
127.0.0.1:6379> SADD set1 v1 v2 v2
(integer) 2
127.0.0.1:6379> SADD set1 v1 #已存在的数值不能追加
(integer) 0
127.0.0.1:6379> SADD set1 v6 #不存在的可以追加
(integer) 1
127.0.0.1:6379> TYPE set1
set

查看集合的所有数据 SMEMBERS

127.0.0.1:6379> SMEMBERS set1
1) "v6"
2) "v2"
3) "v1"
127.0.0.1:6379> SMEMBERS firends
1) "lisi"
2) "zhangsan"
3) "wangwu"

删除集合中的元素 SREM

127.0.0.1:6379> SMEMBERS set1
1) "v6"
2) "v2"
3) "v1"
127.0.0.1:6379> SREM set1 v6
(integer) 1
127.0.0.1:6379> SMEMBERS set1
1) "v2"
2) "v1"

集合间操作

127.0.0.1:6379> SMEMBERS value1
1) "wangjianlin"
2) "mayun"
3) "tony"
4) "leijun"
127.0.0.1:6379> SMEMBERS value2
1) "tangseng"
2) "baigujing"
3) "tony"
4) "wukong"
5) "mayun"

#取交集
#交集：属于A且属于B的元素称为A与B的交集（两个元素都存在的值）
127.0.0.1:6379> SINTER value1 value2
1) "mayun"
2) "tony"

#取并集
#并集：属于A或属于B的元素为称为A与B的并集（两个元素的所有值集合然后去重）
127.0.0.1:6379> SUNION value1 value2
1) "wangjianlin"
2) "tangseng"
3) "tony"
4) "leijun"
5) "baigujing"
6) "wukong"
7) "mayun"

#取差集
#差集：属于A而不属于B的元素称为A与B的差集（列出的是A有但是B没有的值）
127.0.0.1:6379> SDIFF value1 value2
1) "wangjianlin"
2) "leijun"

有序集合（sorted set）

redis有序集合和集合一样，也是string类型元素的集合且不允许有重复的成员，不同的是每个元素都会关联一个double(双精度浮点型)类型的分数，redis正是通过该分数来为集合中的成员进行从小到大的排序
有序集合的成员都是唯一的不可重复，但分数(score)可以重复
集合是通过哈希表实现的，所以添加、删除、查找的复杂度都是O(1)
集合中最大的成员数为2^32-1(4294976295，每个集合可存储40多亿个成员)
经常用于排行榜的场景

有序集合特点：

有序
无重复元素
每个元素是由score和value组成
score 可以重复
value 不可以重复

生成有序集合 ZADD

#1为分，v1为元素值，分数可以重复，元素值不可重复
127.0.0.1:6379> ZADD paihangbang 80 babai 75 wodejiaxiang 90 matrix 50 xiaoshidai 88 huapi
(integer) 5
127.0.0.1:6379> ZADD paihangbang 90 babai
(integer) 0
127.0.0.1:6379> TYPE paihangbang
zset

有序集合实现排行榜

#默认是从小到大排序
127.0.0.1:6379> ZRANGE paihangbang 0 -1
1) "xiaoshidai"
2) "wodejiaxiang"
3) "huapi"
4) "babai"
5) "matrix"

#从大到小排序
127.0.0.1:6379> ZREVRANGE paihangbang 0 -1
1) "matrix"
2) "babai"
3) "huapi"
4) "wodejiaxiang"
5) "xiaoshidai"

#正序显示指定集合内所有key和得分情况
127.0.0.1:6379> ZRANGE paihangbang 0 -1 WITHSCORES
 1) "xiaoshidai"
 2) "50"
 3) "wodejiaxiang"
 4) "75"
 5) "huapi"
 6) "88"
 7) "babai"
 8) "90"
 9) "matrix"
10) "90"

#倒序显示指定集合内所有key和得分情况
127.0.0.1:6379> ZREVRANGE paihangbang 0 -1 WITHSCORES
 1) "matrix"
 2) "90"
 3) "babai"
 4) "90"
 5) "huapi"
 6) "88"
 7) "wodejiaxiang"
 8) "75"
 9) "xiaoshidai"
10) "50"

获取集合的个数 ZCARD

127.0.0.1:6379> ZCARD paihangbang
(integer) 5

基于索引返回数值 ZRANGE

127.0.0.1:6379> ZRANGE paihangbang  0 -1
1) "xiaoshidai"
2) "wodejiaxiang"
3) "huapi"
4) "babai"
5) "matrix"
#
127.0.0.1:6379> ZRANGE paihangbang  0 2
1) "xiaoshidai"
2) "wodejiaxiang"
3) "huapi"
#
127.0.0.1:6379> ZRANGE paihangbang  0 10 #超出范围不报错
1) "xiaoshidai"
2) "wodejiaxiang"
3) "huapi"
4) "babai"
5) "matrix"

返回某个数值的索引排名

127.0.0.1:6379> ZRANK paihangbang huapi
(integer) 2 #从小到大排第三，因为从0开始
127.0.0.1:6379> ZRANK paihangbang wodejiaxiang
(integer) 1 #从小到大排第二，因为从0开始

获取分数 ZSCORE

127.0.0.1:6379> ZSCORE paihangbang babai
"90"
127.0.0.1:6379> ZSCORE paihangbang xiaoshidai
"50"

删除部分元素 ZREM

127.0.0.1:6379> ZRANGE paihangbang 0 -1
1) "xiaoshidai"
2) "wodejiaxiang"
3) "huapi"
4) "babai"
5) "matrix"
127.0.0.1:6379> ZREM paihangbang huapi babai
(integer) 2
127.0.0.1:6379> ZRANGE paihangbang 0 -1
1) "xiaoshidai"
2) "wodejiaxiang"
3) "matrix"

#删除有序集合
127.0.0.1:6379> del paihangbang
(integer) 1
127.0.0.1:6379> ZRANGE paihangbang 0 -1
(empty list or set)

哈希（Hashes）

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

生成 hash key

HSET key field value

127.0.0.1:6379> HSET 9527 name xiangzheng age 23
(integer) 2
127.0.0.1:6379> TYPE 9527
hash
---
127.0.0.1:6379> HSET 9527 name azheng age 23 city huludao #数值已存在则会覆盖
(integer) 1
127.0.0.1:6379> HGETALL 9527
1) "name"
2) "azheng" #
3) "age"
4) "23"
5) "city"
6) "huludao"


#查看所有字段的值
127.0.0.1:6379> HGETALL 9527
1) "name" #键
2) "xiangzheng" #值
3) "age" #键
4) "23" #值

#增加字段
127.0.0.1:6379> HSET 9527 gender man
(integer) 1
127.0.0.1:6379> HGETALL 9527
1) "name"
2) "azheng"
3) "age"
4) "23"
5) "city"
6) "huludao"
7) "gender"
8) "man"

获取 hash key对应字段的值

127.0.0.1:6379> HGET 9527 name
"azheng"
127.0.0.1:6379> HGET 9527 age
"23"

#获取多个值
127.0.0.1:6379> HMGET 9527 city gender
1) "huludao"
2) "man"

删除一个hash key的对应字段

127.0.0.1:6379> HGET 9527 city
"huludao"
127.0.0.1:6379> HDEL 9527 city
(integer) 1
127.0.0.1:6379> HGET 9527 city
(nil)

批量设置hash key的多个field和value

127.0.0.1:6379> HGETALL 9527
1) "name"
2) "azheng"
3) "age"
4) "23"
5) "gender"
6) "man"
127.0.0.1:6379> HMSET 9527 name zhouxingxing age 50 city hongkong
OK
127.0.0.1:6379> HGETALL 9527
1) "name"
2) "zhouxingxing"
3) "age"
4) "50"
5) "gender"
6) "man"
7) "city"
8) "hongkong"

获取hash中所有的字段名field(键)

127.0.0.1:6379> HKEYS 9527
1) "name"
2) "age"
3) "gender"
4) "city"

获取hash key对应所有field的value

127.0.0.1:6379> HVALS 9527
1) "zhouxingxing"
2) "50"
3) "man"
4) "hongkong"

消息队列

前言

消息队列：把要传输的数据放在队列中

功能：可以实现多个系统之间的解耦、异步、削峰/限流等

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

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

常用的消息队列应用：Kafka、rabbitMQ、redis(不太专业)

生产者/消费者模式

先生产，后消费
消费者通过抢购得到
可以利用list列表来实现

发布者/订阅者模式

先订阅，后发布
订阅者都会收到

订阅者监听频道

127.0.0.1:6379> SUBSCRIBE 89.4 106.6   #订阅者事先订阅指定的频道，之后发布的消息才能收到
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "89.4"
3) (integer) 1
1) "subscribe"
2) "106.6"
3) (integer) 2

#订阅支持通配符
127.0.0.1:6379> PSUBSCRIBE pattern [pattern ...]

发布者发布消息

127.0.0.1:6379> PUBLISH 89.4 hello #发布消息
(integer) 1

127.0.0.1:6379> SUBSCRIBE 89.4 106.6
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "89.4"
3) (integer) 1
1) "subscribe"
2) "106.6"
3) (integer) 2
1) "message" #收到消息
2) "89.4"
3) "hello"

优化

解决redis启动后的三个报警信息

tcp-backlog

#默认最大等待队列数量为128，值较低，建议优化

#在日志中可以看到此报警信息
[root@centos8 ~]#tail -f /var/log/redis/redis.log
WARNING: The TCP backlog setting of 511 cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of 128.
[root@centos8 ~]#cat /proc/sys/net/core/somaxconn
128

#优化方法：修改内核参数
[root@centos8 ~]$echo net.core.somaxconn = 1024 >> /etc/sysctl.conf
[root@centos8 ~]$sysctl -p
net.core.somaxconn = 1024

#或者把redis中的默认值调成低于128，只起到不会报警的作用
[root@centos8 ~]$grep backlog /etc/redis.conf
# TCP listen() backlog.
# In high requests-per-second environments you need an high backlog in order
# make sure to raise both the value of somaxconn and tcp_max_syn_backlog
tcp-backlog 511

vm.overcommit_memory

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.

#优化方法：修改内核参数
[root@centos8 ~]$echo vm.overcommit_memory = 1 >> /etc/sysctl.conf
[root@centos8 ~]$sysctl -p
net.core.somaxconn = 1024
vm.overcommit_memory = 1

#vm.overcommit_memory内核参数说明
0：表示内核将检查是否有足够的可用内存空间供应用进程使用，如果有足够的可用内存，内存申请允许，否则，内存申请失败，并把错误返回给应用进程
1：表示内核允许分配所有的物理内存，而不管当前的内存状态如何
2：表示内核允许分配超过所有物理内存和交换空间总和的内存

Transparent Huge Pages

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 never > /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.

#解决办法
[root@centos8 ~]$echo 'echo never > /sys/kernel/mm/transparent_hugepage/enabled' >> /etc/rc.d/rc.local 
[root@centos8 ~]$chmod +x /etc/re.d/rc.local
[root@centos8 ~]$bash /etc/rc.d/rc.local

禁用危险操作

[root@aliyun ~]# vim /etc/redis.conf
rename-command KEYS ""
rename-command FLUSHALL ""
rename-command FLUSHDB ""
#或者改成别名
rename-command KEYS "xxx"
rename-command FLUSHALL "xxx"
rename-command FLUSHDB "xxx"

主从复制优化

避免全量复制

主从复制与集群模式

Redis 主从复制

Redis 主从复制概述

一个master可以有多个slave
一个slave只能有一个master
数据流是单向的，master到slave

Redis 主从复制工作原理

从服务器从主服务器同步数据，此过程是非阻塞的
redis主从复制分为全量同步和增量同步

全量复制：

首次同步是全量复制，首先从节点向主节点发送 psync 的同步命令，主节点收到后会将自己的 runid 和 offset 发送给从节点，从节点会保存下来，然后主节点会 fork 一个子进程并执行bgsave命令生产 RDB 快照生成完毕后会发送给从节点，从节点收到后会删除原有的所有数据然后将收到后的 RDB 文件载入自己的内存
在此期间主节点如果有新写入的数据会写入到一个缓冲区中，最后主节点再将缓冲区的内容全部发送给从节点，从节点将剩余的数据进行还原

增量复制：

后期内容发生变化时会进行增量复制，从节点会向主节点发送当前的 offset 位置给主服务器，然后主服务器分析 offset 偏移量将之后的数据以及在缓冲区的积压数据一并发送给从服务器，最后从服务器再保存到其内存中。
PS：offset 位置（等同于MySQL的binlog的位置)

其它描述方式：

1) #从服务器连接主服务器，发送PSYNC命令
2) #主服务器接收到PSYNC命令后，开始执行BGSAVE命令生成RDB快照文件并使用缓冲区记录此后执行的所有写命令
3) #主服务器BGSAVE执行完后，向所有从服务器发送RDB快照文件，并在发送期间继续记录被执行的写命令
4) #从服务器收到快照文件后丢弃所有旧数据，载入收到的快照至内存
5) #主服务器快照发送完毕后，开始向从服务器发送缓冲区中的写命令
6) #从服务器完成对快照的载入，开始接受命令请求，并执行来自主服务器缓冲区的写命令
7) #后期同步会先发送自己slave_repl_offset位置，只同步新增加的数据，不再全量同步

Redis 主从复制实现

实现前注意事项

主节点和从节点的配置文件一定要一样，否则会出现问题
一旦搭好主从，从节点则为只读，不能写入数据了（默认是从节点只读但是也可以修改 replica-read-only）
- 因为数据流是由 master 向 slave 单向传输，所以slave修改数据的话会导致数据差错
主节点重启后会导致run id改变，会导致触发全量复制
主节点一定要开启持久化，防止数据丢失
redis slave也要开启持久化并设置和master同样的连接密码，因为后期slave会有提升为master的可能，slave端切换master同步后会丢失之前的所有数据，而通过持久化可以恢复数据
一旦某个slave成为一个master的slave，redis slave服务会清空当前redis服务器上的所有数据并将master的数据导入到自己的内存中，但是如果只是断开同步关系后，则不会删除当前已经同步过的数据

主节点配置

正常无需配置，但如果使用哨兵功能一定要开启，因为不配置的话当主节点宕机后恢复会因为事先没有配置主从复制而导致无法向新的主节点进行复制

[root@centos8 ~]#vim /etc/redis.conf
replicaof <masterip> <masterport> #指向被复制redis主节点的IP、端口(本机)
masterauth <masterpass>           #指向被复制redis主节点的密码(本机)

从节点配置

#临时生效
127.0.0.1:6379> REPLICAOF master_ip port
127.0.0.1:6379> CONFIG GET masterauth <masterpass>

#永久生效
[root@centos8 ~]#vim /etc/redis.conf
replicaof <masterip> <masterport> #指向被复制redis主节点的IP、端口
masterauth <masterpass>           #指向被复制redis主节点的密码
requirepass password              #主节点的登录密码(为了以后slave成为master没有密码而无法进行复制等问题)

Redis 主从复制优化

[root@centos8 ~]#vim /etc/redis.conf
#master的写入数据缓冲区，用于记录自上一次同步后到下一次同步过程中间的写入命令
#默认只有1MB，生产中要设置的足够大，否则缓冲区过小会导致复制数据不完整
#计算公式：repl-backlog-size = 允许从节点最大中断时长 * 主实例offset每秒写入量，比如master每秒最大写入64mb，最大允许60秒，那么就要设置为64mb*60秒=3840MB(3.8G)，建议此值设的足够大
repl-backlog-size 1mb

#redis同时也提供了当没有slave需要同步的时候，多久可以释放环形队列，默认360秒，值为0 则表示永远不释放这部分内存
repl-backlog-ttl 3600

#是否使用无盘同步RDB文件，默认为no，no为不使用无盘，需要将RDB文件保存到磁盘后再发送给slave，yes为支持无盘，支持无盘就是RDB文件不需要保存至本地磁盘，而是直接通过socket文件发送给slave
repl-diskless-sync no

#diskless时复制的服务器等待的延迟时间
repl-diskless-sync-delay 5

#slave端向server端发送ping的时间区间设置，默认为10秒（探测对方的状态的间隔时间）
repl-ping-replica-period 10

#设置超时时间，默认60秒
repl-timeout 60

#是否启用tcp-nodelay，如设置成yes，则redis会合并小的TCP包从而节省带宽，但会增加同步延迟(40ms)，造成master与slave数据不一致，假如设置成no，则redis会立即发送同步数据，没有延迟，yes关注性能，no关注redis服务中的数据一致性
repl-disable-tcp-nodelay no


#slave端的优先级设置，值是一个整数，数字越小表示优先级越高。当master故障时将会按照优先级来选择slave端进行恢复，如果值设置为0，则表示该slave永远不会被选择
replica-priority 100

#设置一个master的可用slave不能少于多少个，否则master无法执行写
min-replicas-to-write 3

#设置至少由上面数量的slave延迟时间都大于多少秒时，master不接受写操作(拒绝写入)
min-replicas-max-lag 10

删除主从同步

REPLIATOF NO ONE 指令可以取消主从复制

#取消复制，在slave上执行REPLIATOF NO ONE，会断开和master的连接 从而不再进行主从复制，但不会清除slave上已有的数据
127.0.0.1:6379> REPLIATOF NO ONE

—

Redis 级联复制

Redis 级联复制概述

一主一从从在带一个或多个从

Redis 级联复制实现

只需在一主一从的基础上，将新的从节点配置文件IP端口等指向旧的从节点即可