redis学习记录

redis-benchmark压力测试

命令

redis-benchmark -h localhost -p 6379 -c 100 -n 100000

查看redis中的数据库总数：

默认使用第0个
默认安装方式下redis配置文件的路径：

切换数据库和查看数据库大小：

127.0.0.1:6379> select 3 	//切换数据库
OK
127.0.0.1:6379[3]> DBSIZE	//查看数据库大小
(integer) 0

插入和获取值：

127.0.0.1:6379[3]> SET name lvqiang
OK
127.0.0.1:6379[3]> DBSIZE
(integer) 1
127.0.0.1:6379[3]> get name
"lvqiang"

查看所有的key

127.0.0.1:6379[3]> set age 22
OK
127.0.0.1:6379[3]> keys *
1) "age"
2) "name"

清空当前库中所有key

127.0.0.1:6379[3]> flushdb
OK
127.0.0.1:6379[3]> keys *
(empty list or set)

清空所有数据库

127.0.0.1:6379[3]> SELECT 0
OK
127.0.0.1:6379> keys *
1) "myset:__rand_int__"
2) "key:__rand_int__"
3) "mylist"
4) "name"
5) "counter:__rand_int__"
127.0.0.1:6379> SELECT 3
OK
127.0.0.1:6379[3]> keys*
(error) ERR unknown command 'keys*'
127.0.0.1:6379[3]> keys *
(empty list or set)
127.0.0.1:6379[3]> FLUSHALL
OK
127.0.0.1:6379[3]> SELECT 0
OK
127.0.0.1:6379> key *
(error) ERR unknown command 'key'
127.0.0.1:6379> keys *
(empty list or set)

判断某个key是否存在

127.0.0.1:6379> keys *
(empty list or set)
127.0.0.1:6379> EXISTS name
(integer) 0
127.0.0.1:6379> set name lvqiang
OK
127.0.0.1:6379> EXISTS name
(integer) 1

移除某个key

127.0.0.1:6379> MOVE name 1
(integer) 1
127.0.0.1:6379> keys *
(empty list or set)

#设置过期时间

127.0.0.1:6379> set name lvqiang
OK
127.0.0.1:6379> EXPIRE name 3	//设置过期时间
(integer) 1
127.0.0.1:6379> ttl name //查看剩余时间
(integer) -2
127.0.0.1:6379> keys *
(empty list or set)

查看当前key的类型

127.0.0.1:6379> set name lvqiang
OK
127.0.0.1:6379> set age 22
OK
127.0.0.1:6379> type name
string
127.0.0.1:6379> type age
string

String类型

在字符串后面追加内容

127.0.0.1:6379> APPEND name 666
(integer) 10
127.0.0.1:6379> get name
"lvqiang666"

返回的新的字符串的长度

得到字符串的长度

127.0.0.1:6379> STRLEN name
(integer) 10
127.0.0.1:6379> APPEND gender nan
(integer) 3
127.0.0.1:6379> keys *
1) "gender"
2) "age"
3) "name"

使用append如果数据库中没有key就就添加该key

字符串的增和减

127.0.0.1:6379> INCR name
(error) ERR value is not an integer or out of range
127.0.0.1:6379> INCR age
(integer) 23
127.0.0.1:6379> DECR name
(error) ERR value is not an integer or out of range
127.0.0.1:6379> DECR age
(integer) 22
127.0.0.1:6379> INCRBY name 10
(error) ERR value is not an integer or out of range
127.0.0.1:6379> INCRBY age 10
(integer) 32
127.0.0.1:6379> DECRBY name 10
(error) ERR value is not an integer or out of range
127.0.0.1:6379> DECRBY age 10
(integer) 22

字符串的截取和替换

127.0.0.1:6379> GETRANGE name 0 6
"lvqiang"
127.0.0.1:6379> GETRANGE name 0 -1
"lvqiang666"
127.0.0.1:6379> SETRANGE name 7 '777'
(integer) 10
127.0.0.1:6379> get name
"lvqiang777"

存在设置和不存在设置

127.0.0.1:6379> keys *
1) "gender"
2) "age"
127.0.0.1:6379> SETEX name 20 "moumoumou"
OK
127.0.0.1:6379> get name
"moumoumou"
127.0.0.1:6379> ttl name
(integer) 9
127.0.0.1:6379> ttl name
(integer) 1
127.0.0.1:6379> get name
(nil)
127.0.0.1:6379> set name lvqiang
OK
127.0.0.1:6379> SETEX name 20 "moumoumou"
OK
127.0.0.1:6379> get name
"moumoumou"
127.0.0.1:6379> ttl name
(integer) 1
127.0.0.1:6379> ttl name
(integer) -2
127.0.0.1:6379> keys *
1) "gender"
2) "age"
127.0.0.1:6379> SETNX name lvqiang
(integer) 1
127.0.0.1:6379> SETNX name moumou
(integer) 0
127.0.0.1:6379> get name
"lvqiang"

同时设置和同时获取多个值

127.0.0.1:6379> FLUSHDB
OK
127.0.0.1:6379> keys *
(empty list or set)
127.0.0.1:6379> mset name lvqiang age 22
OK
127.0.0.1:6379> mset gender nan name moumou
OK
127.0.0.1:6379> keys *
1) "gender"
2) "age"
3) "name"
127.0.0.1:6379> get name
"moumou"
127.0.0.1:6379> FLUSHDB
OK
127.0.0.1:6379> MSETNX name lvqiang
(integer) 1
127.0.0.1:6379> MSETNX age 22 name moumou
(integer) 0
127.0.0.1:6379> get name
"lvqiang"

MSETNX 具有原子性，一个键不成功则一条命令不成功。

127.0.0.1:6379> keys *
1) "name"
127.0.0.1:6379> set age 22
OK
127.0.0.1:6379> mget name age
1) "lvqiang"
2) "22"
127.0.0.1:6379> mset user:1:name lvqiang user:1:age 22
OK
127.0.0.1:6379> mget user:1:name user:1:age
1) "lvqiang"
2) "22"
127.0.0.1:6379> getset db redis
(nil)
127.0.0.1:6379> getset db mongodb
"redis"
127.0.0.1:6379> get db
"mongodb"

List类型

存和取

127.0.0.1:6379> keys *
(empty list or set)
127.0.0.1:6379> LPUSH list one two three
(integer) 3
127.0.0.1:6379> LRANGE list 0 -1
1) "three"
2) "two"
3) "one"
127.0.0.1:6379> LRANGE list 0 1
1) "three"
2) "two"

可以看见它类似于栈的结构

127.0.0.1:6379> RPUSH list four
(integer) 4
127.0.0.1:6379> LRANGE list 0 -1
1) "three"
2) "two"
3) "one"
4) "four"

移除：

127.0.0.1:6379> LPOP list
"three"
127.0.0.1:6379> RPOP list
"four"
127.0.0.1:6379> LRANGE list 0 -1
1) "two"
2) "one"

取list中的某一个：

127.0.0.1:6379> LRANGE list 0 -1
1) "two"
2) "one"
127.0.0.1:6379> LINDEX list 0
"two"
127.0.0.1:6379> LINDEX list 1
"one"

计算list的长度

127.0.0.1:6379> LLEN list
(integer) 2

移除

127.0.0.1:6379> LPUSH list one two three
(integer) 5
127.0.0.1:6379> LRANGE list 0 -1
1) "three"
2) "two"
3) "one"
4) "two"
5) "one"
127.0.0.1:6379> LREM list 1 one
(integer) 1
127.0.0.1:6379> LRANGE list 0 -1
1) "three"
2) "two"
3) "two"
4) "one"
127.0.0.1:6379> LREM list 2 two
(integer) 2
127.0.0.1:6379> LRANGE list 0 -1
1) "three"
2) "one"

截取list中的部分内容

127.0.0.1:6379> LPUSH list tow four
(integer) 4
127.0.0.1:6379> LRANGE list 0 -1
1) "four"
2) "tow"
3) "three"
4) "one"
127.0.0.1:6379> LTRIM list 0 3
OK
127.0.0.1:6379> LRANGE list 0 -1
1) "four"
2) "tow"
3) "three"
4) "one"
127.0.0.1:6379> LTRIM list 0 2
OK
127.0.0.1:6379> LRANGE list 0 -1
1) "four"
2) "tow"
3) "three"

rpoplpush

移除列表的最后一个元素，将他移动到新的列表中

127.0.0.1:6379> RPOPLPUSH list list1
"three"
127.0.0.1:6379> LRANGE list 0 -1
1) "four"
2) "tow"
127.0.0.1:6379> LRANGE list1 0 -1
1) "three"

从命令也可以很好的解释左边移除右边压入

替换某个位置的值

127.0.0.1:6379> LRANGE list 0 -1
1) "four"
2) "tow"
127.0.0.1:6379> lset list 1 three
OK
127.0.0.1:6379> LRANGE list 0 -1
1) "four"
2) "three"
127.0.0.1:6379> lset list 2 two
(error) ERR index out of range
127.0.0.1:6379> lset list 0 two
OK
127.0.0.1:6379> LRANGE list 0 -1
1) "two"
2) "three"

插入：

127.0.0.1:6379> LINSERT list before two first
(integer) 3
127.0.0.1:6379> LRANGE list 0 -1
1) "first"
2) "two"
3) "three"
127.0.0.1:6379> RPUSH list three
(integer) 4
127.0.0.1:6379> LRANGE list 0 -1
1) "first"
2) "two"
3) "three"
4) "three"
127.0.0.1:6379> LINSERT list before three four
(integer) 5
127.0.0.1:6379> LRANGE list 0 -1
1) "first"
2) "two"
3) "four"
4) "three"
5) "three"
127.0.0.1:6379> LINSERT list after three five
(integer) 6
127.0.0.1:6379> LRANGE list 0 -1
1) "first"
2) "two"
3) "four"
4) "three"
5) "five"
6) "three"

set集合类型

添加

127.0.0.1:6379> sadd myset1 "one" "two" "three"
(integer) 3
127.0.0.1:6379> SMEMBERS myset1
1) "two"
2) "one"
3) "three"
127.0.0.1:6379> SISMEMBER myset1 one	//判断是否是集合中的元素
(integer) 1
127.0.0.1:6379> SISMEMBER myset1 five
(integer) 0

移除

127.0.0.1:6379> scard myset1 
(integer) 3
127.0.0.1:6379> SREM myset1 one
(integer) 1
127.0.0.1:6379> SMEMBERS myset1
1) "two"
2) "three"

随机抽选

127.0.0.1:6379> SRANDMEMBER myset1 
"two"
127.0.0.1:6379> SRANDMEMBER myset1 
"three"

移动

127.0.0.1:6379> SRANDMEMBER myset1 2
1) "two"
2) "three"
127.0.0.1:6379> SMOVE myset1 myset2 "one"
(integer) 0
127.0.0.1:6379> SADD myset2 "myset2"
(integer) 1
127.0.0.1:6379> SMOVE myset1 myset2 "one"
(integer) 0
127.0.0.1:6379> SMOVE myset1 myset2 "two"
(integer) 1
127.0.0.1:6379> SMEMBERS myset1
1) "three"
127.0.0.1:6379> SMEMBERS myset2
1) "two"
2) "myset2"

集合的交并补

127.0.0.1:6379> sadd myset1 a b c
(integer) 3
127.0.0.1:6379> sadd myset2 b c d
(integer) 3
127.0.0.1:6379> sdiff myset1 myset2
1) "a"
127.0.0.1:6379> sdiff myset2 myset1
1) "d"
127.0.0.1:6379> sinter myset1 myset2
1) "c"
2) "b"
127.0.0.1:6379> SUNION myset1 myset2
1) "c"
2) "d"
3) "a"
4) "b"

hash哈希类型

插入和获取

127.0.0.1:6379> hset myhash f1 hello f2 world
(integer) 2
127.0.0.1:6379> HGET myhash f1
"hello"
127.0.0.1:6379> HGET myhash f2
"world"
127.0.0.1:6379> HGETALL myhash
1) "f1"
2) "hello"
3) "f2"
4) "world"
127.0.0.1:6379> HMGET myhash f1 f2
1) "hello"
2) "world"

不存在才插入

127.0.0.1:6379> hsetnx myhash f4 hello
(integer) 1
127.0.0.1:6379> hsetnx myhash f4 hello
(integer) 0

删除

127.0.0.1:6379> HDEL myhash f1
(integer) 1
127.0.0.1:6379> HGETALL myhash
1) "f2"
2) "world"

获取长度

127.0.0.1:6379> HLEN myhash
(integer) 1

判断是否存在

127.0.0.1:6379> HEXISTS myhash f1
(integer) 0
127.0.0.1:6379> HEXISTS myhash f2
(integer) 1

查看所有的key和所有的value

127.0.0.1:6379> HSET myhash f1 hello
(integer) 1
127.0.0.1:6379> HKEYS myhash
1) "f2"
2) "f1"
127.0.0.1:6379> HVALS myhash
1) "world"
2) "hello"

zset(有序集合)

插入：

127.0.0.1:6379> ZADD myzset 0 one 
(integer) 1
127.0.0.1:6379> ZADD myzset 0 two
(integer) 1
127.0.0.1:6379> ZRANGE myzset 0 -1
1) "one"
2) "two"
127.0.0.1:6379> ZADD myzset 0 tree
(integer) 1
127.0.0.1:6379> ZRANGE myzset 0 -1
1) "one"
2) "tree"
3) "two"
127.0.0.1:6379> ZADD myzset 3 four
(integer) 1
127.0.0.1:6379> ZRANGE myzset 0 -1
1) "one"
2) "tree"
3) "two"
4) "four"
127.0.0.1:6379> ZADD myzset 0 a
(integer) 1
127.0.0.1:6379> ZRANGE myzset 0 -1
1) "a"
2) "one"
3) "tree"
4) "two"
5) "four"

排序：

127.0.0.1:6379> ZRANGEBYSCORE myzset -inf +inf withscores
 1) "a"
 2) "0"
 3) "one"
 4) "0"
 5) "tree"
 6) "0"
 7) "two"
 8) "0"
 9) "four"
10) "3"
127.0.0.1:6379> ZRANGEBYSCORE myzset -inf 0 withscores
1) "a"
2) "0"
3) "one"
4) "0"
5) "tree"
6) "0"
7) "two"
8) "0"
127.0.0.1:6379> 

127.0.0.1:6379> ZRANGE myzset 0 -1
1) "a"
2) "one"
3) "tree"
4) "two"
5) "four"
127.0.0.1:6379> zrem myzset one //删除元素
(integer) 1
127.0.0.1:6379> ZRANGE myzset 0 -1
1) "a"
2) "tree"
3) "two"
4) "four"
127.0.0.1:6379> zcard myzset	//统计个数
(integer) 4
127.0.0.1:6379> ZREVRANGE myzset 0 -1	//从大到小排序
1) "four"
2) "two"
3) "tree"
4) "a"

127.0.0.1:6379> zadd myzset 1 bb
(integer) 1
127.0.0.1:6379> ZREVRANGE myzset 0 -1
1) "four"
2) "bb"
3) "two"
4) "tree"
5) "a"
127.0.0.1:6379> ZRANGEBYSCORE myzset -inf +inf withscores
 1) "a"
 2) "0"
 3) "tree"
 4) "0"
 5) "two"
 6) "0"
 7) "bb"
 8) "1"
 9) "four"
10) "3"
127.0.0.1:6379> zcount myzset 0 1	//统计从0到1的个数
(integer) 4

事务

Redis事务本质:一组命令的集合!一个事务中的所有命令都会被序列化，在事务执行过程的中，会按照顺序执行!
一次性、顺序性、排他性!执行一些列的命令

Redis事务没有没有隔离级别的概念

所有的命令在事务中，并没有直接被执行!只有发起执行命令的时候才会执行

redis单条命令是保证原子性的，但是事务不保证原子性
redis的事务∶
开启事务( multi )·
命令入队（… )
执行事务( exec )

127.0.0.1:6379> multi 	//开启事务
OK
127.0.0.1:6379> set k1 v1	//命令入队
QUEUED
127.0.0.1:6379> set k2 v2
QUEUED
127.0.0.1:6379> get k2
QUEUED
127.0.0.1:6379> set k3 v3
QUEUED
127.0.0.1:6379> exec	//执行事务
1) OK
2) OK
3) "v2"
4) OK

放弃事务

127.0.0.1:6379> MULTI
OK
127.0.0.1:6379> get k1
QUEUED
127.0.0.1:6379> get k2
QUEUED
127.0.0.1:6379> set k4 v4
QUEUED
127.0.0.1:6379> discard
OK
127.0.0.1:6379> get k4
(nil)

如果事务队列中存在语法性，那么执行命令的时候，其他命令是可以正常执行的，错误命令抛出异常!

127.0.0.1:6379> set k1 v1
OK
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379> INCR k1
QUEUED
127.0.0.1:6379> set k2 v2
QUEUED
127.0.0.1:6379> set k3 v3
QUEUED
127.0.0.1:6379> get k3
QUEUED
127.0.0.1:6379> EXEC
1) (error) ERR value is not an integer or out of range
2) OK
3) OK
4) "v3"

使用watch实现乐观锁：

执行exec之前的操作

执行失败

配置文件

绑定到的ip地址

绑定到的端口

以守护进程的方式运行默认是no，我们需要自己开启yes

以后台方式运行的pid文件

设置日志级别

日志文件位置

快照，持久化

如果900s内，如果至少有一个1 key进行了修改，我们及进行持久化操作
save 900 1
如果300s内，如果至少10 key进行 了修改，我们及进行持久化操作
save 300 10
如果60s内，如果至少10000 key进行 了修改，我们及进行持久化操作
save 60 10000

持久化出错是否还继续工作

是否压缩rdb文件

保存rdb文件的时候，进行错误的检查校验
rdb文件保存的目录

主从复制

安全

设置密码

可以在配置文件中设置也可以用命令

127.0.0.1:6379> config get requirpass
(empty list or set)
127.0.0.1:6379> config set requirpass 123456
(error) ERR Unsupported CONFIG parameter: requirpass
127.0.0.1:6379> config set requirepass 123456
OK
127.0.0.1:6379> ping
(error) NOAUTH Authentication required.
127.0.0.1:6379> config get requirepass
(error) NOAUTH Authentication required.
127.0.0.1:6379> auth 123456
OK
127.0.0.1:6379> config get requirepass
1) "requirepass"
2) "123456"

最大客户端数量

最大内存数

aof配置

默认是不开启aof模式的，默认是使用rdb方式持久化的，在大部分所有的情况下，rdb完全够用!

每次修改都会sync。 消耗性能
每秒执行一次sync， 可能会丢失这1s的数据!
不执行sync, 这个时候操作系统自己同步数据，速度最快!

RDB

在指定的时间间隔内将内存中的数据集快照写入磁盘,也就是行话讲的Snapshot快照,它恢复时是将快照文件直接读到内存里。Redis会单独创建( fork ) - -个子进程来进行持久化,会先将数据写入到-一个临时文件中,待持久化过程都结束了,再用这个临时文件替换上次持久化好的文件。整个过程中, 主进程是不进行任何I0操作的。这就确保了极高的性能。如果需要进行大规模数据的恢复,且对于数据恢复的完整性不是非常敏感,那RDB方式要比AOF方式更加的高效。RDB的缺点是最后一次持久化后的数据可能丢失。我们默认的就是RDB，一般情况下不需要修改这个配置。

保存规则

lvqiang@ubuntu:/etc$ redis-cli 
127.0.0.1:6379> set key1 v1
OK
127.0.0.1:6379> set key2 v2
OK
127.0.0.1:6379> set key3 v3
OK
lvqiang@ubuntu:/etc$ /etc/init.d/redis-server stop
[ ok ] Stopping redis-server (via systemctl): redis-server.service.
lvqiang@ubuntu:/etc$ redis-server 
lvqiang@ubuntu:/etc$ redis-cli 
127.0.0.1:6379> get key1
"v1"

触发机制
1、save的规则满足的情况下,会自动触发rdb规则
2、执行flushall命令,也会触发我们的rdb规则!
3、退出redis ,也会产生rdb文件!
备份就自动生成一个dump.rdb
如果恢复rdb文件!
1、只需要将rdb文件放在我们redis启动目录就可以, redis启动的时候会自动检查dump.rdb恢复其中的数据!
2、查看需要存在的位置

优点:
1、适合大规模的数据恢复!
2、对数据的完整性要不高!
I缺点:
1、需要一定的时间间隔进程操作!如果redis意外宕机了,这个最后一次修改数据就没有的了!
2、fork进程的时候 ,会占用一定的内容空间! !

AOF

将我们的所有命令都记录下来
默认是不开启的,我们需要手动进行配置!我们只需要将appendonly改为yes就开启了aof !
重启, redis就可以生效了!
如果这个aof文件有错位,这时候redis是启动不起来的吗,我们需要修复这个aof文件
redis给我们提供了一个工具redi s-check-aof --fix
优点:
1、每一次修改都同步,文件的完整会更加好!
2、每秒同步- -次 ,可能会丢失- -秒的数据
3、从不同步,效率最高的!
缺点:
1、相对于数据文件来说, aof远远大于rdb ,修复的速度也比rdb慢!
2、Aof 运行效率也要比rdb慢,所以我们redis默认的配置就是rdb持久化!

重写：
aof默认就是文件的无限追加,文件会越来越大!|
如果aof文件大于64m,太大了! fork- 个新的进程来将我们的文件进行重写!

订阅发布

先订阅，等待发布者发布就可以接受消息

发布者发布后所有的订阅者就可以接收消息

主从复制

主从复制,是指将-台Redis服务器的数据，复制到其他的Redis服务器。前者称为主节点(master/leader) ,后者称为从节点
(slave/follower) ;数据的复制是单向的,只能由主节点到从节点。Master以写为主 , Slave以读为主。
默认情况下,每台Redis服务器都是主节点;且-个主节点可以有多个从节点(或没有从节点) ,但一个从节点只能有一一个主节点。
主从复制的作用主要包括:
1、数据冗余:主从复制实现了数据的热备份,是持久化之外的一种数据冗余方式。
2、故障恢复:当主节点出现问题时,可以由从节点提供服务,实现快速的故障恢复;实际上是一种服务的冗余。
3、负载均衡:在主从复制的基础上,配合读写分离,可以由主节点提供写服务,由从节点提供读服务(即写Redis数据时应用连接
主节点，读Redis数据时应用连接从节点) , 分担服务器负载;尤其是在写少读多的场景下,通过多个从节点分担读负载,可以大
大提高Redis服务器的并发量。
4、高可用基石:除了.上述作用以外,主从复制还是哨兵和集群能够实施的基础,因此说主从复制是Redis高可用的基础。

环境配置

127.0.0.1:6379> info replication
# Replication
role:master	//角色master
connected_slaves:0	//从机数
master_replid:9003356f0cdcad3ca8c6e8d400b15e56ce0b8c53
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:0
second_repl_offset:-1
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0

默认三台都是主机，现在配置从机，配置两台从机

主机信息

真实的从主配置应该在配置文件中配置,这样的话是永久的,我们这里使用的是命令,暂时的!

第一个区域是配置主机的地址和端口，第二个区域是配置主机的密码，如果没有密码就不用设置。

主机可以写,从机不能写只能读!主机中的所有信息和数据,都会自动被从机保存!



测试：主机断了又重新连上

断开后两从机的信息，仍然能够查询

主机断开有重新连接后又能查询主机新添加的内容

如果是使用命令行,来配置的主从,这个时候如果重启了,就会变回主机!只要变为从机,立马就会从主机中获取值!

复制原理
Slave启动成功连接到master后会发送一个sync同步 命令Master接到命令,启动后台的存盘进程,同时收集所有接收到的用于修改数据集命令,在后台进程执行完毕之后, master将传送整个数据文件到slave ,并完成- -次完全同步。
全量复制:而slave服务在接收到数据库文件数据后,将其存盘并加载到内存中。
增量复制: Master继续将新的所有收集到的修改命令依次传给slave ,完成同步
但是只要是重新连接master , - -次完全同步(全量复制)将被自动执行!我们的数据一定可以在从机中看到 !|

尝试下面这种配置：





将第二台设置成主机后又能工作

哨兵模式

主从切换技术的方法是:当主服务器宕机后,需要手动把一台从服务器切换为主服务器,这就需要人工干预,费事费力,还会造成一段时间内服务不可用。这不是一种推荐的方式,更多时候,我们优先考虑哨兵模式。Redis从2.8开始正式提供 了Sentinel (哨
兵)架构来解决这个问题。
谋朝篡位的自动版,能够后台监控主机是否故障,如果故障了根据投票数自动将从库转换为主库。
哨兵模式是一种特殊的模式,首先Redis提供了哨兵的命令,哨兵是一个独立的进程,作为进程,它会独立运行。其原理是哨兵通
过发送命令,等待Redis服务器响应,从而监控运行的多个Redis实例。

这里的哨兵有两个作用
●通过发送命令,让Redis服务器返回监控其运行状态,包括主服务器和从服务器。
●当哨兵监测到master宕机,会自动将slave切换成master ,然后通过发布订阅模式通知其他的从服务器,修改配置文件,让它们切换主机。然而一个哨兵进程对Redis服务器进行监控,可能会出现问题,为此,我们可以使用多个哨兵进行监控。各个哨兵之间还会进行监
控,这样就形成了多哨兵模式。

假设主服务器宕机;哨兵1先检测到这个结果,系统并不会马上进行failover过程,仅仅是随兵1主观的认为主服务器不可用,这个现象成为主观下线。当后面的哨兵也检测到主服务器不可用,并且数量达到一-定值时,那么哨兵之间就会进行- -次投票 ,投票的结
果由一个哨兵发起,进行failover[故障转移]操作。切换成功后,就会通过发布订阅模式,让各个哨兵把自己监控的从服务器实现切换主机,这个过程称为客观下线。

哨兵的配置文件

启动哨兵：

关闭主机：

哨兵自动选举产生主机

优点:
1、哨兵集群,基于主从复制模式,所有的主从配置优点，它全有
2、主从可以切换 ,故障可以转移,系统的可用性就会更好
3、哨兵模式就是主从模式的升级,手动到自动,更加健壮!
缺点:
1、Redis不好在线扩容的,集群容量一旦到达上限,在线扩容就十分麻烦!
2、实现哨兵模式的配置其实是很麻烦的,里面有很多选择!

缓存穿透以缓存雪崩

缓存穿透概念

缓存穿透的概念很简单,用户想要查询一-个数据,发现redis内存数据库没有,也就是缓存没有命中,于是向持久层数据库查询。发现也没有,于是本次查询失败。当用户很多的时候,缓存都没有命中，于是都去请求了持久层数据库。这会给持久层数据库造成很大的压力,这时候就相当于出现了缓存穿透。


但是这种方法会存在两个问题:
1、如果空值能够被缓存起来,这就意味着缓存需要更多的空间存储更多的键,因为这当中可能会有很多的空值的键;
2、即使对空值设置了过期时间,还是会存在缓存层和存储层的数据会有一-段时间窗口的不- 致,这对于需要保持一致性的业务会有影响。

缓存击穿概述

这里需要注意和缓存击穿的区别,缓存击穿,是指一个key非常热点 ,在不停的扛着大并发,大并发集中对这一个点进行访问,当这个key在失效的瞬间,持续的大并发就穿破缓存,直接请求数据库,就像在一个屏障上凿开了一个洞。
当某个key在过期的瞬间,有大量的请求并发访问,这类数据一般是热点数据,由于缓存过期,会同时访问数据库来查询最新数据,并且回写缓存,会导使数据库瞬间压力大。

缓存雪崩概念

缓存雪崩,是指在某一个时间段,缓存集中过期失效。
产生雪崩的原因之- - - , 比如在写本文的时候,马上就要到双十二零点,很快就会迎来一波抢购,这波商品时间比较集中的放入了缓存,假设缓存一个小时。 那么到了凌晨- -点钟的时候 ,这批商品的缓存就都过期了。而对这批商品的访问查询,都落到了数据库上,对于数据库而言,就会产生周期性的压力波峰。于是所有的请求都会达到存储层,存储层的调用量会暴增,造成存储层也会挂掉的情况。

其实集中过期,倒不是非常致命，比较致命的缓存雪崩,是缓存服务器某个节点宕机或断网。因为自然形成的缓存雪崩，- 定是在某个时间段集中创建缓存,这个时候,数据库也是可以顶住压力的。无非就是对数据库产生周期性的压力而已。而缓存服务节点的宕机,对数据库服务器造成的压力是不可预知的,很有可能瞬间就把数据库压垮。