Redis&Jedis

Redis

1. NoSQL简介

• 问题：海量用户，高并发
• 罪魁祸首：关系型数据库
  • 性能瓶颈：磁盘IO性能低下
  • 扩展瓶颈：数据关系复杂，扩展性差，不便于大规模集群
• 解决思路
  • 降低磁盘IO次数，越低越好---------内存存储
  • 去除数据间的关系，越简单越好—不存储关系，仅储存数据
• NoSQL(Not-Only SQL)：泛指非关系型的数据库
  • 作为关系型数据库的补充
  • 作用
    • 应对基于海量用户和海量数据前提下的数据处理问题
  • 特征
    • 可扩容，可伸缩
    • 大数据量下高性能
    • 灵活的数据模型
    • 高可用
  • 常见Nosql数据库
    • Redis
    • memcache
    • HBase
    • MongoDB
• 解决实例
  • 基础数据使用MySQL存储
  • 高频、波段性的数据存储在NoSQL中

注意

• 并不能说哪些数据存储在NoSQL中
• 是MySQL中的基础数据在某一时段达到高频段的时候将其存储在NoSQL中

2. Redis介绍

• 概念
  • Redis(REmote DIctioary Server)是用C语言开发的一个开源的高性能键值对(key-value)数据库，存储在内存中
  • key是字符串类型
  • value分5种（String、Hash、List、Set、Sorted_set）
• 特征
  • 数据间没有必然的关联关系
  • 内部采用单线程机制进行工作
  • 高性能。官方测试数据：50个并发执行100000个请求，读的速度是110000次/s，写的速度是81000次/s
  • 多数据类型支持
    • 字符串 类型--------------string
    • 列表类型 -----------------list
    • 散列类型------------------hash
    • 集合类型------------------set
    • 有序集合类型------------zset/sorted_set
  • 支持持久化，可以进行数据灾难恢复
• 应用场景
  • 为热点数据加速查询（主要场景）
  • 即时信息查询
  • 时效性信息控制
  • 分布式数据共享
  • 消息队列

3. 下载安装配置

3.1 下载安装

• 在Linux系统，基于Center OS7
• 下载安装包
  • wget http://download.redis.io/releases/redis-5.0.0.tar.gz
• 解压安装包
  • tar –xvf redis-5.0.0.tar.gz
• 编译（在解压的目录中执行）
  • make
• 安装（在解压的目录中执行）
  • make install
• 相关文件
  • redis-server，服务器启动命令 客户端启动命令
  • redis-cli，redis核心配置文件
  • redis.conf，RDB文件检查工具（快照持久化文件）
  • redis-check-dump，AOF文件修复工具
  • redis-check-aof

3.2 Redis服务器启动

• 启动服务器——参数启动
  • redis-server [--port port]
  • 范例：redis-server --port 6379
• 启动服务器——配置文件启动
  • redis-server config_file_name
  • 范例：redis-server redis.conf
• 启动客户端
  • redis-cli [-h host] [-p port]
  • 范 例：redis-cli –h 61.129.65.248 –p 6384

  注意

  • 服务器启动指定端口使用的是–port，客户端启动指定端口使用的是-p。-的数量不同。

• Redis基础环境设置约定
  • 创建配置文件存储目录
    • mkdir conf
  • 创建服务器文件存储目录（包含日志、数据、临时配置文件等）
    • mkdir data
  • 创建快速访问链接
    • ln -s redis-5.0.0 redis

3.3 配置文件启动与常用配置

• 服务器端设定
  • 设置服务器以守护进程的方式运行，开启后服务器控制台中将打印服务器运行信息（同日志内容相同）
    • daemonize yes|no
  • 绑定主机地址
    • bind ip
  • 设置服务器端口
    • port port
  • 设置服务器文件保存地址
    • dir path
• 客户端配置
  • 服务器允许客户端连接最大数量，默认0，表示无限制。当客户端连接到达上限后，Redis会拒绝新的连接
    • maxclients count
  • 客户端闲置等待最大时长，达到最大值后关闭对应连接。如需关闭该功能，设置为 0
    • timeout seconds
• 日志配置
  • 设置服务器以指定日志记录级别
    • loglevel debug|verbose|notice|warning
  • 日志记录文件名
    • logfile filename

  注意

  • 日志级别开发期设置为verbose即可，生产环境中配置为notice，简化日志输出量，降低写日志IO的频度。

4. Redis基本操作

4.1 信息读写

• 设置key，value数据
  • set key value
  • 示例：set name zhangsan
• 根据key查询对应的value，如果不存在，返回空(nil)
  • get key
  • 示例：get name

4.2 帮助信息

• 获取命令帮助文档
  • help [command]
  • 示例：help set
• 获取组中所有命令信息名称
  • help [@group-name]
  • 示例：help @string

4.3 退出

• 退出客户端
  • quit
  • exit
• 快捷键
  • Ctrl+c

5. 数据存储类型

5.1 介绍

• 业务数据的特殊性
  • 原始业务功能设计
  • 运营平台监控到的突发高频访问数据
  • 高频、复杂的统计数据
• 数据类型指的是存储的数据的类型，也就是value部分的类型，key部分永远都是字符串
• value部分的常用数据类型5种（string、hash、list、set、sorted_set/zset）

5.2 String

• 介绍
  • 存储的数据：单个数据，最简单的数据存储类型，也是最常用的数据存储类型
  • 存储数据的格式：一个存储空间保存一个数据
  • 存储内容：通常使用字符串，如果字符串以整数的形式展示，可以作为数字操作
• 基本操作
  • 添加/修改数据
    • set key value
  • 获取数据
    • get key
  • 删除数据
    • del key
  • 判定性添加数据
    • setnx key value
  • 添加/修改多个数据
    • mset key1 value1 key2 value2 ...
  • 获取多个数据
    • mget key1 key2 ...
  • 获取数据字符个数(字符串长度)
    • strlen key
  • 追加信息到原始信息后部（如果原始信息存在就追加，否则新建）
    • append key value
• 扩展操作
  • 设置数值数据增加指定范围的值
    • incr key
    • incrby key increment
    • incrbyfloat key increment
  • 设置数值数据减少指定范围的值
    • decr key
    • decrby key increment
  • 设置数据具有指定的声明周期
    • setex key seconds value
    • psetex key milliseconds value

  注意

  • 数据操作不成功的反馈与数据正常操作之间的差异
    • 表示运行结果是否成功：0->false/1->true
    • 表示运行结果值：3->3/1->1
  • 数据未获取到时，对应的数据为(nil)，等同于null
  • 数据最大存储量：512MB
  • string在redis内部存储默认就是一个字符串，当遇到增减类操作incr，decr时会转成数值型进行计算
  • 按数值进行操作的数据，如果原始数据不能转成数值，或超越了redis数值上限范围，将报错
  • redis所有的操作都是原子性的，采用单线程处理所有业务，命令是一个一个执行的，因此无需考虑并发带来的数据影响

• key 的设置约定：数据库中的热点数据key命名惯例

  	表名	主键名	主键值	字段名
  eg1：	order	id	29437595	name
  eg2：	equip	id	390472345	type
  eg3：	news	id	202004150	title

5.3 Hash

• 介绍
  • 新的存储需求：对一系列存储的数据进行编组，方便管理，典型应用存储对象信息
  • 需要的存储结构：一个存储空间保存多个键值对数据
  • hash类型：底层使用哈希表结构实现数据存储
  • hash存储结构优化
    • 如果field数量较少，存储结构优化为类数组结构
    • 如果field数量较多，存储结构使用HashMap结构
    • 我们将value部分保存的数据的键命名为field
• 基本操作
  • 添加/修改数据
    • hset key field value
  • 获取数据
    • hget key field
    • hgetall key
  • 删除数据
    • hdel key field1 [field2]
  • 设置field的值，如果该field存在则不做任何操作
    • hsetnx key field value
  • 添加/修改多个数据
    • hmset key field1 value1 field2 value2 ...
  • 获取多个数据
    • hmget key field1 field2 ...
  • 获取哈希表中字段的数量
    • hlen key
  • 获取哈希表中是否存在指定的字段
    • hexists key field
• 扩展操作
  • 获取哈希表中所有的字段名或字段值
    • hkeys key
    • hvals key
  • 设置指定字段的数值数据增加指定范围的值
    • hincrby key field increment
    • hincrbyfloat key field increment

  注意

  • hash类型中value只能存储字符串，不允许存储其他数据类型，不存在嵌套现象。如果数据未获取到，对应的值为(nil)
  • 每个hash可以存储2的32次方-1个键值对
  • hash类型十分贴近对象的数据存储形式，并且可以灵活添加删除对象属性，但hash设计初衷不是为了存储大量对象而设计的，切记不可滥用，更不可以将hash作为对象列表使用
  • hgetall操作可以获取全部属性，如果内部field过多，遍历整体数据效率就会过低，有可能成为数据访问瓶颈

5.4 List

• 介绍
  • 数据存储需求：存储多个数据，并对数据进入存储空间的顺序进行区分
  • 需要的数据结构：一个存储空间保存多个数据，且通过数据可以体现进入顺序
  • List类型：保存多个数据，底层使用双向链表存储结构实现
• 基本操作
  • 添加/修改数据
    • lpush key value1 [value2] ...
    • rpush key value1 [value2] ...
  • 获取数据
    • lrange key start stop
    • lindex key index
    • llen key
  • 获取并移除数据
    • lpop key
    • rpop key
• 扩展操作
  • 移除指定数据
    • lrem key count value
  • 规定时间内获取并移除数据
    • blpop key1 [key2] timeout
    • brpop key1 [key2] timeout
    • brpoplpush source destination timeout

  注意

  • list中保存的数据都是string类型的，数据总容量是有限的，最多2的32次方-1个元素（4294967295）
  • list具有索引的概念，但是操作数据时通常以队列的形式进行入队出队操作，或以栈的形式进行入栈出栈操作
  • 获取全部数据操作结束索引设置为-1
  • list可以对数据进行分页操作，通常第一页的信息来自于list，第二页及更多的信息通过数据库的形式加载

5.5 Set

• 介绍
  • 新的存储需求：存储大量的数据，在查询方面提供更高的效率
  • 需要新的存储结构：能够保存大量的数据，高效的内部存储机制，便于查询
  • set类型：与hash存储结构完全相同，仅存储键，不存储值(nil)，并且值是不允许重复的
• 基本操作
  • 添加数据
    • sadd key member1 [member2]
  • 获取全部数据
    • smembers key
  • 删除数据
    • srem key member1 [member2]
  • 获取集合数据总量
    • scard key
  • 判断集合中是否包含指定数据
    • sismember key member
  • 随机获取集合中指定数量的数据
    • srandmember key [count]
  • 随机获取集合中的某个数据并将该数据移出集合
    • spop key [count]
• 扩展操作
  • 求两个集合的交、并、差集
    • sinter key1 [key2 ...]
    • sunion key1 [key2 ...]
    • sdiff key1 [key2 ...]
  • 求两个集合的交、并、差集并存储到指定集合中
    • sinterstore destination key1 [key2 ...]
    • sunionstore destination key1 [key2 ...]
    • sdiffstore destination key1 [key2 ...]
  • 将指定数据从原始集合中移动到目标集合中
    • smove source destination member

  注意

  • set类型不允许数据重复，如果添加的数据在set中已经存在，将只保留一份
  • set虽然与hash的存储结构相同，但是无法启用hash中存储值的空间

6. key常用指令

• 基本操作
  • 删除指定key
    • del key
  • 获取key是否存在
    • exists key
  • 获取key的类型
    • type key
• 扩展操作
  • 排序
    • sort
  • 改名
    • rename key newkey
    • renamenx key newkey
  • 为指定key设置有效期
    • expire key seconds
    • pexpire key milliseconds
    • expireat key timestamp
    • pexpireat key milliseconds-timestamp
  • 获取key的有效时间
    • ttl key
    • pttl key
  • 切换key从时效性转换为永久性
    • persist key
  • 查询key
    • keys pattern
  • 查询模式规则
    • * 匹配任意数量的任意符号
    • ？ 配合一个任意符号
    • [] 匹配一个指定符号

      指令	说明
      keys *	查询所有
      keys it*	查询所有以it开头
      keys *heima	查询所有以heima结尾
      keys ??heima	查询所有前面两个任意字符，后面以heima结尾
      keys user:?	查询所有以user:开头，最后一个字符任意
      keys u [st] er:l	查询所有以u开头，以er:l结尾，中间有一个s或t字母

7. 数据库常用指令

• 介绍
  • redis为每个服务提供有16个数据库，编号从0到15
  • 每个数据库之间的数据相互独立
• db基本操作
  • 切换数据库
    • select index
  • 其他操作
    • ping
• db扩展操作
  • 数据移动
    • move key db
  • 数据总量
    • dbsize
  • 数据清除
    • flushdb
    • flushall

8.Jedis

8.1 Jedis简单使用

• 介绍
  • Jedis用于Java语言连接redis服务，并提供对应的操作API
• 使用步骤
  • 下载jar包
    • https://mvnrepository.com/artifact/redis.clients/jedis
  • 导入jar包
    • jedis-3.1.0.jar
  • 基于maven

    <dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.1.0</version>
    </dependency>
    

• 客户端连接redis
  • 连接redis
    • Jedis jedis = new Jedis("localhost", 6379);
  • 操作redis
    • jedis.set("name", "itheima"); jedis.get("name");
  • 关闭redis连接
    • jedis.close();
• API文档
  • http://xetorthio.github.io/jedis/
• 代码

  public class JedisTest {
  
      public static void main(String[] args) {
          //1.获取连接对象
          Jedis jedis = new Jedis("192.168.40.130",6379);
          //2.执行操作
          jedis.set("age","39");
          String hello = jedis.get("hello");
          System.out.println(hello);
          jedis.lpush("list1","a","b","c","d");
          List<String> list1 = jedis.lrange("list1", 0, -1);
          for (String s:list1 ) {
              System.out.println(s);
          }
          jedis.sadd("set1","abc","abc","def","poi","cba");
          Long len = jedis.scard("set1");
          System.out.println(len);
          //3.关闭连接
          jedis.close();
      }
  }
  

8.2 Jedis简易工具类开发

• 基于连接池获取连接
  • JedisPool：Jedis提供的连接池技术
  • poolConfig:连接池配置对象
  • host:redis服务地址
  • port:redis服务端口号
• JedisPool的构造器如下

  public JedisPool(GenericObjectPoolConfig poolConfig, String host, int port) {
  this(poolConfig, host, port, 2000, (String)null, 0, (String)null);
  }
  

• 封装连接参数
  • 创建jedis的配置文件：jedis.properties

  jedis.host=192.168.40.130  
  jedis.port=6379  
  jedis.maxTotal=50  
  jedis.maxIdle=10
  

• 加载配置信息
  • 创建JedisUtils：com.itheima.util.JedisUtils，使用静态代码块初始化资源

  public class JedisUtils {
      private static int maxTotal;
      private static int maxIdel;
      private static String host;
      private static int port;
      private static JedisPoolConfig jpc;
      private static JedisPool jp;
  
      static {
          ResourceBundle bundle = ResourceBundle.getBundle("redis");
          maxTotal = Integer.parseInt(bundle.getString("redis.maxTotal"));
          maxIdel = Integer.parseInt(bundle.getString("redis.maxIdel"));
          host = bundle.getString("redis.host");
          port = Integer.parseInt(bundle.getString("redis.port"));
          //Jedis连接池配置
          jpc = new JedisPoolConfig();
          jpc.setMaxTotal(maxTotal);
          jpc.setMaxIdle(maxIdel);
          jp = new JedisPool(jpc,host,port);
      }
  
  }
  

• 获取连接
  • 对外访问接口，提供jedis连接对象，连接从连接池获取，在JedisUtils中添加一个获取jedis的方法：getJedis

  public static Jedis getJedis(){
  	Jedis jedis = jedisPool.getResource();
  	return jedis;
  }
  

9. 持久化

9.1 简介

• 自动备份
  • 通过自动的形式将你的数据保存起来，我们的数据可以由内存到硬盘上实现保存
• 持久化
  • 利用永久性存储介质将数据进行保存，在特定的时间将保存的数据进行恢复的工作机制称为持久化 。
  • 持久化用于防止数据的意外丢失，确保数据安全性
• 持久化过程保存什么
  • RDB：将当前数据状态进行保存，保存数据结果，格式简单（快照）
  • AOF：保存操作过程，存储格式复杂（日志）

9.2 RDB

• save指令
  • 手动执行一次保存操作
  • save
• save指令相关配置
  • 设置本地数据库文件名，默认值为 dump.rdb，通常设置为dump-端口号.rdb
    • dbfilename filename
  • 设置存储.rdb文件的路径，通常设置成存储空间较大的目录中，目录名称data
    • dir path
  • 设置存储至本地数据库时是否压缩数据，默认yes，设置为no，节省 CPU 运行时间，但存储文件变大
    • rdbcompression yes|no
  • 设置读写文件过程是否进行RDB格式校验，默认yes，设置为no，节约读写10%时间消耗，单存在数据损坏的风险
    • rdbchecksum yes|no
      

  注意

  • save指令的执行会阻塞当前Redis服务器，直到当前RDB过程完成为止，有可能会造成长时间阻塞，线上环境不建议使用

• bgsave指令
  • bg其实是background的意思，后台执行的意思，手动启动后台保存操作，但不是立即执行
  • bgsave
• bgsave指令相关配置
  • 后台存储过程中如果出现错误现象，是否停止保存操作，默认yes
    • stop-writes-on-bgsave-error yes|no
  • 其 他
    • dbfilename filename
    • dir path
    • rdbcompression yes|no
    • rdbchecksum yes|no
      

  注意

  • bgsave命令是针对save阻塞问题做的优化，Redis内部所有涉及到RDB操作的都采用bgsave的方式，save命令可以放弃使用

• save配置自动执行
  • 设置自动持久化的条件，满足限定时间范围内key的变化数量达到指定数量即进行持久化
  • save second changes
  • 参数
    • second：监控时间范围
    • changes：监控key的变化量
  • 范例

    save 900 1
    save 300 10
    save 60 10000
    

  • 其他相关配置

    dbfilename filename
    dir path
    rdbcompression yes|no
    rdbchecksum yes|no
    stop-writes-on-bgsave-error yes|no
    

注意

• save配置要根据实际业务情况进行设置，频度过高或过低都会出现性能问题，结果可能是灾难性的
• save配置启动后执行的是bgsave操作

• RDB三种启动方式对比

  方式	save指令	bgsave指令
  读写	同步	同步
  阻塞客户端指令	是	否
  额外内存消耗	否	是
  启动新进程	否	是

• RDB特殊启动形式
  • 服务器运行过程中重启
    • debug reload
  • 关闭服务器时指定保存数据
    • shutdown save
• RDB优点
  • RDB是一个紧凑压缩的二进制文件，存储效率较高
  • RDB内部存储的是redis在某个时间点的数据快照，非常适合用于数据备份，全量复制等场景
  • RDB恢复数据的速度要比AOF快很多
  • 应用：服务器中每X小时执行bgsave备份，并将RDB文件拷贝到远程机器中，用于灾难恢复。
• RDB缺点
  • RDB方式无论是执行指令还是利用配置，无法做到实时持久化，具有较大的可能性丢失数据
  • bgsave指令每次运行要执行fork操作创建子进程，要牺牲掉一些性能
  • Redis的众多版本中未进行RDB文件格式的版本统一，有可能出现各版本服务之间数据格式无法兼容现象

9.3 AOF

• 概念
  • AOF(append only file)持久化：以独立日志的方式记录每次写命令，重启时再重新执行AOF文件中命令 达到恢复数据的目的。与RDB相比可以简单理解为由记录数据改为记录数据产生的变化
  • AOF的主要作用是解决了数据持久化的实时性，目前已经是Redis持久化的主流方式
    
• 启动AOF相关配置
  • 开启AOF持久化功能，默认no，即不开启状态
    • appendonly yes|no
  • AOF持久化文件名，默认文件名为appendonly.aof，建议配置为appendonly-端口号.aof
    • appendfilename filename
  • AOF持久化文件保存路径，与RDB持久化文件保持一致即可
    • dir
  • AOF写数据策略，默认为everysec
    • appendfsync always|everysec|no
• AOF执行策略
  • AOF写数据三种策略(appendfsync)
    • always(每次）：每次写入操作均同步到AOF文件中数据零误差，性能较低，不建议使用。
    • everysec（每秒）：每秒将缓冲区中的指令同步到AOF文件中，在系统突然宕机的情况下丢失1秒内的数据 数据准确性较高，性能较高，建议使用，也是默认配置
    • no（系统控制）：由操作系统控制每次同步到AOF文件的周期，整体过程不可控
• AOF重写
  • 场景：AOF写数据遇到的问题，如果连续执行如下指令该如何处理
  • AOF文件重 写是将Redis进程内的数据转化为写命令同步到新AOF文件的过程。简单说就是将对同一个数据的若干个条命令执行结 果转化成最终结果数据对应的指令进行记录。
  • AOF重写作用
    • 降低磁盘占用量，提高磁盘利用率
    • 提高持久化效率，降低持久化写时间，提高IO性能
    • 降低数据恢复用时，提高数据恢复效率
  • AOF重写规则
    • 进程内具有时效性的数据，并且数据已超时将不再写入文件
    • 非写入类的无效指令将被忽略，只保留最终数据的写入命令
    • 对同一数据的多条写命令合并为一条命令
  • 为防止数据量过大造成客户端缓冲区溢出，对list、set、hash、zset等类型，每条指令最多写入64个元素
• AOF重写方式
  • 手动重写
    • bgrewriteaof
      
  • 自动重写
    • auto-aof-rewrite-min-size size
    • auto-aof-rewrite-percentage percentage
  • 自动重写触发条件设置
    • auto-aof-rewrite-min-size size
    • auto-aof-rewrite-percentage percent
  • 自动重写触发比对参数（ 运行指令info Persistence获取具体信息 ）
    • aof_current_size
    • aof_base_size
  • 自动重写触发条件公式：
    

9.4 RDB与AOF对比

• RDB与AOF对比（优缺点）

  持久化方式	RDB	AOF
  占用存储空间	小（数据级：压缩）	大（指令级：重写）
  存储速度	慢	快
  恢复速度	快	慢
  数据安全性	会丢失数据	依据策略决定
  资源消耗	高/重量级	低/轻量级
  启动优先级	低	高

• RDB与AOF应用场景
  • 对数据非常敏感，建议使用默认的AOF持久化方案
    • AOF持久化策略使用everysecond，每秒钟fsync一次。该策略redis仍可以保持很好的处理性能，当出 现问题时，最多丢失0-1秒内的数据。
    • 注意：由于AOF文件存储体积较大，且恢复速度较慢
  • 数据呈现阶段有效性，建议使用RDB持久化方案
    • 数据可以良好的做到阶段内无丢失（该阶段是开发者或运维人员手工维护的），且恢复速度较快，阶段 点数据恢复通常采用RDB方案
    • 注意：利用RDB实现紧凑的数据持久化会使Redis降的很低，慎重总结：
• 综合比对
  • RDB与AOF的选择实际上是在做一种权衡，每种都有利有弊
  • 如不能承受数分钟以内的数据丢失，对业务数据非常敏感，选用AOF
  • 如能承受数分钟以内的数据丢失，且追求大数据集的恢复速度，选用RDB
  • 灾难恢复选用RDB
  • 双保险策略，同时开启 RDB和 AOF，重启后，Redis优先使用 AOF 来恢复数据，降低丢失数据的量

10. 删除策略

10.1 过期数据

• Redis是一种内存级数据库，所有数据均存放在内存中，内存中的数据可以通过TTL指令获取其状态，TTL返回的值有三种情况：正数，-1，-2
  • 正数：代表该数据在内存中还能存活的时间
  • -1：永久有效的数据
  • -2：已经国企的数据或被删除的数据或未定义的数据
• 删除策略就是针对已经过期的数据的处理策略，已过期的数据是真的就立即删除了嘛？其实不是，我们会有多种删除策略，是分情况的，在不同的场景下使用不同的删除方式会有不同的效果，这也正是我们说的数据删除策略的问题

10.2 过期数据存储结构

• 在Redis中，如何给数据设置它的失效周期呢？数据的失效在redis中如何存储，如下图
  
• 过期数据是一块独立的存储空间，Hash结构，field是内存地址，value是过期时间，保存了所有key的过期描述，在最终进行过期处理的时候，对该空间的数据进行检测，当时间到期之后通过field找到内存该地址处的数据，然后进行相关操作

10.3 数据删除策略

10.3.1 三种策略

• 在内存占用与CPU占用之间寻找一种平衡，顾此失彼都会造成整体redis性能的下降，甚至引发服务器宕机或 内存泄露，针对过期数据要进行删除的时候都有哪些删除策略呢？
  • 定时删除
  • 惰性删除
  • 定期删除

10.3.2 定时删除

• 创建一个定时器，当key设置有过期时间，且过期时间到达时，由定时器任务立即执行对键的删除操作
• 优点
  • 节约内存，到时就删除，快速释放掉不必要的内存占用
• 缺点
  • CPU压力很大，无论CPU此时负载量多高，均占用CPU，会影响redis服务器响应时间和指令吞吐量
• 总结
  • 用处理器性能换取存储空间（拿时间换空间）
    

10.3.3 惰性删除

• 数据到达过期时间，不做处理，等下次访问该数据时，我们需要判断
  • 如果未过期，返回数据
  • 发现已过期，删除，返回不存在
• 优点
  • 节约CPU性能，发现必须删除的时候才能删除
• 缺点
  • 内存压力很大，出现长期占用内存的数据
• 总结
  • 用存储空间换取处理器性能（拿空间换时间）
    

10.3.4 定期删除

• 定时删除和惰性删除两种方案都相对极端，说说redis的定期删除方案
  • Redis启动服务器初始化时，读取配置server.hz的值，默认为10
  • 每秒钟执行server.hz次serverCron()-------->databasesCron()--------->activeExpireCycle()
  • activeExpireCycle()对每个expires[*]逐一进行检测，每次执行耗时：250ms/server.hz
  • 对某个expires[*]检测时，随机挑选W个key检测
  • 参数current_db用于记录activeExpireCycle()进入哪个expires[*] 执行
  • 如果activeExpireCycle()执行时间到期，下次从current_db继续向下执行

  如果key超时，删除key
  如果一轮中删除的key的数量>W25%，循环该过程
  如果一轮中删除的key的数量≤W25%，检查下一个expires[*]，0-15循环
  W取值=ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP属性值

• 总结
  • 定期删除就是周期性轮询redis库中的时效性数据，采用随机抽取的策略，利用过期数据占比的方式控制删除频度
  • 特点1：CPU性能占用设置有峰值，检测频度可自定义设置
  • 特点2：内存压力不是很大，长期占用内存的冷数据会被持续处理
  • 周期性抽查存储空间（随机抽查，重点抽查）

10.3.5 删除策略对比

• 定时删除
  • 节约内存，无占用
  • 不分时段占用CPU资源，频度高
  • 拿时间换空间
• 惰性删除
  • 内存占用严重
  • 延时执行，CPU利用率高
  • 拿空间换时间
• 定期删除
  • 内存定期随机清理
  • 每秒花费固定的CPU资源维护内存
  • 随机抽查，重点抽查

10.4 淘汰策略

10.4.1 介绍

• 当新数据进入redis时，如果内存不足怎么办？在执行每一个命令前，会调用freeMemoryIfNeeded()检测内存是否充足。如果内存不满足新加入数据的最低存储要求，redis要临时删除一些数据为当前指令清理存储空间。清理数据的策略称为逐出算法。
• 注意
  • 逐出数据的过程不是100%能够清理出足够的可使用的内存空间，如果不成功则反复执行。当对所有数据尝试完毕，如不能达到内存清理的要求，将出现错误信息如下
  • (error) OOM command not allowed when used memory >'maxmemory'

10.4.2 策略配置

• 影响数据淘汰的相关配置如下
  • 1 最大可使用内存，即占用物理内存的比例，默认值为0，表示不限制，生产环境中根据需求设定，通常设置在50%以上

    maxmemory ?mb
    

  • 2 每次选取待删除数据的个数，采用随机获取数据的方式作为待检测删除数据

    maxmemory-samples count
    

  • 3 对数据进行删除的选择策略

    maxmemory-policy policy
    

• 那数据删除的策略policy到底有几种？一共3类8种
  • 第一类：检测易失数据（可能会过期的数据集server.db[i].expires）

    volatile-lru：挑选最近最少使用的数据淘汰
    volatile-lfu：挑选最近使用次数最少的数据淘汰
    volatile-ttl：挑选将要过期的数据淘汰
    volatile-random：任意选择数据淘汰
    

  • 第二类：检测全库数据（所有数据集server.db[i].dict）

    allkeys-lru：挑选最近最少使用的数据淘汰
    allkeLyRs-lfu：：挑选最近使用次数最少的数据淘汰
    allkeys-random：任意选择数据淘汰，相当于随机
    

  • 第三类：放弃数据驱逐

    no-enviction（驱逐）：禁止驱逐数据(redis4.0中默认策略)，会引发OOM(Out Of Memory)
    

  • 注意：这些策略是配置到哪个属性上？怎么配置？如下

    maxmemory-policy volatile-lru
    

• 数据淘汰策略配置依据
  • 使用INFO命令输出监控信息，查询缓存hit和miss的次数，根据业务需求调优Redis配置

11. 主从复制

11.1 简介

11.1.1 高可用

• 因为互联网应用独有的特性我们演化出了三高架构
  • 高并发
    • 应用要提供某一业务要能支持很多客户端同时访问的能力，我们称为并发，高并发的意思就很明确了
  • 高性能
    • 性能带给我们最直观的感受就是：速度快，时间短
  • 高可用
    • 可用性：一年中应用服务正常运行的时间占全年时间的百分比
    • 把一年中服务器不可用的时间加在一起，用一年时间减去，得到应用服务全年可用的时间，计算全年可用的时间占全年时间的百分比
    • 业界可用性目标为5个9，即99.999%，即服务器年宕机时长低于315秒，约5.25分钟

11.1.2 主从复制概念

• 单机redis的风险与问题
  • 问题1：机器故障
    • 现象：硬盘故障，系统崩溃
    • 本质：数据丢失，很可能对业务造成灾难性打击
    • 结论：基本上会放弃使用redis
  • 问题2：容量瓶颈
    • 现象：内存不足，从16G升级到64G，从64G到128G，无限升级内存
    • 本质：穷，硬件条件跟不上
    • 结论：放弃使用redis
  • 结论
    • 为了避免单点Redis服务器故障，准备多台服务器，互相连通。将数据复制多个副本保存在不同的服务器上，连接在一起，并保证数据是同步的。即使有其中一台服务器宕机，其他服务器依然可以继续提供服务，实现Redis的高可用，同时实现数据冗余备份。
• 多台服务器连接方案
  
  • 提供数据方：master
    • 主服务器，主节点，主库主客户端
  • 接收数据方：slave
    • 从服务器，从节点，从库从客户端
  • 需要解决的问题
    • 数据同步（master数据复制到slave中）
• 主从复制
  • 概念：主从复制即将master中的数据即时、有效的复制到slave中
  • 特征：一个master可以拥有多个slave，一个slave只能对应一个master
  • 职责：master和slave各自的职责不一样
• master
  • 写数据
  • 执行写操作时，将出现变化的数据自动同步到slave
  • 读数据（可忽略）
• slave
  • 读数据
  • 写数据（禁止）

11.1.3 主从复制的作用

• 读写分离：master写、slave读，提高服务器的读写负载能力
• 负载均衡：基于主从结构，配合读写分离，由slave分担master负载，并根据需求的变化，改变slave的数 量，通过多个从节点分担数据读取负载，大大提高Redis服务器并发量与数据吞吐量
• 故障恢复：当master出现问题时，由slave提供服务，实现快速的故障恢复
• 数据冗余：实现数据热备份，是持久化之外的一种数据冗余方式
• 高可用基石：基于主从复制，构建哨兵模式与集群，实现Redis的高可用方案

11.2 主从复制工作流程

11.2.1 介绍

• 主从复制过程大体可以分为三个阶段
  • 建立连接阶段（即准备阶段）
  • 数据同步阶段
  • 命令传播阶段（反复同步）
    
• 命令的传播有四种
  

11.2.2 建立连接

• 建立slave到master的连接，使master能够识别slave，并保存slave端口号
• 流程
  • 1 设置master的地址和端口，保存master信息
  • 2 建立socket连接
  • 3 发送ping命令（定时器任务）
  • 4 身份验证
  • 5 发送slave端口信息
  • 主从连接成功
• 当前状态
  • slave：保存master的地址与端口
  • master：保存slave的端口
  • 二者之间创建了连接的socket
    
• master和slave互联
  • 方式一：客户端发送命令
    • slaveof masterip masterport
  • 方式二：启动服务器参数
    • redis-server --slaveof masterip masterport
  • 方式三：服务器配置（主流方式）
    • slaveof masterip masterport
  • slave系统信息
    • master_link_down_since_seconds
masterhost & masterport
  • master系统信息
    • uslave_listening_port(多个)
• 主从断开连接
  • 断开slave与master的连接，slave断开连接后，不会删除已有数据，只是不再接收master发送的数据
    • slaveof no one
• 授权访问
  • master客户端发送命令设置密码
    • requirepass password
  • master配置文件设置密码
    • config set requirepass password
config get requirepass
  • slave客户端发送命令设置密码
    • auth password
  • slave配置文件设置密码
    • masterauth password
  • slave启动服务器设置密码
    • redis-server –a password

11.2.3 数据同步

• 在slave初次连接master后，复制master中的所有数据到slave
• 将slave的数据库状态更新成master当前的数据库状态
• 同步过程
  • 1 请求同步数据
  • 2 创建RDB同步数据
  • 3 恢复RDB同步数据
  • 4 请求部分同步数据
  • 5 恢复部分同步数据
  • 数据同步工作完成
• 当前状态
  • slave：具有master端全部数据，包含RDB过程接收的数据
  • master：保存slave当前数据同步的位置
  • 二者之间完成了数据克隆
    
• 数据同步阶段master说明
  • 如果master数据量巨大，数据同步阶段应避开流量高峰期，避免造成master阻塞，影响业务正常执行
  • 复制缓冲区大小设定不合理，会导致数据溢出。如进行全量复制周期太长，进行部分复制时发现数据已经存在丢失的情况，必须进行第二次全量复制，致使slave陷入死循环状态
    • repl-backlog-size ?mb
  • master单级内存占用主机内存的比例不应过大，建议使用50%-70%的内存，留下30%-50%的内存用于执行bgsave命令和创建复制缓冲区
• 数据同步阶段slave说明
  • 为避免slave进行全量复制、部分复制时服务器响应阻塞或数据不同步，建议关闭此期间的对外服务
    • slave-serve-stale-data yes|no
  • 数据同步阶段，master发送给slave信息可以理解master是slave的一个客户端，主动向slave发送命令
  • 多个slave同时对master请求数据同步，master发送的RDB文件增多，会对带宽造成巨大冲击，如果master带宽不足，因此数据同步需要根据业务需求，适量错峰
  • slave过多时，建议调整拓扑结构，由一主多从结构变为树状结构，中间的节点既是master，也是 slave。注意使用树状结构时，由于层级深度，导致深度越高的slave与最顶层master间数据同步延迟 较大，数据一致性变差，应谨慎选择

11.2.4 命令传播

• 当master数据库状态被修改后，导致主从服务器数据库状态不一致，此时需要让主从数据同步到一致的状态，同步的动作称为命令传播
• master将接收到的数据变更命令发送给slave，slave接收命令后执行命令
• 命令传播阶段的部分复制
  • 命令传播阶段出现了断网现象：
  • 网络闪断闪连：忽略
  • 短时间网络中断：部分复制
  • 长时间网络中断：全量复制
• 这里我们主要来看部分复制，部分复制的三个核心要素
  • 服务器的运行 id（run id）
  • 主服务器的复制积压缓冲区
  • 主从服务器的复制偏移量
• 服务器运行ID（runid）
  • 概念：服务器运行ID是每一台服务器每次运行的身份识别码，一台服务器多次运行可以生成多个运行id
  • 组成：运行id由40位字符组成，是一个随机的十六进制字符
    例如：fdc9ff13b9bbaab28db42b3d50f852bb5e3fcdce
  • 作用：运行id被用于在服务器间进行传输，识别身份。如果想两次操作均对同一台服务器进行，必须每次操作携带对应的运行id，用于对方识别
  • 实现方式：运行id在每台服务器启动时自动生成的，master在首次连接slave时，会将自己的运行ID发送给slave，slave保存此ID，通过info Server命令，可以查看节点的runid

11.3 复制缓冲区工作原理

• 概念：
  • 复制缓冲区，又名复制积压缓冲区，是一个先进先出（FIFO）的队列，用于存储服务器执行过的命令，每次传播命令，master都会将传播的命令记录下来，并存储在复制缓冲区
  • 复制缓冲区默认数据存储空间大小是1M
  • 当入队元素的数量大于队列长度时，最先入队的元素会被弹出，而新元素会被放入队列
• 作用：
  • 用于保存master收到的所有指令（仅影响数据变更的指令，例如set，select）
• 数据来源：
  • 当master接收到主客户端的指令时，除了将指令执行，会将该指令存储到缓冲区中
    
• 复制缓冲区组成
  • 偏移量
    • 概念：一个数字，描述复制缓冲区中的指令字节位置
    • 分类：
      • master复制偏移量：记录发送给所有slave的指令字节对应的位置（多个）
      • slave复制偏移量：记录slave接收master发送过来的指令字节对应的位置（一个）
    • 作用：同步信息，比对master与slave的差异，当slave断线后，恢复数据使用
    • 数据来源：
      • master端：发送一次记录一次
      • slave端：接收一次记录一次
  • 字节值
• 工作原理
  • 通过offset区分不同的slave当前数据传播的差异
  • master记录已发送的信息对应的offset
  • slave记录已接收的信息对应的offset
    

11.4 工作流程更新（全量复制/部分复制）

11.5 心跳机制

• 心跳机制
  • 进入命令传播阶段后，master与slave间需要进行信息交换，使用心跳机制进行维护，实现双方连接保持在线
• master心跳
  • 内部指令：PING
  • 周期：由repl-ping-slave-period决定，默认10秒
  • 作用：判断slave是否在线
  • 查询：INFO replication 获取slave最后一次连接时间间隔，lag项维持在0或1视为正常
• slave心跳任务
  • 内部指令：REPLCONF ACK {offset}
  • 周期：1秒
  • 作用1：汇报slave自己的复制偏移量，获取最新的数据变更指令
  • 作用2：判断master是否在线
• 心跳阶段注意事项
  • 当slave多数掉线，或延迟过高，master为保障数据稳定性，将拒绝所有信息同步
    • min-slaves-to-write 2
min-slaves-max-lag 8
  • slave数量少于2个，或者所有slave的延迟都大于等于8秒时，强制关闭master写功能，停止数据同步
    • slave数量由slave发送REPLCONF ACK命令做确认
    • slave延迟由slave发送REPLCONF ACK命令做确认
• 至此：我们可以总结出完整的主从复制流程
  

11.6 常见问题

11.6.1 频繁的全量复制

• 伴随着系统的运行，master的数据量会越来越大，一旦master重启，runid将发生变化，会导致全部slave的全量复制操作
• 内部优化调整方案
  • 1 master内部创建master_replid变量，使用runid相同的策略生成，长度41位，并发送给所有slave
  • 2 在master关闭时执行命令shutdown save，进行RDB持久化,将runid与offset保存到RDB文件中
    • repl-id repl-offset
通过redis-check-rdb命令可以查看该信息
  • 3 master重启后加载RDB文件，恢复数据，重启后，将RDB文件中保存的repl-id与repl-offset加载到内存中
    • master_repl_id=repl master_repl_offset =repl-offset
通过info命令可以查看该信息
  • 作用：本机保存上次runid，重启后恢复该值，使所有slave认为还是之前的master
• 第二种出现频繁全量复制的问题现象：网络环境不佳，出现网络中断，slave不提供服务
• 问题原因：复制缓冲区过小，断网后slave的offset越界，触发全量复制
• 最终结果：slave反复进行全量复制
• 解决方案：修改复制缓冲区大小
  • repl-backlog-size ?mb
• 建议设置如下
  • 1.测算从master到slave的重连平均时长second
  • 2.获取master平均每秒产生写命令数据总量write_size_per_second
  • 3.最优复制缓冲区空间 = 2 * second * write_size_per_second

11.6.2 频繁的网络中断

• 问题现象
  • master的CPU占用过高 或 slave频繁断开连接
• 问题原因
  • slave每1秒发送REPLCONFACK命令到master
  • 当slave接到了慢查询时（keys * ，hgetall等），会大量占用CPU性能
  • master每1秒调用复制定时函数replicationCron()，比对slave发现长时间没有进行响应
• 最终结果
  • master各种资源（输出缓冲区、带宽、连接等）被严重占用
• 解决方案
  • 通过设置合理的超时时间，确认是否释放slave
    • repl-timeout seconds
  • 该参数定义了超时时间的阈值（默认60秒），超过该值，释放slave
• 问题现象
  • slave与master连接断开
• 问题原因
  • master发送ping指令频度较低
  • master设定超时时间较短
  • ping指令在网络中存在丢包
• 解决方案
  • 提高ping指令发送的频度
    • repl-ping-slave-period seconds
  • 超时时间repl-time的时间至少是ping指令频度的5到10倍，否则slave很容易判定超时

11.6.3 数据不一致

• 问题现象
  • 多个slave获取相同数据不同步
• 问题原因
  • 网络信息不同步，数据发送有延迟
• 解决方案
  • 优化主从间的网络环境，通常放置在同一个机房部署，如使用阿里云等云服务器时要注意此现象
  • 监控主从节点延迟（通过offset）判断，如果slave延迟过大，暂时屏蔽程序对该slave的数据访问
    • slave-serve-stale-data yes|no
  • 开启后仅响应info、slaveof等少数命令（慎用，除非对数据一致性要求很高）

12. 哨兵模式

12.1 哨兵简介

• 首先我们来看一个业务场景：如果redis的master宕机了，此时应该怎么办？
  
• 那此时我们可能需要从一堆的slave中重新选举出一个新的master，那这个操作过程是什么样的呢？这里面会有什么问题出现呢？
  
• 要实现这些功能，我们就需要redis的哨兵，那哨兵是什么呢？
• 哨兵
  • 哨兵(sentinel) 是一个分布式系统，用于对主从结构中的每台服务器进行监控，当出现故障时通过投票机制选择新的master并将所有slave连接到新的master。

12.2 哨兵作用

• 监控：
  • 监控master和slave
  • 不断的检查master和slave是否正常运行
  • master存活检测、master与slave运行情况检测
• 通知（提醒）：
  • 当被监控的服务器出现问题时，向其他（哨兵间，客户端）发送通知
• 自动故障转移：
  • 断开master与slave连接，选取一个slave作为master，将其他slave连接新的master，并告知客户端新的服务器地址
• 注意
  • 哨兵也是一台redis服务器，只是不提供数据相关服务，通常哨兵的数量配置为单数

12.3 哨兵启动

• 配置哨兵
  • 配置一拖二的主从结构（利用之前的方式启动即可）
  • 配置三个哨兵（配置相同，端口不同），参看sentinel.conf
• 设置哨兵监听的主服务器信息， sentinel_number表示参与投票的哨兵数量
  • sentinel monitor master_name master_host master_port sentinel_number
• 设置判定服务器宕机时长，该设置控制是否进行主从切换
  • sentinel down-after-milliseconds master_name million_seconds
• 设置故障切换的最大超时时
  • sentinel failover-timeout master_name million_seconds
• 设置主从切换后，同时进行数据同步的slave数量，数值越大，要求网络资源越高，数值越小，同步时间越长
  • sentinel parallel-syncs master_name sync_slave_number
• 启动哨兵
  • redis-sentinel filename

12.4 主从切换过程演示

12.4.1 监控阶段

• 用于同步各个节点的状态信息
• 获取各个sentinel的状态（是否在线）
• 获取master的状态

  master属性
  	prunid
  	prole：master
  各个slave的详细信息
  

• 获取所有slave的状态（根据master中的slave信息）

  slave属性
  	prunid
  	prole：slave
  	pmaster_host、master_port
  	poffset
  

• 其内部的工作原理如下
  

12.4.2 通知阶段

• sentinel在通知阶段要不断的去获取master/slave的信息，然后在各个sentinel之间进行共享，具体的流程如下
  

12.4.3 故障转移阶段

• 当master宕机后sentinel是如何知晓并判断出master是真的宕机了呢？我们来看具体的操作流程
  
• 当sentinel认定master下线之后，此时需要决定更换master，那这件事由哪个sentinel来做呢？这时候sentinel之间要进行选举，如下图所示：
  
• 由选举胜出的sentinel去从slave中选一个新的master出来
  • 首先它有一个在服务器列表中挑选备选master的原则
    • 不在线的OUT
    • 响应慢的OUT
    • 与原master断开时间久的OUT
    • 优先原则（优先级 offset runid）
  • 选出新的master之后，发送指令（ sentinel ）给其他的slave：
    • 向新的master发送slaveof no one
    • 向其他slave发送slaveof 新masterIP端口

13. 集群（cluster）

13.1 简介

• 集群
  • 使用网络将若干台计算机联通起来，并提供统一的管理方式，使其对外呈现单级的服务效果
• 集群作用
  • 分散单台服务器的访问压力，实现负载均衡
  • 分散单台服务器的存储压力，实现可扩展性
  • 降低单台服务器宕机带来的业务灾难

13.2 Cluster集群结构设计

• 数据存储设计
  • 通过算法设计，计算出key应该保存的位置
  • 将所有的存储空间计划切割成16384份，每台主机保存一部分
    • 注意：每份代表的是一个存储空间，不是一个key的保存空间
  • 将key按照计算出的结果放到对应的存储空间
• 那redis的集群是如何增强可扩展性的呢？譬如我们要增加一个集群节点
  
• 当我们查找数据时，集群是如何操作的呢？
  • 各个数据库相互通信，保存各个库中槽的编号数据
  • 一次命中，直接返回
  • 一次未命中，告知具体位置
    

13.3 Cluster集群结构搭建

• 首先要明确的几个要点：
  • 配置服务器（3主3从）
  • 建立通信（Meet）
  • 分槽（Slot）
  • 搭建主从（master-slave）
• Cluster配置
  • 是否启用cluster，加入cluster节点
    • cluster-enabled yes|no
  • cluster配置文件名，该文件属于自动生成，仅用于快速查找文件并查询文件内容
    • cluster-config-file filename
  • 节点服务响应超时时间，用于判定该节点是否下线或切换为从节点
    • cluster-node-timeout milliseconds
  • master连接的slave最小数量
    • cluster-migration-barrier min_slave_number

13.4 Cluster节点操作命令

• 查看集群节点信息
  • cluster nodes
• 更改slave指向新的master
  • cluster replicate master-id
• 发现一个新节点，新增master
  • cluster meet ip:port
• 忽略一个没有solt的节点
  • cluster forget server_id
• 手动故障转移
  • cluster failover

13.5 集群操作命令

• 创建集群
  • redis-cli –-cluster create masterhost1:masterport1 masterhost2:masterport2 masterhost3:masterport3 [masterhostn:masterportn …] slavehost1:slaveport1 slavehost2:slaveport2 slavehost3:slaveport3 -–cluster-replicas n

  注意：master与slave的数量要匹配，一个master对应n个slave，由最后的参数n决定
  master与slave的匹配顺序为第一个master与前n个slave分为一组，形成主从结构

• 添加master到当前集群中，连接时可以指定任意现有节点地址与端口
  • redis-cli --cluster add-node new-master-host:new-master-port now-host:now-port
• 添加slave
  • redis-cli --cluster add-node new-slave-host:new-slave-port master-host:master-port --cluster-slave --cluster-master-id masterid
• 删除节点，如果删除的节点是master，必须保障其中没有槽slot
  • redis-cli --cluster del-node del-slave-host:del-slave-port del-slave-id
• 重新分槽，分槽是从具有槽的master中划分一部分给其他master，过程中不创建新的槽
  • redis-cli --cluster reshard new-master-host:new-master:port --cluster-from src- master-id1, src-master-id2, src-master-idn --cluster-to target-master-id -- cluster-slots slots

  注意：将需要参与分槽的所有masterid不分先后顺序添加到参数中，使用，分隔指定目标得到的槽的数量，所有的槽将平均从每个来源的master处获取

• 重新分配槽，从具有槽的master中分配指定数量的槽到另一个master中，常用于清空指定master中的槽
  • redis-cli --cluster reshard src-master-host:src-master-port --cluster-from src- master-id --cluster-to target-master-id --cluster-slots slots --cluster-yes

14. 企业级解决方案

14.1 缓存预热

• 场景
  • 服务器启动后迅速宕机
• 问题排查
  • 请求数量较高，大量的请求过来之后都需要去从缓存中获取数据，但是缓存中又没有，此时从数据库中查找数据然后将数据再存入缓存，造成了短期内对redis的高强度操作从而导致问题
  • 主从之间数据吞吐量较大，数据同步操作频度较高
• 解决方案
  • 前置准备工作
    • 日常例行统计数据访问记录，统计访问频度较高的热点数据
    • 利用LRU数据删除策略，构建数据留存队列
  • 准备工作
    • 将统计结果中的数据分类，根据级别，redis优先加载级别较高的热点数据
    • 利用分布式多服务器同时进行数据读取，提速数据加载过程
    • 热点数据主从同时预热
  • 实施
    • 使用脚本程序固定触发数据预热过程
    • 如果条件允许，使用了CDN（内容分发网络），效果会更好

  总结

  • 缓存预热就是系统启动前，提前将相关的缓存数据直接加载到缓存系统。避免在用户请求的时候，先查询数据库，然后再将数据缓存的问题！用户直接查询事先被预热的缓存数据

14.2 缓存雪崩

• 数据库服务器崩溃，一连串的场景会随之而来
  • 1.系统平稳运行过程中，忽然数据库连接量激增
  • 2.应用服务器无法及时处理请求
  • 3.大量408，500错误页面出现
  • 4.客户反复刷新页面获取数据
  • 5.数据库崩溃
  • 6.应用服务器崩溃
  • 7.重启应用服务器无效
  • 8.Redis服务器崩溃
  • 9.Redis集群崩溃
  • 10.重启数据库后再次被瞬间流量放倒
• 问题排查
  • 1.在一个较短的时间内，缓存中较多的key集中过期
  • 2.此周期内请求访问过期的数据，redis未命中，redis向数据库获取数据
  • 3.数据库同时接收到大量的请求无法及时处理
  • 4.Redis大量请求被积压，开始出现超时现象
  • 5.数据库流量激增，数据库崩溃
  • 6.重启后仍然面对缓存中无数据可用
  • 7.Redis服务器资源被严重占用，Redis服务器崩溃
  • 8.Redis集群呈现崩塌，集群瓦解
  • 9.应用服务器无法及时得到数据响应请求，来自客户端的请求数量越来越多，应用服务器崩溃
  • 10.应用服务器，redis，数据库全部重启，效果不理想
  • 总而言之就两点：短时间范围内，大量key集中过期
• 解决方案
  • 思路
    • 更多的页面静态化处理
    • 构建多级缓存架构（Nginx缓存+redis缓存+ehcache缓存）
    • 检测Mysql严重耗时业务进行优化（对数据库的瓶颈排查：例如超时查询、耗时较高事务等）
    • 灾难预警机制，监控redis服务器性能指标（CPU占用、CPU使用率、内存容量、查询平均响应时间、线程数）
    • 限流，降级（短时间范围内牺牲一些客户体验，限制一部分请求访问，降低应用服务器压力，待业务低速运转后再逐步放开访问）
  • 实施
    • LRU与LFU切换
    • 数据有效期策略调整（根据业务数据有效期进行分类错峰，A类90分钟，B类80分钟，C类70分钟，过期时间使用固定时间+随机值的形式，稀释集中到期的key的数量）
    • 超热数据使用永久key
    • 定期维护（自动+人工）（对即将过期数据做访问量分析，确认是否延时，配合访问量统计，做热点数据的延时）
    • 加锁：慎用！

  总结

  • 缓存雪崩就是瞬间过期数据量太大，导致对数据库服务器造成压力。如能够有效避免过期时间集中，可以有效解决雪崩现象的 出现（约40%），配合其他策略一起使用，并监控服务器的运行数据，根据运行记录做快速调整

14.3 缓存击穿

• 还是数据库服务器崩溃，但是跟之前的场景有点不太一样
  • 1.系统平稳运行过程中
  • 2.数据库连接量瞬间激增
  • 3.Redis服务器无大量key过期
  • 4.Redis内存平稳，无波动
  • 5.Redis服务器CPU正常
  • 6.数据库崩溃
• 问题排查
  • 1.Redis中某个key过期，该key访问量巨大
  • 2.多个数据请求从服务器直接压到Redis后，均未命中
  • 3.Redis在短时间内发起了大量对数据库中同一数据的访问
  • 总而言之就两点：单个key高热数据，key过期
• 解决方案
  • 预先设定
    • 以电商为例，每个商家根据店铺等级，指定若干款主打商品，在购物节期间，加大此类信息key的过期时长 注意：购物节不仅仅指当天，以及后续若干天，访问峰值呈现逐渐降低的趋势
  • 现场调整
    • 监控访问量，对自然流量激增的数据延长过期时间或设置为永久性key
  • 后台刷新数据
    • 启动定时任务，高峰期来临之前，刷新数据有效期，确保不丢失
  • 二级缓存
    • 设置不同的失效时间，保障不会被同时淘汰就行
  • 枷锁
    • 分布式锁，防止被击穿，但是要注意也是性能瓶颈，慎重！

  总结

  • 缓存击穿就是单个高热数据过期的瞬间，数据访问量较大，未命中redis后，发起了大量对同一数据的数据库访问，导致对数 据库服务器造成压力。应对策略应该在业务数据分析与预防方面进行，配合运行监控测试与即时调整策略，毕竟单个key的过 期监控难度较高，配合雪崩处理策略即可

14.4 缓存穿透

• 场景
  • 1.系统平稳运行过程中
  • 2.应用服务器流量随时间增量较大
  • 3.Redis服务器命中率随时间逐步降低
  • 4.Redis内存平稳，内存无压力
  • 5.Redis服务器CPU占用激增
  • 6.数据库服务器压力激增
  • 7.数据库崩溃
• 问题排查
  • 1.Redis中大面积出现未命中
  • 2.出现非正常URL访问
• 问题分析
  • 获取的数据在数据库中也不存在，数据库查询未得到对应数据
  • Redis获取到null数据未进行持久化，直接返回
  • 下次此类数据到达重复上述过程
  • 出现黑客攻击服务器
• 解决方案
  • 缓存null
    • 对查询结果为null的数据进行缓存（长期使用，定期清理），设定短时限，例如30-60秒，最高5分钟
  • 白名单策略
    • 提前预热各种分类数据id对应的bitmaps，id作为bitmaps的offset，相当于设置了数据白名单。当加载正常数据时放行，加载异常数据时直接拦截（效率偏低）
    • 使用布隆过滤器（有关布隆过滤器的命中问题对当前状况可以忽略）
  • 实施监控
    • 实时监控redis命中率（业务正常范围时，通常会有一个波动值）与null数据的占比
    • 非活动时段波动：通常检测3-5倍，超过5倍纳入重点排查对象
    • 活动时段波动：通常检测10-50倍，超过50倍纳入重点排查对象
    • 根据倍数不同，启动不同的排查流程。然后使用黑名单进行防控（运营）
  • key加密
    • 问题出现后，临时启动防灾业务key，对key进行业务层传输加密服务，设定校验程序，过来的key校验
    • 例如每天随机分配60个加密串，挑选2到3个，混淆到页面数据id中，发现访问key不满足规则，驳回数据访问

  总结

  • 缓存击穿是指访问了不存在的数据，跳过了合法数据的redis数据缓存阶段，每次访问数据库，导致对数据库服务器造成压力。通常此类数据的出现量是一个较低的值，当出现此类情况以毒攻毒，并及时报警。应对策略应该在临时预案防范方面多做文章
  • 无论是黑名单还是白名单，都是对整体系统的压力，警报解除后尽快移除。

14.5 性能指标监控

• 性能指标：Performance
  • 响应请求的平均时间
    • latency
  • 平均每秒处理请求总数
    • instantaneous_ops_per_sec
  • 缓存查询命中率（通过查询总次数与查询得到非nil数据总次数计算而来）
    • hit_rate(calculated)
• 内存指标：Memory
  • 当前内存使用量
    • used_memory
  • 内存碎片率（关系到是否进行碎片整理）
    • mem_fragmentation_ratio
  • 为避免内存溢出删除的key的总数量
    • evicted_keys
  • 基于阻塞操作（BLPOP等）影响的客户端数量
    • blocked_clients
• 基本活动指标：Basic_activity
  • 当前客户端连接总数
    • connected_clients
  • 当前连接slave总数
    • connected_slaves
  • 最后一次主从信息交换距现在的秒
    • master_last_io_seconds_ago
  • key的总数
    • keyspace
• 持久性指标：Persistence
  • 当前服务器最后一次RDB持久化的时间
    • rdb_last_save_time
  • 当前服务器最后一次RDB持久化后数据变化总量
    • rdb_changes_since_last_save
• 错误指标：Error
  • 被拒绝连接的客户端总数（基于达到最大连接值的因素）
    • rejected_connections
  • key未命中的总次数
    • keyspace_misses
  • 主从断开的秒数
    • master_link_down_since_seconds

14.6 性能监控工具

• 要对redis的相关指标进行监控，我们可以采用一些用具：
  • CloudInsight Redis
  • Prometheus
  • Redis-stat
  • Redis-faina
  • RedisLive
  • zabbix
• 也有一些命令工具：
  • benchmark
  • redis-cli
• benchmark
  • 测试当前服务器的并发性能
    • redis-benchmark [-h ] [-p ] [-c ] [-n <requests]> [-k ]
  • 范例1：50个连接，10000次请求对应的性能
    • redis-benchmark -c -n
  • 范例2：100个连接，5000次请求对应的性能
    • redis-benchmark -c 100 -n 5000
      
• redis-cli
  • monitor：启动服务器调试信息
    • monitor
  • slowlog：慢日志
    • 获取慢查询日志
      • slowlog [operator]
      • get ：获取慢查询日志信息
      • len ：获取慢查询日志条目数
      • reset ：重置慢查询日志
    • 相关配置
      • slowlog-log-slower-than 1000 #设置慢查询的时间下线，单位：微妙
slowlog-max-len 100 #设置慢查询命令对应的日志显示长度，单位：命令数