Redis的一些总结

一、redis的数据类型

1、String（字符串）

  1. #追加字符串，没有的话就新建
  2. append name “wangqin”
  3. #字符串长度
  4. strlen name
  5. #i++
  6. set count 0
  7. incr count
  8. #i–
  9. decr count
  10. #指定增量 count = count + 10
  11. incrby count 10
  12. #指定减量 count = count - 10
  13. decrby count 10
  14. #截取字符串 wangqin
  15. getrange key 0 3
  16. “wang”
  17. #替换
  18. setrange key 1 qq
  19. “wqqgqin”
  20. #设置过期时间
  21. setex key 30 “hello”
  22. #不存在再设置，往往在分布式中使用,如果key1不存在就创建，存在就创建失败
  23. setnx key1 “redis”
  24. #批量设置
  25. mset k1 v1 k2 v2 k3 v3
  26. #批量获取
  27. mget k1 k2
  28. #要么一起成功，要么一起失败，保持原子性
  29. msetnx k1 v1 k2 v2
  30. #先获取在写入，不存在值为nil，存在的话获取原来的值在设置新的值
  31. getset

2、List（列表）

  1. #将一个值或者多个值插入list的头部
  2. 127.0.0.1:6379> lpush list one
  3. (integer) 1
  4. 127.0.0.1:6379> lpush list two
  5. (integer) 2
  6. 127.0.0.1:6379> lpush list three
  7. (integer) 3
  8. #查看list，头->尾
  9. 127.0.0.1:6379> lrange list 0 -1
  10. 1) "three"
  11. 2) "two"
  12. 3) "one"
  13. 127.0.0.1:6379> lrange list 0 1
  14. 1) "three"
  15. 2) "two"
  16. 127.0.0.1:6379> rpush list right
  17. (integer) 4
  18. #将一个值或者多个值插入list的尾部
  19. 127.0.0.1:6379> lrange list 0 -1
  20. 1) "three"
  21. 2) "two"
  22. 3) "one"
  23. 4) "right"
  24. #移除list第一个元素
  25. 127.0.0.1:6379> lpop list
  26. "three"
  27. 127.0.0.1:6379> lrange list 0 -1
  28. 1) "two"
  29. 2) "one"
  30. 3) "right"
  31. #移除list最后一个元素
  32. 127.0.0.1:6379> rpop list
  33. "right"
  34. 127.0.0.1:6379> lrange list 0 -1
  35. 1) "two"
  36. 2) "one"
  37. #根据下标获取值
  38. 127.0.0.1:6379> lindex list 0
  39. #获取list长度
  40. 127.0.0.1:6379> llen list
  41. (integer) 2
  42. 127.0.0.1:6379> lrange list 0 -1
  43. 1) "three"
  44. 2) "two"
  45. 3) "two"
  46. 4) "one"
  47. #从上至下删除一个 two
  48. 127.0.0.1:6379> lrem list 1 two
  49. (integer) 1
  50. 127.0.0.1:6379> lrange list 0 -1
  51. 1) "three"
  52. 2) "two"
  53. 3) "one"
  54. 127.0.0.1:6379>

3、Set（集合）

  1. #添加Set元素
  2. 127.0.0.1:6379> sadd myset v1 v2 v3 v4
  3. (integer) 4
  4. #显示所有myset集合中的元素
  5. 127.0.0.1:6379> smembers myset
  6. 1) "v1"
  7. 2) "v3"
  8. 3) "v4"
  9. 4) "v2"
  10. #查询v1是否存在myset集合中，存在就返回1，不存在就返回0
  11. 127.0.0.1:6379> sismember myset v1
  12. (integer) 1
  13. 127.0.0.1:6379> sismember myset v6
  14. (integer) 0
  15. 127.0.0.1:6379> sadd uset k1 k2 k3 v1
  16. (integer) 4
  17. #合并集合myset和uset到集合set中，set重复的取一个就行
  18. 127.0.0.1:6379> sunionstore set myset uset
  19. (integer) 7
  20. #合并显示集合myset和uset
  21. 127.0.0.1:6379> sunion myset uset
  22. 1) "v1"
  23. 2) "v3"
  24. 3) "k1"
  25. 4) "k3"
  26. 5) "v4"
  27. 6) "k2"
  28. 7) "v2"
  29. #set集合的长度
  30. 127.0.0.1:6379> scard set
  31. (integer) 6
  32. #随机删除set中的元素
  33. 127.0.0.1:6379> spop set
  34. "v4"
  35. #移动指定的一个值到其他的集合中set->myset
  36. 127.0.0.1:6379> smove set myset k1
  37. #两个集合的差集
  38. 127.0.0.1:6379> smembers set
  39. 1) "v3"
  40. 2) "k3"
  41. 3) "k2"
  42. 4) "v2"
  43. 127.0.0.1:6379> smembers myset
  44. 1) "v1"
  45. 2) "v3"
  46. 3) "v4"
  47. 4) "v2"
  48. 5) "k1"
  49. 127.0.0.1:6379> sdiff myset set
  50. 1) "v1"
  51. 2) "k1"
  52. 3) "v4"
  53. #两个集合的交集
  54. 127.0.0.1:6379> sinter myset set
  55. 1) "v3"
  56. 2) "v2"
  57. #两个集合的并集
  58. 127.0.0.1:6379> sunion myset set
  59. 1) "v1"
  60. 2) "v3"
  61. 3) "k1"
  62. 4) "k3"
  63. 5) "v4"
  64. 6) "k2"
  65. 7) "v2"

4、Hash（哈希）

  1. #set一个具体的 key-value
  2. 127.0.0.1:6379> hset myhash name wangqin
  3. (integer) 1
  4. #获取一个字段值
  5. 127.0.0.1:6379> hget myhash name
  6. "wangqin"
  7. #set一组 key-value
  8. 127.0.0.1:6379> hmset myhash name wangqin1 age 18
  9. OK
  10. #获取一组 key-value
  11. 127.0.0.1:6379> hmget myhash name age
  12. 1) "wangqin1"
  13. 2) "18"
  14. #获取全部数据
  15. 127.0.0.1:6379> hgetall myhash
  16. 1) "name"
  17. 2) "wangqin1"
  18. 3) "age"
  19. 4) "18"
  20. #删除指定的key
  21. 127.0.0.1:6379> hdel myhash name
  22. (integer) 1
  23. 127.0.0.1:6379> hgetall myhash
  24. 1) "age"
  25. 2) "18"
  26. 127.0.0.1:6379> hmset myhash name wangqin set male
  27. OK
  28. #获取hash表的字段数量
  29. 127.0.0.1:6379> hlen myhash
  30. (integer) 3
  31. #hash表中是否存在key
  32. 127.0.0.1:6379> hexists myhash name
  33. (integer) 1
  34. 127.0.0.1:6379> hexists myhash name1
  35. (integer) 0
  36. #获取hash表的key
  37. 127.0.0.1:6379> hkeys myhash
  38. 1) "age"
  39. 2) "name"
  40. 3) "set"
  41. #获取hash表的值
  42. 127.0.0.1:6379> hvals myhash
  43. 1) "18"
  44. 2) "wangqin"
  45. 3) "male"

5、Zset（有序集合）

  1. #添加zset元素
  2. 127.0.0.1:6379> zadd zset 1 one
  3. (integer) 1
  4. #批量添加zset元素
  5. 127.0.0.1:6379> zadd zset 2 two 3 three
  6. (integer) 2
  7. #获取zset中所有元素
  8. 127.0.0.1:6379> zrange zset 0 -1
  9. 1) "one"
  10. 2) "two"
  11. 3) "three"
  12. #倒序查询
  13. 127.0.0.1:6379> zrevrange zset 0 -1
  14. 1) "three"
  15. 2) "two"
  16. 3) "one"
  17. 127.0.0.1:6379> zadd zset -1 -one
  18. (integer) 1
  19. 127.0.0.1:6379> zadd zset -2 -two
  20. (integer) 1
  21. #正序排序，从-∞到+∞
  22. 127.0.0.1:6379> zrangebyscore zset -inf +inf
  23. 1) "-two"
  24. 2) "-one"
  25. 3) "one"
  26. 4) "two"
  27. 5) "three"
  28. 127.0.0.1:6379> zrangebyscore zset -1 +inf
  29. 1) "-one"
  30. 2) "one"
  31. 3) "two"
  32. 4) "three"
  33. #倒序排序，从+∞到-∞
  34. 127.0.0.1:6379> zrevrangebyscore zset +inf -1
  35. 1) "three"
  36. 2) "two"
  37. 3) "one"
  38. 4) "-one"
  39. 127.0.0.1:6379> zrem zset one
  40. (integer) 1
  41. 127.0.0.1:6379> zrange zset 0 -1
  42. 1) "-two"
  43. 2) "-one"
  44. 3) "two"
  45. 4) "three"
  46. #集合的长度
  47. 127.0.0.1:6379> zcard zset
  48. (integer) 4

6、geospatital（地理位置）

  1. #添加地理位置
  2. 127.0.0.1:6379> geoadd China:city 116.42 29.90 home
  3. (integer) 1
  4. 127.0.0.1:6379> geoadd China:city 117.30 31.79 hefei
  5. (integer) 1
  6. 127.0.0.1:6379> geoadd China:city 120.21  30.20 hangzhou
  7. (integer) 1
  8. 127.0.0.1:6379> geoadd China:city 121.48 31.40 shenzhen
  9. (integer) 1
  10. 127.0.0.1:6379> geoadd China:city 106.54 29.40 chongqing
  11. (integer) 1
  12. #获取纬度和经度
  13. 127.0.0.1:6379> geopos China:city home
  14. 1) 1) "116.41999751329421997"
  15.  2) "29.90000043079877656"
  16. #获取两地距离
  17. 127.0.0.1:6379> geodist China:city home hefei
  18. "226388.9875"
  19. 127.0.0.1:6379> geodist China:city home hefei km
  20. "226.3890"
  21. # 距离115 30范围300km的地方
  22. 127.0.0.1:6379> georadius China:city 115 30 300 km
  23. 1) "home"
  24. 2) "hefei"

7、Hyperloglog

用于大数据量下的去重计数，有约0.81%的误差率，但非常节省内存，如统计网站UV

  1. 如果可以允许容错的话可以使用Hyperloglog，0.81%的容错率
  2. #创建元素
  3. 127.0.0.1:6379> pfadd mykey a b c d e f g
  4. (integer) 1
  5. #统计mykey元素的基数数量
  6. 127.0.0.1:6379> pfcount mykey
  7. (integer) 7
  8. 127.0.0.1:6379> pfadd ukey q w e r t y u i o p
  9. (integer) 1
  10. #合并两组 mkey ukey->key，会去重
  11. 127.0.0.1:6379> pfmerge key mykey ukey
  12. OK
  13. 127.0.0.1:6379> pfcount key
  14. (integer) 15

8、Bitmap(位图)

基于String的位操作，非常适合二值状态统计，如用户签到

  1. 位图，只有两种状态的，操作二进制来进行记录，只有0 1两个状态
  2. #添加元素
  3. 127.0.0.1:6379> setbit sign 0 1
  4. (integer) 0
  5. 127.0.0.1:6379> setbit sign 1 1
  6. (integer) 0
  7. 127.0.0.1:6379> setbit sign 2 0
  8. (integer) 0
  9. 127.0.0.1:6379> setbit sign 3 0
  10. (integer) 0
  11. #查询元素
  12. 127.0.0.1:6379> getbit sign 3
  13. (integer) 0
  14. 127.0.0.1:6379> getbit sign 1
  15. (integer) 1
  16. #统计次数
  17. 127.0.0.1:6379> bitcount sign
  18. (integer) 3

9、Stream：

提供了完整的消息队列功能，支持消费者组，用于异步任务处理、消息流等。常用命令有 XADD、XREAD

二、事务

  1. #开启一组事务
  2. 127.0.0.1:6379> multi
  3. OK
  4. 127.0.0.1:6379> set k1 v1
  5. QUEUED
  6. 127.0.0.1:6379> set k2 v2
  7. QUEUED
  8. 127.0.0.1:6379> get k2
  9. QUEUED
  10. 127.0.0.1:6379> set k3 v3
  11. QUEUED
  12. #执行事务
  13. 127.0.0.1:6379> exec
  14. 1) OK
  15. 2) OK
  16. 3) "v2"
  17. 4) OK
  18. #放弃事务
  19. 127.0.0.1:6379> multi
  20. OK
  21. 127.0.0.1:6379> set k4 v4
  22. QUEUED
  23. 127.0.0.1:6379> set k5 v5
  24. QUEUED
  25. 127.0.0.1:6379> discard
  26. OK
  27. 127.0.0.1:6379> get v4
  28. (nil)

三、Redis持久化

1、RDB

什么是RDB

Redis的一些总结一、redis的数据类型1、S - 图1

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

RDB持久化是把当前进程数据生成快照保存到硬盘的过程，触发RDB持久化过程分为手动触发和自动触

发rdb保存的文件时dump.rdb 都是在我们配置文件快照中进行配置的

触发机制

  • save的规则满足的情况下，会自动触发rdb规则
  • 执行flushall命令，也会触发
  • 退出redis

Redis的一些总结一、redis的数据类型1、S - 图2

如何恢复rdb文件

  1. 1. 将dump.rdb放在我们的redis启动目录下就可以，redis启动的时候会自动检查dump.rdb恢复数据
  2. 2. 查看需要存在的位置
  3. 127.0.0.1:6379> config get dir
  4. 1) "dir"
  5. 2) "/usr/local/bin"

优缺点

  • 优点：

适合大规模的数恢复

对数据的完整性要求不高

  • 缺点：

需要一定的时间间隔进程操作，如果redis意外宕机了，这个最后一场修改数据就没有了

fork进程的时候会占用一定的内容空间

2、AOF(Append Only File)

将我们的所有命令记录下来，恢复的时候就把这个文件里面的命令全部执行一遍

Redis的一些总结一、redis的数据类型1、S - 图3

以日志的形式来记录每个写操作，将Redis执行过得所有指令记录下来（读操作不记录），只追加文件但不可以改写文件，redis启动之初读取该文件重新构建数据库，即redis重启的话根据日志文件的内容将写指令从前到后执行一次完成数据库的恢复工作

优缺点

  1. 优点
  2. 每一次修改都要同步，文件的完整性更好
  3. 每秒同步一次，可能会丢失这一秒的数据
  4. 从不同步，效率最高
  6. 缺点
  7. 相对于数据文件，AOF远远大于RDB，修复速度也比rdb慢
  8. AOF效率也比RDB慢

四、发布和订阅消息

  • 使用 subscribe 频道名 进行订阅监听

  • 使用 publish 频道名 发布的内容 进行发布消息广播；

订阅监听

  1. 127.0.0.1:6379> subscribe wangqin
  2. Reading messages... (press Ctrl-C to quit)
  3. 1) "subscribe"
  4. 2) "wangqin"
  5. 3) (integer) 1
  6. 1) "message"
  7. 2) "wangqin"
  8. 3) "hello, qin"

发布消息广播

  1. 127.0.0.1:6379> publish wangqin "hello, qin"
  2. (integer) 1

五、主从复制

1、主从复制

主从复制,是指将一台Redis服务器的数据 ,复制到其他的Redis服务器I前者称为主节点(master/leader)，

后者称为从节点(slave/follower)数据的复制是单向的，只能由主节点到从节点，Master以写为主, Slave

以读为主。

默认情况下,每台Redis服务器都是主节点，且一个主节点可以有多个从节点(或没有从节点) ,但一个从节

点只能有一一个主节点。主从复制的作用主要包括:

  • 数据冗余：主从复制实现了数据的热备份,是持久化之外的一种数据冗余方式。
  • 故障恢复：当主节点出现问题时,可以由从节点提供服务,实现快速的故障恢复;实际上是一种服务的冗余。
  • 负载均衡：在主从复制的基础上,配合读写分离,可以由主节点提供写服务,由从节点提供读服务(即写Redis数据时应用连接主节点,读Redis数据时应用连接从节点) , 分担服务器负载;尤其是在写少读多的场景下,通过多个从节点分担读负载,可以大大提高Redis服务器的并发量。
  • 高可用基石:除了.上述作用以外,主从复制还是哨兵和集群能够实施的基础,因此说主从复制是Redis高可用的基础。一般来说,要将Redis运用于工程项目中,只使用一台Redis是万万不能的,原因如下:
  • 从结构上,单个Redis服务器会发生单点故障,并且一台服务器需要处理所有的请求负载,压力较大;
  • 从容量上,单个Redis服务器内存容量有限,就算一台Redis服务器内存容量为256G ,也不能将所有内存用作Redis存储内存， 一般来说 ,单台Redis最大使用内存不应该超过20G。电商网站上的商品,一般都是一次上传,无数次浏览的,说专业点也就是”多读少写”

Redis的一些总结一、redis的数据类型1、S - 图4

主从复制配置过程

  1. 在
  2. redis-cli
  3. 应用中配置主从 
  4. slaveof
  5.  127
  6. .0
  7. .0
  8. .1
  9.  6380
  10. 这里以主服务器：192
  11. .168
  12. .238
  13. .143
  14.  ；从服务器：192
  15. .168
  16. .238
  17. .144
  18.  为例；
  19. 配置从服务器的 
  20. redis
  21. .conf
  22.  ，添加：
  23. 配置主机：
  24. replicaof
  25.  127
  26. .0
  27. .0
  28. .1
  29.  6380
  30. 密码：
  31. masterauth
  32.  <
  33. master-password
  34. >
  35. 配置从机只能做读操作 
  36. replica-read-only
  37. yes
  38. 如果主机断开连接，从机依旧连接到主机的，但是没有写操作。如果主机回来，从机依旧可以直接获取
  39. 到主机写的信息

复制原理

Slave启动成功连接到master后会发送一个sync同步命令Master接到命令，启动后台的存盘进程，同时收集所有接收到的用于修改数据集命令，在后台进程执行完毕之后，master将传送整个数据文件到slave，并完成一次完全同步。全量复制:而slave服务在接收到数据库文件数据后，将其存盘并加载到内存中。[root@qin bin]# redis-cli -p 6380127.0.0.1:6380> info replication# Replicationrole:master #主机connected_slaves:2 #从机两个 6379和6380slave0:ip=127.0.0.1,port=6379,state=online,offset=266,lag=1slave1:ip=127.0.0.1,port=6381,state=online,offset=266,lag=1master_replid:ee9893cc165118d4639a473c3db9bb55b7e29248master_replid2:0000000000000000000000000000000000000000master_repl_offset:266second_repl_offset:-1repl_backlog_active:1repl_backlog_size:1048576repl_backlog_first_byte_offset:1repl_backlog_histlen:266增量复制:Master继续将新的所有收集到的修改命令依次传给slave，完成同步但是只要是重新连接master,一次完全同步(全量复制)将被自动执行

层层链路

Redis的一些总结一、redis的数据类型1、S - 图5

2、哨兵模式

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

Redis的一些总结一、redis的数据类型1、S - 图6

主要是在 Redis 2.0 中的，用于对主服务器进行监控功能一：监控主数据库和从数据库是否正常运行；功能二：主数据库出现故障时候，可以自动将从数据库转换为主数据库，实现自动切换；实现步骤：修改从服务器的 sentinel.confsentinel monitor myredis 192.168.238.143 6379 1 # 主数据库名称、IP、端口、投票选举次数sentinel down-after-milliseconds myredis 5000 #默认 1 秒检查一次，这里配置超时 5000 毫秒为宕机；sentinel failover-timeout myredis 900000sentinel parallel-syncs myredis 2sentinel can-failover myredis yes

启动 sentinel 哨兵

[root@qin bin]# redis-sentinel qconfig/sentinel.conf72466:X 08 Dec 2020 02:41:53.764 # oO0OoO0OoO0Oo Redis is startingoO0OoO0OoO0Oo72466:X 08 Dec 2020 02:41:53.764 # Redis version=5.0.7, bits=64,commit=00000000, modified=0, pid=72466, just started72466:X 08 Dec 2020 02:41:53.764 # Configuration loaded . .-``__ ‘’-. .-` . `. ‘’-. Redis 5.0.7 (00000000/0) 64 bit.-`` .-.\/ ., ‘’-. ( ‘ , .-|, ) Running in sentinel mode|-._-…-__...-.``-._|' .-‘| Port: 26379| `-. ._ / _.-' | PID: 72466-. `-. -./ _.-' _.-' |-.`-. -.__.-' _.-'_.-'| |-.`-. .-‘.-‘ | http://redis.io -._-.`-.__.-‘.-‘ .-‘ |`-.-._-..-‘ .-‘.-‘| | -._-. .-‘.-‘ | `-. -._-..-‘.-‘ .-‘ -._-..-‘ .-‘ `-. _.-‘ `-..-‘ 72466:X 08 Dec 2020 02:41:53.765 # WARNING: The TCP backlog setting of 511cannot be enforced because /proc/sys/net/core/somaxconn is set to the lowervalue of 128.72466:X 08 Dec 2020 02:41:53.765 # Sentinel ID isdf5d73e7709db2ce099fa9b7432a58281b982f4872466:X 08 Dec 2020 02:41:53.765 # +monitor master myredis 127.0.0.1 6380quorum 1

若主机断开了，哨兵会选举一个从机作为主机。如果主机后来回来了，只能归并到新的主机下当做从机。

  • 优点：

哨兵集群,基于主从复制模式,所有的主从配置优点，它全有。

主从可以切换 ,故障可以转移,系统的可用性就会更好。

哨兵模式就是主从模式的升级,手动到自动,更加健壮。

  • 缺点:

Redis 不好啊在线扩容的，集群容量一旦到达上限,在线扩容就十分麻烦！实现哨兵模式的配置其实是很麻烦的，里面有很多选择

Redis的一些总结一、redis的数据类型1、S - 图7

假设主服务器宕机，哨兵1先检测到这个结果，系统并不会马上进行failover故障转移过程，仅仅是哨兵1

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

配置文件

  1. # Example sentinel.conf 
  2. # 哨兵sentinel实例运行的端口 默认26379 
  3. port 
  4. 26379
  5. # 哨兵sentinel的工作目录 
  6. dir /tmp 
  7. # 哨兵sentinel监控的redis主节点的 ip port 
  8. # master-name 可以自己命名的主节点名字 只能由字母A-z、数字0-9 、这三个字符".-_"组成。 
  9. # quorum 当这些quorum个数sentinel哨兵认为master主节点失联 那么这时 客观上认为主节点失联了
  10. # sentinel monitor <master-name> <ip> <redis-port> <quorum> 
  11. sentinel monitor mymaster 
  12. 127.0
  13. .0
  14. .1
  15. 6379
  16. 2
  17. # 当在Redis实例中开启了requirepass foobared 授权密码 这样所有连接Redis实例的客户端都要提供
  18. 密码 
  19. # 设置哨兵sentinel 连接主从的密码 注意必须为主从设置一样的验证密码 
  20. # sentinel auth-pass <master-name> <password> 
  21. sentinel auth-pass mymaster MySUPER--secret
  22. -0123
  23. password 
  24. # 指定多少毫秒之后 主节点没有应答哨兵sentinel 此时 哨兵主观上认为主节点下线 默认30秒 
  25. # sentinel down-after-milliseconds <master-name> <milliseconds> 
  26. sentinel down-after-milliseconds mymaster 
  27. 30000
  28. # 这个配置项指定了在发生failover主备切换时最多可以有多少个slave同时对新的master进行 同步， 
  29. 这个数字越小，完成failover所需的时间就越长， 
  30. 但是如果这个数字越大，就意味着越 多的slave因为replication而不可用。 
  31. 可以通过将这个值设为 
  32. 1
  33.  来保证每次只有一个slave 处于不能处理命令请求的状态。 
  34. # sentinel parallel-syncs <master-name> <numslaves>
  36. sentinel parallel-syncs mymaster 
  37. 1
  38. # 故障转移的超时时间 failover-timeout 可以用在以下这些方面： 
  39. #1. 同一个sentinel对同一个master两次failover之间的间隔时间。 
  40. #2. 当一个slave从一个错误的master那里同步数据开始计算时间。直到slave被纠正为向正确的master那
  41. 里同步数据时。 
  42. #3.当想要取消一个正在进行的failover所需要的时间。  
  43. #4.当进行failover时，配置所有slaves指向新的master所需的最大时间。不过，即使过了这个超时，
  44. slaves依然会被正确配置为指向master，但是就不按parallel-syncs所配置的规则来了 
  45. # 默认三分钟 
  46. # sentinel failover-timeout <master-name> <milliseconds> 
  47. sentinel failover-timeout mymaster 
  48. 180000
  49. # SCRIPTS EXECUTION 
  50. #配置当某一事件发生时所需要执行的脚本，可以通过脚本来通知管理员，例如当系统运行不正常时发邮件通知
  51. 相关人员。 
  52. #对于脚本的运行结果有以下规则： 
  53. #若脚本执行后返回1，那么该脚本稍后将会被再次执行，重复次数目前默认为10 
  54. #若脚本执行后返回2，或者比2更高的一个返回值，脚本将不会重复执行。 
  55. #如果脚本在执行过程中由于收到系统中断信号被终止了，则同返回值为1时的行为相同。 
  56. #一个脚本的最大执行时间为60s，如果超过这个时间，脚本将会被一个SIGKILL信号终止，之后重新执行。
  57. #通知型脚本:当sentinel有任何警告级别的事件发生时（比如说redis实例的主观失效和客观失效等等），
  58. 将会去调用这个脚本， 
  59. 这时这个脚本应该通过邮件，SMS等方式去通知系统管理员关于系统不正常运行的信息。调用该脚本时，将传
  60. 给脚本两个参数， 
  61. 一个是事件的类型， 
  62. 一个是事件的描述。 
  63. 如果sentinel.conf配置文件中配置了这个脚本路径，那么必须保证这个脚本存在于这个路径，并且是可执
  64. 行的，否则sentinel无法正常启动成功。 
  65. #通知脚本 
  66. # sentinel notification-script <master-name> <script-path> 
  67. sentinel notification-script mymaster /var/redis/notify.sh 
  68. # 客户端重新配置主节点参数脚本 
  69. # 当一个master由于failover而发生改变时，这个脚本将会被调用，通知相关的客户端关于master地址已
  70. 经发生改变的信息。 
  71. # 以下参数将会在调用脚本时传给脚本: 
  72. # <master-name> <role> <state> <from-ip> <from-port> <to-ip> <to-port> 
  73. # 目前<state>总是“failover”, 
  74. # <role>是“leader”或者“observer”中的一个。 
  75. # 参数 from-ip, from-port, to-ip, to-port是用来和旧的master和新的master(即旧的slave)通
  76. 信的 
  77. # 这个脚本应该是通用的，能被多次调用，不是针对性的。 
  78. # sentinel client-reconfig-script <master-name> <script-path> 
  79. sentinel client-reconfig-script mymaster /var/redis/reconfig.sh

六、Redis缓存穿透和雪崩

Redis缓存的使用，极大的提升了应用程序的性能和效率，特别是数据查询方面。但同时，它也带来了一些问题。其中，最要害的 问题，就是数据的一致性问题，从严格意义上讲，这个问题无解。如果对数据的一致性要求很高，那么就不能使用缓存。

另外的一些典型问题就是，缓存穿透、缓存雪崩和缓存击穿。目前，业界也都有比较流行的解决方案。

1、缓存穿透(查不到)

概念

缓存穿透的概念很简单，用户想要查询一个数据，发现redis内存数据库没有，也就是缓存没有命中，于是向持久层数据库查询。发 现也没有，于是本次查询失败。当用户很多的时候，缓存都没有命中(秒

杀)，于是都去请求了持久层数据库。这会给持久层数据库造成很 大的压力，这时候就相当于出现了缓存

解决方案

布隆过滤器

当存储层不命中后，即使返回的空对象也要将其缓存起来，同时设置一个过期时间，之后再访问这个数

据库将会从缓存中获取，保护了后端数据库

但是这种方法会存在两个问题:

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

2、缓存击穿(量太大)

概述

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

解决方案

设置热点数据永不过期从缓存层面来看，没有设置过期时间，所以不会出现热点key过期后产生的问题。加互斥锁

分布式锁：使用分布式锁,保证对于每个key同时只有一一个线程去查询后端服务,其他线程没有获得分布式锁的权限,因此只需要等待即可。这种方式将高并发的压力转移到了分布式锁,因此对分布式锁的考验很大。

3、缓存雪崩

概念

缓存雪崩，是指在某一个时间段，缓存集中过期失效。Redis宕机!

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

解决方案

redis高可用

这个思想的含义是,既然redis有可能挂掉,那我多增设几台redis ,这样-台挂掉之后其他的还可以继续工作,其实就是搭建的集 群。(异地多活!|)

限流降级

这个解决方案的思想是,在缓存失效后,通过加锁或者队列来控制读数据库写缓存的线程数量。比如对某个key只允许一个线程查 询数据和写缓存,其他线程等待。

数据预热.

数据加热的含义就是在正式部署之前,我先把可能的数据先预先访问一遍,这样部分可能大量访问的数据就会加载到缓存中。在即. 将发生大并发访问前手动触发加载缓存不同的key ,设置不同的过期时间,让缓存失效的时间点尽量均匀。

七、redis 在项目中的应用

1、redis缓存注解

  • @Cacheable：根据方法对其返回结果进行缓存，下次请求时，如果缓存存在，则直接读取缓存数据返回；如果缓存不存在，则执行方法，并把返回的结果存入缓存中，一般用在查询方法上。
  • value：缓存名，必填，它指定了你的缓存存放在哪块命名空间
  • cacheNames：与 value 差不多，二选一即可
  • key：可选属性，可以使用 SpEL 标签自定义缓存的key
  • @CachePut：使用该注解标志的方法，每次都会执行，并将结果存入指定的缓存中。其他方法可以直接从响应的缓存中读取缓存数据，而不需要再去查询数据库，一般用在新增方法上。
  • value：缓存名，必填，它指定了你的缓存存放在哪块命名空间
  • cacheNames：与 value 差不多，二选一即可
  • key：可选属性，可以使用 SpEL 标签自定义缓存的key
  • @CacheEvict：使用该注解标志的方法，会清空指定的缓存，一般用在更新或者删除方法上
  • value：缓存名，必填，它指定了你的缓存存放在哪块命名空间
  • cacheNames：与 value 差不多，二选一即可
  • key：可选属性，可以使用 SpEL 标签自定义缓存的key
  • allEntries：是否清空所有缓存，默认为 false。如果指定为 true，则方法调用后将立即清空所有的缓存
  • beforeInvocation：是否在方法执行前就清空，默认为 false。如果指定为 true，则在方法执行前就会清空缓存