redis学习
记录学习NoSQL Redis
一、NoSQL概述
- NoSQL,指的是非关系型数据库。NoSQL有时也称为Not Only SQL的缩写,是对不同于传统的关系型数据库的数据库管理系统的统称。
1、为什么要用NoSQL
1、单机mysql的年代
在早期90年代,一个网站的访问量一般都不大,用单个数据库完全够用。
在那个时代,网站更多使用的都是静态网页,动态交互型界面使用不多。
DAL:Data Access Layer(数据访问层-Hibernate,Mybatis)
但使用该架构的情况下,也随之存在不少问题,网站存在对应的瓶颈
- 数据量的总大小一个机器放不下时
- 数据的索引(B+Tree)一个机器的内存放不下时
- 访问量(读写混合)一个实例Mysql不能接受
只要出现上述三种情况之一,可能就会导致网站的无法正常使用,只能对数据库的整体架构进行重构
2、memcached(缓存)+mysql+垂直拆分(读写分离)
- 随着网站访问量的不断上升,几乎大部分使用单机mysql架构的网站在数据库上都出现了性能问题
- 随之而来的实际,使用缓存技术来环节数据库的压力,优化数据库结构和索引。。开始比较流行的是通过文件缓存来缓解数据库压力,但是当访问量继续增大的时候,多台web机器通过文件缓存不能共享,大量的小文件缓存也带了了比较高的IO压力。
- 在这个时候,Memcached就自然的成为一个非常时尚的技术产品。
- 网站80%的情况都是在读,每次都要去查询数据库的话就十分的麻烦!所以说我们希望减轻数据的压力,我们可以使用缓存来保证效率!
- Memcached作为一个独立的分布式的缓存服务器,为多个web服务器提供了一个共享的高性能缓存服务,在Memcached服务器上,又发展了根据hash算法来进行多台Memcached缓存服务的扩展,然后又出现了一致性hash来解决增加或减少缓存服务器导致重新hash带来的大量缓存失效的弊端。
- 由于数据库的写入压力增加,Memcached只能缓解数据库的读取压力。读写集中在一个数据库上让数据库不堪重负,大部分网站开始使用主从复制技术来达到读写分离,以提高读写性能和读库的可扩展性。Mysql的master-slave模式成为这个时候的网站标配了。
3、分库分表+水平拆分+mysql集群
- 本质:数据库的读写
- 早些年的MyISAM:表锁,十分影响效率,高并发情况下就会出现严重的锁问题
- 当下的转战Innodb:行锁
- 技术和业务在发展的同时,对人的要求也越来越高!
- 慢慢的就开始使用分库分表来解决写的压力!MySQL在某个年代推出了表分区,但并没有什么公司用!
- 为满足需求,随之诞生的则是MySQL的集群,很好满足那个时代的所有需求!
4、如今最近的年代
- 2010-2020十年之间,世界已经发生了翻天覆地的变化;(定位,音乐。热榜也是一种数据)
- MySQL等关系型数据库就不够用了!当下数据量很多(大数据时代),变化很快!
- MySQL用它存储一些比较大的文件,效率就低了,比如博客,图片等!如果有一种数据库去专门处理这种数据。
最前面的是企业级防火墙,后面通过负载均衡主机(软负载:Nginx,硬负载:F5)在 web 服务器集群之间进行调度,再由具体的 web 服务器(Tomcat)去访问缓存,访问数据库。
为什么要nosql
今天我们可以通过第三方平台(如:Google,Facebook等)可以很容易的访问和抓取数据。用户的个人信息,社交网络,地理位置,用户生成的数据和用户操作日志已经成倍的增加。我们如果要对这些用户数据进行挖掘,那SQL数据库已经不适合这些应用了, NoSQL数据库的发展也却能很好的处理这些大的数据。
2、什么是NoSQL
NoSQL
NoSQL = Not Only SQL(不仅仅是SQL)
关系型数据库:表格 (行 ,列)
泛指非关系型数据库的,随着web2.0互联网的诞生!传统的关系型数据库很难对付web2.0时代!尤其是超大规模的高并发的社区! 暴露出来很多难以克服的问题,NoSQL在当今大数据环境下发展的十分迅速,Redis是发展最快的,而且是我们当下必须要掌握的一个技术!
很多的数据类型用户的个人信息,社交网络,地理位置。这些数据类型的存储不需要一个固定的格式!不需要多余的操作就可以横向扩展的 ! Map<String,Object> 使用键值对来控制!
NoSQL特点
解耦!!
方便拓展(数据之间没有关系,很好扩展!)
大数据量高性能(Redis一秒写8万次,读取11万,NoSQL的缓存记录级,是一种细粒度的缓存,性能会比较高)
数据类型是多样型的!(不需要事先设计数据库!随取随用!如果数据量非常大的表,很多人就无法设计了)
传统RDBMS(关系型数据库)和NoSQL的对比
1
2
3
4
5
6
7
8传统的 RDBMS
- 高度组织化结构化数据
- 结构化查询语言(SQL)
- 数据和关系都存储在单独的表中。
- 数据操纵语言,数据定义语言
- 严格的一致性
- 基础事务
- .....1
2
3
4
5
6
7
8
9Nosql
- 代表着不仅仅是SQL
- 没有声明性查询语言
- 没有预定义的模式
- 键值对存储,列存储,文档存储,图形数据库
- 最终一致性,而非ACID属性
- 非结构化和不可预知的数据
- CAP定理(C:强一致性 A:高可用性 P:分布式容忍性)
- 高性能,高可用性和可伸缩性
理解:3V+3高
大数据时代的3V:主要是描述问题的
- 海量Volume
- 多样Variety
- 实时Velocity
大数据时代的3高:主要是对程序的要求
- 高并发
- 高可扩
- 高性能
真正在公司中的实践:NoSQL + RDBMS 一起使用才是最强的,阿里巴巴的架构演进!
3、阿里巴巴演进分析
思考问题:这么多东西难道都是在一个数据库中的吗?
技术急不得,越是慢慢学,才能越扎实!
开源才是技术的王道!
任何一家互联网的公司,都不可能只是简简单单让用户能用就好了
大量公司做的都是相同的业务(竞品协议)
随着这样的竞争,业务是越来越完善,然后对于开发者的要求也是越来越高
如果你未来相当一个架构师: 没有什么是加一层解决不了的
1 | # 1、商品的基本信息 |
要知道,一个简单地网页背后的技术一定不是大家所想的那么简单
大型互联网应用问题
- 数据类型太多了
- 数据源繁多,经常重构
- 数据要改造,大面积改造
解决问题:
这里以上都是NoSQL入门概述,不仅能够提高大家的知识,还可以帮助大家了解大厂的工作内容
4、NoSQL的四大分类
键值(Key-Value)存储数据库
这一类数据库主要会使用到一个哈希表,这个表中有一个特定的键和一个指针指向特定的数据。Key/value模型对于IT系统来说的优势在于简单、易部署。但是如果DBA(数据库管理员)只对部分值进行查询或更新的时候,Key/value就显得效率低下了。举例如:Tokyo Cabinet/Tyrant, Redis, Voldemort, Oracle BDB
列存储数据库
这部分数据库通常是用来应对分布式存储的海量数据。键仍然存在,但是它们的特点是指向了多个列。这些列是由列家族来安排的。如:Cassandra, HBase, Riak.
文档型数据库
文档型数据库的灵感是来自于Lotus Notes办公软件的,而且它同第一种键值存储相类似。该类型的数据模型是版本化的文档,半结构化的文档以特定的格式存储,比如JSON。文档型数据库可 以看作是键值数据库的升级版,允许之间嵌套键值。而且文档型数据库比键值数据库的查询效率更高。如:CouchDB, MongoDb. 国内也有文档型数据库SequoiaDB,目前已经开源
图形(Graph)数据库
图形结构的数据库同其他行列以及刚性结构的SQL数据库不同,它是使用灵活的图形模型,并且能够扩展到多个服务器上。NoSQL数据库没有标准的查询语言(SQL),因此进行数据库查询需要制定数据模型。许多NoSQL数据库都有REST式的数据接口或者查询API。 如:Neo4J, InfoGrid, Infinite Graph
对比
二、redis入门
1、概述
redis是什么??
Redis(Remote Dictionary Server ),即远程字典服务 !
是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库,并提供多种语言的API
redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件,并且在此基础上实现了master-slave(主从)同步。
免费和开源!是当下最热门的 NoSQL 技术之一!也被人们称之为结构化数据库!
redis能干嘛?
- 内存存储、持久化,内存中是断电即失、所以说持久化很重要(rdb,aof)
- 效率高,可以用于高速缓存
- 发布订阅系统
- 地图信息分析
- 计时器、计数器(浏览量!)
- …
特性
- 多样的数据类型
- 持久化
- 集群
- 事务
- …
学习中用到的东西
下载地址:https://redis.io/download/
注意:Wdinow在 Github上下载(停更很久了!)
Redis推荐都是在Linux服务器上搭建的,我们是基于Linux学习!
2、WIndows下Redis的安装
1、下载压缩包直接使用即可。下载地址:https://github.com/tporadowski/redis/releases
2、打开server服务,再使用client去连接,即可直接命令行使用。
记住一句话,Window下使用确实简单,但是Redis 推荐我们使用Linux去开发使用!
3、Linux安装
- 直接找到官网链接对应的下载安装方法 链接:https://redis.io/docs/latest/operate/oss_and_stack/install/install-redis/install-redis-on-linux/
- 使用snap再Ubuntu上安装
1 | sudo apt update |
- 一些常见的snap操作redis的命令
1 | sudo snap start redis |
- 但这里我们就不使用这种方式了,我们可以去自己下载对应的源码编译
1 | wget https://download.redis.io/redis-stable.tar.gz |
- 然后就是可以进入我们默认的安装路径
/usr/local/bin/
,可以发现已经成功安装上了
- 然后我们就可以去创建一个文件夹专门去存放我们的配置文件,方便我们之后的使用
1 | mkdir myconfig |
- 修改配置文件,开启守护进程,使redis能够在后台运行
- 使用我们自己的配置文件去启动redis服务
1 | root@VM-16-10-ubuntu:/usr/local/bin# redis-server myconfig/redis.conf |
- 成功完成启动和连接
- 关闭redis并退出
1 | 127.0.0.1:6379> shutdown |
4、压力测试
- redis-benchmark是一个压力测试工具
- 官方自带的性能测试工具
我们来简单测试一下
1 | 测试100个并发,100个请求 |
中间的部分就是不同毫秒时处理总数据的百分比以及延迟;最后的部分就是算出的平均吞吐量了。总体来说,吞吐速度还是很不错的。
5、基础知识
- redis默认有16个数据库,这可以在redis.conf配置文件中可以看到
- 可以在配置文件中修改databases的值去修改默认的数据库的数量
- 数据库默认使用的是第0个数据库
- redis使用时可以使用select去切换数据库
1 | 127.0.0.1:6379> dbsize # 查看db大小 |
清空当前数据库
flushdb
清除所有数据库
flushall
Redis 是单线程的!
明白Redis是很快的,官方表示,Redis是基于内存操作,CPU不是Redis性能瓶颈,Redis的瓶颈是根据机器的内存和网络带宽,既然可以使用单线程来实现,就使用单线程了!所以就使用了单线程了!
Redis 是C 语言写的,官方提供的数据为 10W+ 的QPS,完全不比同样是使用 key-vale的Memecache差!
Redis为什么单线程还这么快?
1、误区1:高性能的服务器一定是多线程的?
2、误区2:多线程(CPU上下文会切换!)一定比单线程效率高!
速度:CPU>内存>硬盘
核心:redis 是将所有的数据全部放在内存中的,所以说使用单线程去操作效率就是最高的,
多线程(CPU上下文会切换:耗时的操作!!!),对于内存系统来说,如果没有上下文切换效率就是最高的!
多次读写都是在一个CPU上的,在内存情况下,这个就是最佳的方案!
三、五大数据类型
Redis 是一个开源(BSD许可)的,内存中的数据结构存储系统,它可以用作数据库、缓存和消息中间件MQ。 它支持多种类型的数据结构,如 字符串(strings), 散列(hashes), 列表(lists), 集合(sets), 有序集合(sorted sets) 与范围查询, bitmaps, hyperloglogs 和 地理空间(geospatial) 索引半径查询。 Redis 内置了 复制(replication),LUA脚本(Lua scripting), LRU驱动事件(LRU eviction),事务(transactions) 和不同级别的 磁盘持久化(persistence), 并通过Redis哨兵(Sentinel)和自动 分区(Cluster)提供高可用性(high availability)。
1、常见命令
1 | 127.0.0.1:6379[3]> keys * # 查看所有的key |
2、String(字符串)
1 | ################################################# |
String类似的使用场景:value除了是我们的字符串还可以是我们的数字!
- 计数器
- 粉丝数
- 对象缓存存储
3、List(列表)
Redis列表是简单的字符串列表,按照插入顺序排序。按照插入顺序排序。你可以添加一个元素到列表的头部(左边)或者尾部(右边)
在redis里面,我们可以把list玩成 栈、队列、阻塞队列!
1 | ################################################# |
小结
- 他实际上是一个链表,before Node after , left,right 都可以插入值
- 如果key 不存在,创建新的链表
- 如果key存在,新增内容
- 如果移除了所有值,空链表,也代表不存在
- 在两边插入或者改动值,效率最高! 中间元素,相对来说效率会低一点~
消息队列(Lpush Rpop)
栈( Lpush Lpop)
4、Set集合
Redis 的 Set 是 String 类型的无序集合。集合成员是唯一的,这就意味着集合中不能出现重复的数据。
1 | ################################################# |
5、Hash(哈希)
Redis hash 是一个 string 类型的 field(字段) 和 value(值) 的映射表,hash 特别适合用于存储对象。
1 | ################################################# |
hash变更的数据 user name age,尤其是是用户信息之类的,经常变动的信息!
hash 更适合于对象的存储,String更加适合字符串存储!
6、Zset(有序集合)
1 | ################################################# |
其余的一些api,可以去查询官方文档
案例思路:
set 排序、存储班级成绩,工资表排序
加权:1-重要消息 0-普通消息
排行榜应用实现,取top 10
四、三种特殊数据类型
Redis在3.2版本中加入了地理空间(geospatial)以及索引半径查询的功能
主要用在需要地理位置的应用上
朋友的定位,附近的人,打车距离计算
查询城市经纬度:http://www.jsons.cn/lngcode/
geodd 功能说明: 将指定的地理空间位置(纬度、经度、名称)添加到指定的key中。
1 | # getadd 添加地理位置 |
geopos 功能说明: 从key里返回所有给定位置元素的位置(经度和纬度)
GEOPOS 命令返回一个数组, 数组中的每个项都由两个元素组成: 第一个元素为给定位置元素的经度, 而第二个元素则为给定位置元素的纬度。
当给定的位置元素不存在时, 对应的数组项为空值
1 | 127.0.0.1:6379> geopos china:city xian |
geodist 两人之间的距离!
功能说明
- 返回两个给定位置之间的距离,如果两个位置之间的其中一个不存在, 那么命令返回空值
- 指定单位的参数 unit 必须是以下单位的其中一个
- m 表示单位为米(默认值)
- km 表示单位为千米
- mi 表示单位为英里
- ft 表示单位为英尺
1 | 127.0.0.1:6379> geodist china:city beijing shanghai |
georadius
我附近的人? (获得所有附近的人的地址,定位!)通过半径来查询!
以给定的经纬度为中心, 返回键包含的位置元素当中,与中心的距离不超过给定最大距离的所有位置元素
在给定以下可选项时, 命令会返回额外的信息:
withdist
在返回位置元素的同时, 将位置元素与中心之间的距离也一并返回。 距离的单位和用户给定的范围单位保持一致。
withcoord
将位置元素的经度和维度也一并返回。
withhash
以 52 位有符号整数的形式, 返回位置元素经过原始 geohash 编码的有序集合分值。 这个选项主要用于底层应用或者调试, 实际中的作用并不大。 命令默认返回未排序的位置元素。
1 | 127.0.0.1:6379> georadius china:city 110 30 1000 km # 以110,30 这个经纬度为中心,寻找方圆1000km内的城市 |
georadiusbymember
功能说明: 这个命令和 GEORADIUS 命令一样, 都可以找出位于指定范围内的元素, 但是 GEORADIUSBYMEMBER 的中心点是由给定的位置元素决定的, 而不是像 GEORADIUS 那样, 使用输入的经度和纬度来决定中心点指定成员的位置被用作查询的中心
1 | 127.0.0.1:6379> GEORADIUSBYMEMBER china:city beijing 1000 km # 以北京为中心,附近1000米的城市 |
geohash
该命令将返回11个字符的Geohash字符串!
1 | # 将二维的经纬度转换为一维的字符串,如果两个字符串越接近,那么则距离越近! |
geo底层的实现原理其实就是zset!我们可以使用zset命令来操作geo!
1 | 127.0.0.1:6379> zrange china:city 0 -1 # 查看全部的元素 |
2、hyperloglog
什么是基数
比如数据集 {1, 3, 5, 7, 5, 7, 8}, 那么这个数据集的基数集为 {1, 3, 5 ,7, 8},
基数(不重复元素)为5。 基数估计就是在误差可接受的范围内,快速计算基数。
简介
Redis 2.8.9 版本就更新了 Hyperloglog 数据结构!
Redis HyperLogLog 是用来做基数统计的算法,HyperLogLog 的优点是,在输入元素的数量或者体积非常非常大时,计算基数所需的空间总是固定的、并且是很小的。
在 Redis 里面,每个 HyperLogLog 键只需要花费 12 KB 内存,就可以计算接近 2^64 个不同元素的基 数。这和计算基数时,元素越多耗费内存就越多的集合形成鲜明对比。
但是,因为 HyperLogLog 只会根据输入元素来计算基数,而不会储存输入元素本身,所以 HyperLogLog 不能像集合那样,返回输入的各个元素。
网页的UV 一个人访问一个网站多次,但是还是算作一个人!)
传统的方式, set 保存用户的id,然后就可以统计 set 中的元素数量作为标准判断 !
这个方式如果保存大量的用户id,就会比较麻烦!我们的目的是为了计数,而不是保存用户id;
测试使用
1 | 127.0.0.1:6379> pfadd mykey a b c d e # 创建第一组元素 mykey |
0.81% 错误率! 统计UV任务,可以忽略不计的!
如果允许容错,那么一定可以使用 Hyperloglog
如果不允许容错,就使用 set 或者自己的数据类型即可!
3、bitmap
BitMap 原本的含义是用一个比特位来映射某个元素的状态。由于一个比特位只能表示 0 和 1 两种状态,所以 BitMap 能映射的状态有限,但是使用比特位的优势是能大量的节省内存空间。
应用场景
- 用户签到
- 统计活跃用户(用户登陆情况)
- 统计用户是否在线
- 实现布隆过滤器
测试
使用bitmap 来记录 周一到周日的打卡!
7天打卡
1 | 127.0.0.1:6379> setbit sign 1 1 |
查看某一天的打开情况
1 | 127.0.0.1:6379> getbit sign 1 |
统计操作,统计 打卡的天数!
1 | 127.0.0.1:6379> bitcount sign # 统计这周的打卡记录,就可以看到是否有全勤! |
五、事务
Redis 事务本质:一组命令的集合! 一个事务中的所有命令都会被序列化,在事务执行过程的中,会按照顺序执行!
一次性、顺序性、排他性!执行一系列的命令!
Redis事务没有没有隔离级别的概念!
所有的命令在事务中,并没有直接被执行!只有发起执行命令的时候才会执行!exec
Redis单条命令式保证原子性的,但是事务不保证原子性!
Redis 事务可以一次执行多个命令, 并且带有以下三个重要的保证:
- 批量操作在发送 EXEC 命令前被放入队列缓存
- 收到 EXEC 命令后进入事务执行,事务中任意命令执行失败,其余的命令依然被执行
- 在事务执行过程,其他客户端提交的命令请求不会插入到事务执行命令序列中
一个事务从开始到执行会经历以下三个阶段:
- 开启事务(multi)
- 命令入队(……)
- 执行事务(exec)
正常执行事务
1 | 127.0.0.1:6379> multi # 开启事务 |
放弃事务
1 | discard # 取消事务 |
编译型异常(代码有误!命令有误!)事务中所有的命令都不会执行
1 | 127.0.0.1:6379> keys * |
运行时异常,如果事务队列中存在语法性错误,那么执行命令的时候,其他命令是可以正常执行的,错误命令抛出错误
1 | 127.0.0.1:6379> keys * |
监控 watch
悲观锁
很悲观,认为什么时候都会出问题,无论做什么都会加锁!
乐观锁
很乐观,认为什么时候都不会出问题,所以不会上锁,更新数据的时候去判断一下,再此期间是否有人修改过这个数据
获取version
更新的时候带上version条件
redis监视
正常情况
1 | 127.0.0.1:6379> set money 100 # 现在有100块钱 |
失败情况,模拟多线程修改值 , 使用watch 可以当做redis的乐观锁操作!
1 | 127.0.0.1:6379> watch money # 监视money |
在上面执行事务之前,另外一个线程又往money中充了100块
重新开启一个redis服务
1 | 127.0.0.1:6379> keys * |
回到原来的redis服务,执行事务,发现执行失败
1 | 127.0.0.1:6379(TX)> exec # 执行之前,另外一个线程,修改了我们的值,这个时候,就会导致事务执行失 败! |
如何解决这个问题呢?
1 | 127.0.0.1:6379> unwatch # 1.如果发现事务执行失败,就先解锁 |
六、jedis
什么是Jedis 是 Redis 官方推荐的 java连接开发工具! 使用Java 操作Redis 中间件!如果你要使用
java操作redis,那么一定要对Jedis 十分的熟悉!
测试使用
1、首先就是新建一个maven项目,导入对应所需要的依赖
1 | <!-- https://mvnrepository.com/artifact/redis.clients/jedis --> |
2、由于我们是在windows上进行测试,所以我们可以开启windows的redis服务端去测试一下。
3、编写简单的代码去测试redis的连接
1 | package com.github; |
5、测试功能(简单使用一下事务功能)
1 | import redis.clients.jedis.Jedis; |
事务执行失败,我们将异常代码注释后再次去执行
成功完成对应事务的执行
七、springboot整合
SpringData 也是和 SpringBoot 齐名的项目
官方:https://spring.io/projects/spring-data-redis
说明: 在 SpringBoot2.x 之后,原来使用的jedis 被替换为了 lettuce?
jedis:采用的直连,多个线程操作的话,是不安全的,如果想要避免不安全,使用redis pool连接池,更像BIO模式!
lettuce:采用netty,实例可以再多个线程中进行共享,不存在线程不安全的情况,可以减少线程数据。更新NIO模式!
简单的使用
1、首先就是配置对应的连接
1 | # 配置redis1 |
2、编写简单的测试项目
1 |
|
进阶使用,使用redis存储对象
User.java
1 | package com.github.demo.pojo; |
1 |
|
注!!!!!如需存储对象到redis中需要将对象继承序列化方法才可以
1 |
|
但是仅仅是这样还是不够完美,我们发现使用客户端去直接查看时,中文就变成乱码了
为解决上述问题,自定义RedisTemplate
1 | package com.github.demo.config; |
再次运行上面的
正常取值
现在显示就是正常的了
所有的redis操作,其实对于java开发人员来说,十分的简单,更重要是要去理解redis的思想和每一种数
据结构的用处和作用场景!
八、Redis.conf详解
启动的时候,可以在启动加上配置文件位置,使用对应的配置文件去启动
表明了对应的单位,并且表示大小写不敏感
包含include,表名可以应用其他的配置文件
network 网络
1 | bind 127.0.0.1 # 绑定ip |
general 通用
1 | daemonize yes # 以守护进程的方式运行(是否在后台执行),默认是 no |
日志等级
- debug (a lot of information, useful for development/testing) 很多信息,方便开发、测试
- verbose (many rarely useful info, but not a mess like the debug level) 许多有用的信息,但是没有debug级别信息多
- notice (moderately verbose, what you want in production probably) 适当的日志级别,适合生产环境
- warning (only very important / critical messages are logged) 许多有用的信息,但是没有debug级别信息多
snapshotting 快照
持久化, 在规定的时间内,执行了多少次操作,则会持久化到文件
redis 是内存数据库,如果没有持久化,那么数据断电及失!
1 | save 900 1 # 如果900秒内,如果至少 1 个key进行了修改,我们则进行持久化操作 |
replication 复制,后面讲到主从复制的时候再说
security 安全
可以在这里设置redis的密码,默认是没有密码!
1 | 127.0.0.1:6379> ping |
重新打开一个服务
1 | [root@iZwz9efdd2ukk4oauustczZ ~]# /usr/local/bin/redis-cli -p 6379 |
clients 限制
1 | maxclients 10000 # 设置能连上redis的最大客户端连接数量。默认是10000个客户端连接。由于redis不区分连接是客户端连接还是内部打开文件或者和slave连接等,所以maxclients最小建议设置到32。如果超过了maxclients,redis会给新的连接发送’max number of clients reached’,并关闭连接。 |
当 Redis 内存使用达到 maxmemory
时,需要选择设置好的 maxmemory-policy
进行对数据进行淘汰机制。
1.volatile-lru(least recently used):最近最少使用算法,从设置了过期时间的键key中选择空转时间最长的键值对清除掉;
2.volatile-lfu(least frequently used):最近最不经常使用算法,从设置了过期时间的键中选择某段时间之内使用频次最小的键值对清除掉;
3.volatile-ttl:从设置了过期时间的键中选择过期时间最早的键值对清除;
4.volatile-random:从设置了过期时间的键中,随机选择键进行清除;
5.allkeys-lru:最近最少使用算法,从所有的键中选择空转时间最长的键值对清除;
6.allkeys-lfu:最近最不经常使用算法,从所有的键中选择某段时间之内使用频次最少的键值对清除;
7.allkeys-random:所有的键中,随机选择键进行删除;
8.noeviction:不做任何的清理工作,在redis的内存超过限制之后,所有的写入操作都会返回错误;但是读操作都能正常的进行;
append only mode
1 | appendonly no #默认redis使用的是rdb方式持久化,这种方式在许多应用中已经足够用了。但是redis如果中途宕机,会导致可能有几分钟的数据丢失,根据save来策略进行持久化,Append Only File是另一种持久化方式,可以提供更好的持久化特性。Redis会把每次写入的数据在接收后都写入 appendonly.aof 文件,每次启动时Redis都会先把这个文件的数据读入内存里,先忽略RDB文件。 |
九、redis持久化
Redis 是内存数据库,如果不将内存中的数据库状态保存到磁盘,那么一旦服务器进程退出,服务器中的数据库状态也会消失。所以 Redis 提供了持久化功能!
1、RDB(redis dbbase)
什么是rdb
RDB是一种快照存储持久化方式,具体就是将Redis某一时刻的内存数据保存到硬盘的文件当中,默认保存的文件名为dump.rdb,而在Redis服务器启动时,会重新加载dump.rdb文件的数据到内存当中恢复数据。
在指定的时间间隔内将内存中的数据集快照写入磁盘,也就是行话讲的Snapshot快照,它恢复时是将快照文件直接读到内存里。
Redis会单独创建(fork)一个子进程来进行持久化,会先将数据写入到一个临时文件中,待持久化过程都结束了,再用这个临时文件替换上次持久化好的文件。整个过程中,主进程是不进行任何IO操作的。这就确保了极高的性能。如果需要进行大规模数据的恢复,且对于数据恢复的完整性不是非常敏感,那RDB方式要比AOF方式更加的高效。RDB的缺点是最后一次持久化后的数据可能丢失。我们默认的就是RDB,一般情况下不需要修改这个配置!
有时候在生产环境我们会将这个文件进行备份!
rdb保存的文件是dump.rdb 都是在我们的配置文件中快照中进行配置的!
启动并登陆redis
1 | [root@iZwz9efdd2ukk4oauustczZ ~]# /usr/local/bin/redis-server /usr/local/bin/myconfig/redis.conf |
查看dump.rdb文件保存的路径
1 | 127.0.0.1:6379> config get dir |
去root目录先把dump.rdb删除了
然后如下操作
1 | 127.0.0.1:6379> keys * |
set k5 v5
的时候发现,root目录下生成了一个dump.rdb
然后我们关闭redis服务(断电即失)
1 | 127.0.0.1:6379> shutdown |
这个时候我们再次登陆redis服务,然后get k1
,发现仍然可以取到值
1 | [root@iZwz9efdd2ukk4oauustczZ ~]# /usr/local/bin/redis-server /usr/local/bin/myconfig/redis.conf |
验证完了,把redis.conf配置的save还原了
触发机制
- save的规则满足的情况下,会自动触发rdb规则
- 执行 flushall 命令,也会触发我们的rdb规则
- 退出redis,也会产生 rdb 文件
备份就自动生成一个 dump.rdb
如何恢复rdb文件
只需要将rdb文件放在我们redis启动目录就可以,redis启动的时候会自动检查dump.rdb 恢复其中的数据!
查看需要存在的位置
1
2
3127.0.0.1:6379> config get dir
1) "dir"
2) "/root" # 如果在这个目录下存在 dump.rdb 文件,启动就会自动恢复其中的数据
优缺点
优点:
- 适合大规模的数据恢复
- 对数据的完整性要不高
缺点:
- 需要一定的时间间隔进程操作!如果redis意外宕机了,这个最后一次修改数据就没有的了
- fork进程的时候,会占用一定的内容空间
2、AOF(append only file)
与RDB存储某个时刻的快照不同,AOF持久化方式会记录客户端对服务器的每一次写操作命令,并将这些写操作以Redis协议追加保存到以后缀为aof文件末尾,在Redis服务器重启时,会加载并运行aof文件的命令,以达到恢复数据的目的。
aof什么
以日志的形式来记录每个写操作,将Redis执行过的所有指令记录下来(读操作不记录),只许追加文件但不可以改写文件,redis启动之初会读取该文件重新构建数据,换言之,redis重启的话就根据日志文件的内容将写指令从前到后执行一次以完成数据的恢复工作
1 | 有点类似于mysql导出的sql文件 |
Aof保存的是 appendonly.aof 文件
append
然后重启redis,就可以生效了
如果这个 aof 文件有错位,这时候 redis 是启动不起来的吗,我们需要修复这个aof文件
redis 给我们提供了一个工具 redis-check-aof --fix
1 | [root@iZwz9efdd2ukk4oauustczZ bin]# redis-check-aof --fix /root/appendonlydir/appendonly.aof.1.incr.aof |
如果文件正常,重启就可以恢复了
重写规则说明
aof 默认就是文件的无限追加,文件会越来越大
如果 aof 文件大于 64m,太大了! fork一个新的进程来将我们的文件进行重写!
优点缺点
1 | # appendfsync always # 表示每次写入都执行fsync,以保证数据同步到磁盘 |
优点:
- 每一次修改都同步,文件的完整性会更加好
- 每秒同步一次,可能会丢失一秒的数据
- 从不同步,效率最高的
缺点:
- 相对于数据文件来说,aof远远大于 rdb,修复的速度也比 rdb慢
- Aof 运行效率也要比 rdb 慢,所以我们redis默认的配置就是rdb持久化
3、拓展
RDB 持久化方式能够在指定的时间间隔内对你的数据进行快照存储
AOF 持久化方式记录每次对服务器写的操作,当服务器重启的时候会重新执行这些命令来恢复原始的数据,AOF命令以Redis 协议追加保存每次写的操作到文件末尾,Redis还能对AOF文件进行后台重写,使得AOF文件的体积不至于过大
只做缓存,如果你只希望你的数据在服务器运行的时候存在,你也可以不使用任何持久化
同时开启两种持久化方式
在这种情况下,当redis重启的时候会优先载入AOF文件来恢复原始的数据,因为在通常情况下AOF文件保存的数据集要比RDB文件保存的数据集要完整
RDB 的数据不实时,同时使用两者时服务器重启也只会找AOF文件,那要不要只使用AOF呢?作者
建议不要,因为RDB更适合用于备份数据库(AOF在不断变化不好备份),快速重启,而且不会有
AOF可能潜在的Bug,留着作为一个万一的手段
性能建议
因为RDB文件只用作后备用途,建议只在Slave上持久化RDB文件,而且只要15分钟备份一次就够了,只保留 save 900 1 这条规则
如果Enable AOF ,好处是在最恶劣情况下也只会丢失不超过两秒数据,启动脚本较简单只load自己的AOF文件就可以了,
代价一是带来了持续的IO,
二是AOF rewrite 的最后将 rewrite 过程中产生的新数据写到新文件造成的阻塞几乎是不可避免的。
只要硬盘许可,应该尽量减少AOF rewrite的频率,AOF重写的基础大小默认值64M太小了,可以设到5G以上,默认超过原大小100%大小重写可以改到适当的数值
如果不Enable AOF ,仅靠 Master-Slave Repllcation 实现高可用性也可以,能省掉一大笔IO,也减少了rewrite时带来的系统波动。代价是如果Master/Slave 同时倒掉,会丢失十几分钟的数据,启动脚本也要比较两个 Master/Slave 中的 RDB文件,载入较新的那个,微博就是这种架构
十、redis发布订阅
Redis 发布订阅(pub/sub)是一种消息通信模式:发送者(pub)发送消息,订阅者(sub)接收消息。
Redis 客户端可以订阅任意数量的频道。
订阅/发布消息图:
第一个:消息发送者, 第二个:频道 第三个:消息订阅者!十、redis发布订阅
下图展示了频道 channel1 , 以及订阅这个频道的三个客户端 —— client2 、 client5 和 client1 之间的关系:
当有新消息通过 PUBLISH 命令发送给频道 channel1 时, 这个消息就会被发送给订阅它的三个客户端:
命令
这些命令被广泛用于构建即时通信应用,比如网络聊天室(chatroom)和实时广播、实时提醒等
测试
订阅频道
1
2
3
4127.0.0.1:6379(subscribed mode)> subscribe zyy
1) "subscribe"
2) "zyy"
3) (integer) 1发布消息到频道(新开一个服务验证)
1
2127.0.0.1:6379> PUBLISH zyy hellp
(integer) 1查看订阅者的变化
1
2
3
4
5
6
7127.0.0.1:6379(subscribed mode)> subscribe zyy
1) "subscribe"
2) "zyy"
3) (integer) 1
1) "message"
2) "zyy"
3) "hellp"
原理
Redis是使用C实现的,通过分析 Redis 源码里的 pubsub.c 文件,了解发布和订阅机制的底层实现,籍此加深对 Redis 的理解。
Redis 通过 PUBLISH 、SUBSCRIBE 和 PSUBSCRIBE 等命令实现发布和订阅功能。
通过 SUBSCRIBE 命令订阅某频道后,redis-server 里维护了一个字典,字典的键就是一个个 频道!,而字典的值则是一个链表,链表中保存了所有订阅这个 channel 的客户端。SUBSCRIBE 命令的关键,就是将客户端添加到给定 channel 的订阅链表中。
通过 PUBLISH 命令向订阅者发送消息,redis-server 会使用给定的频道作为键,在它所维护的 channel字典中查找记录了订阅这个频道的所有客户端的链表,遍历这个链表,将消息发布给所有订阅者。
Pub/Sub 从字面上理解就是发布(Publish)与订阅(Subscribe),在Redis中,你可以设定对某一个key值进行消息发布及消息订阅,当一个key值上进行了消息发布后,所有订阅它的客户端都会收到相应的消息。这一功能最明显的用法就是用作实时消息系统,比如普通的即时聊天,群聊等功能。
使用场景
- 实时消息系统
- 实时聊天!(频道当做聊天室,将信息回显给所有人即可!)
- 订阅,关注系统都是可以的!
稍微复杂的场景我们就会使用 消息中间件 MQ
十一、redis主从复制
1、概念
主从复制,是指将一台Redis服务器的数据,复制到其他的Redis服务器。前者称为主节点(master/leader),后者称为从节点(slave/follower);数据的复制是单向的,只能由主节点到从节点。Master以写为主,Slave 以读为主。
默认情况下,每台redis服务器都是主节点;且一个主节点可以有多个从节点(或者没有从节点),但一个从节点只能有一个主节点。
主从复制的作用主要包括:
- 数据冗余:主从复制实现了数据的热备份,是持久化之外的一种数据冗余方式
- 故障恢复:当主节点出现问题时,可以由从节点提供服务,实现快速的故障恢复;实际上是一种服务的冗余
- 负载均衡:在主从复制的基础上,配合读写分离,可以由主节点提供写服务,由从节点提供读服务(即写Redis数据时应用连接主节点,读Redis数据时应用连接从节点),分担服务器负载;尤其是在写少读多的场景下,通过多个从节点分担读负载,可以大大提高Redis服务器的并发量
- 高可用(集群)基石:除了上述作用以外,主从复制还是哨兵和集群能够实施的基础,因此说主从复制是Redis高可用的基础
一般来说,要将redis运用于工程项目中,只使用一台redis是万万不能的(宕机),原因如下:
- 从结构上,单个Redis服务器会发生单点故障,并且一台服务器需要处理所有的请求负载,压力较大
- 从容量上,单个Redis服务器内存容量有限,就算一台Redis服务器内存容量为256G,也不能将所有内存用作Redis存储内存,一般来说,单台Redis最大使用内存不应该超过20G
电商网站上的商品,一般都是一次上传,无数次浏览的,说专业点也就是”多读少写”。
对于这种场景,我们可以使如下这种架构
主从复制,读写分离! 80% 的情况下都是在进行读操作!减缓服务器的压力!架构中经常使用! 一主二从!
只要在公司中,主从复制就是必须要使用的,因为在真实的项目中不可能单机使用Redis!
2、环境模拟配置
复制三个配置文件,修改对应的信息
文件名
1
2
3redis-6380.conf
redis-6381.conf
redis-6382.conf端口
1
2
3port 6380
port 6381
port 6382pid名字
1
2
3pidfile /var/run/redis_6380.pid
pidfile /var/run/redis_6381.pid
pidfile /var/run/redis_6382.pidlog文件名字
1
2
3logfile "6380.log"
logfile "6381.log"
logfile "6382.log"dump.rdb名字
1
2
3dbfilename dump80.rdb
dbfilename dump81.rdb
dbfilename dump82.rdb
启动上面三台服务
查看6380的库的信息
1 | 127.0.0.1:6380> info replication |
3、一主二从
默认情况下,每台Redis服务器都是主节点; 我们一般情况下只用配置从机就好了!
认老大! 一主 (6380)二从(6381,6382)
配置6380作为6381的主机
1 | 127.0.0.1:6381> SLAVEOF 127.0.0.1 6380 |
重新查看6380的配置
1 | 127.0.0.1:6380> info replication |
同样的配置配置6382即可
真实的从主配置应该在配置文件中配置,这样的话是永久的,我们这里使用的是命令,暂时的!
细节
主机可以读,可以写,从机只能读,不能写!主机中的所有信息和数据,都会被从机保存
主机:
1 | 127.0.0.1:6380> set k1 v1 |
从机:
1 | 127.0.0.1:6381> set k2 v2 |
测试:主机断开连接,从机依旧连接到主机的,但是没有写操作,这个时候,主机如果回来了,从机依旧可以直接获取到主机写的信息!
1 | # 主机宕机了 |
如果是使用命令行,来配置的主从,这个时候如果重启了,就会变回主机!只要变为从机,立马就会从主机中获取值!
1 | 127.0.0.1:6380> shutdown # 从机宕机了 |
复制原理
Slave 启动成功连接到 master 后会发送一个sync同步命令
Master 接到命令,启动后台的存盘进程,同时收集所有接收到的用于修改数据集命令,在后台进程执行完毕之后,master将传送整个数据文件到slave,并完成一次完全同步。
全量复制:slave服务在接收到数据库文件数据后,将其存盘并加载到内存中
增量复制:Master 继续将新的所有收集到的修改命令依次传给slave,完成同步
但是只要是重新连接master,一次完全同步(全量复制)将被自动执行! 我们的数据一定可以在从机中看到!
层层链路
此时6380还是从节点
如果没有老大了,这个时候能不能选择一个老大出来呢? 手动!
谋朝篡位
如果主机断开了连接,我们可以使用 slaveof no one
让自己变成主机!其他的节点就可以手动连接到最新的这个主节点(手动)!如果这个时候老大修复了,那就重新连接!
4、哨兵模式
(自动选举老大的模式)
概述
主从切换技术的方法是:当主服务器宕机后,需要手动把一台从服务器切换为主服务器,这就需要人工干预,费事费力,还会造成一段时间内服务不可用。这不是一种推荐的方式,更多时候,我们优先考虑哨兵模式。Redis从2.8开始正式提供了Sentinel(哨兵) 架构来解决这个问题
谋朝篡位的自动版,能够后台监控主机是否故障,如果故障了根据投票数自动将从库转换为主库。
哨兵模式是一种特殊的模式,首先Redis提供了哨兵的命令,哨兵是一个独立的进程,作为进程,它会独立运行。其原理是哨兵通过发送命令,等待Redis服务器响应,从而监控运行的多个Redis实例。
这里的哨兵有两个作用
- 通过发送命令,让Redis服务器返回监控其运行状态,包括主服务器和从服务器。
- 当哨兵监测到master宕机,会自动将slave切换成master,然后通过发布订阅模式通知其他的从服务器,修改配置文件,让它们切换主机。
然而一个哨兵进程对Redis服务器进行监控,可能会出现问题,为此,我们可以使用多个哨兵进行监控。各个哨兵之间还会进行监控,这样就形成了多哨兵模式。
假设主服务器宕机,哨兵1先检测到这个结果,系统并不会马上进行failover[故障转移]过程,仅仅是哨兵1主观的认为主服务器不可用,这个现象成为主观下线。当后面的哨兵也检测到主服务器不可用,并且数量达到一定值时,那么哨兵之间就会进行一次投票,投票的结果由一个哨兵发起,进行failover操作。切换成功后,就会通过发布订阅模式,让各个哨兵把自己监控的从服务器实现切换主机,这个过程称为客观下线。
测试
我们目前的状态是 一主 (6379)二从(6380,6381)
我们目前的状态是 一主 (6379)二从(6380,6381)
新建哨兵的配置文件sentinel.conf
1
sentinel monitor myredis 127.0.0.1 6380 1
启动哨兵
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38root@VM-16-10-ubuntu:/usr/local/bin# redis-sentinel myconfig/sentinel.conf
2239978:X 21 Sep 2024 16:56:34.971 # WARNING Memory overcommit must be enabled! Without it, a background save or replication may fail under low memory condition. Being disabled, it can also cause failures without low memory condition, see https://github.com/jemalloc/jemalloc/issues/1328. 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.
2239978:X 21 Sep 2024 16:56:34.971 * oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
2239978:X 21 Sep 2024 16:56:34.971 * Redis version=7.4.0, bits=64, commit=00000000, modified=1, pid=2239978, just started
2239978:X 21 Sep 2024 16:56:34.971 * Configuration loaded
2239978:X 21 Sep 2024 16:56:34.972 * Increased maximum number of open files to 10032 (it was originally set to 1024).
2239978:X 21 Sep 2024 16:56:34.972 * monotonic clock: POSIX clock_gettime
_._
_.-``__ ''-._
_.-`` `. `_. ''-._ Redis Community Edition
.-`` .-```. ```\/ _.,_ ''-._ 7.4.0 (00000000/1) 64 bit
( ' , .-` | `, ) Running in sentinel mode
|`-._`-...-` __...-.``-._|'` _.-'| Port: 26379
| `-._ `._ / _.-' | PID: 2239978
`-._ `-._ `-./ _.-' _.-'
|`-._`-._ `-.__.-' _.-'_.-'|
| `-._`-._ _.-'_.-' | https://redis.io
`-._ `-._`-.__.-'_.-' _.-'
|`-._`-._ `-.__.-' _.-'_.-'|
| `-._`-._ _.-'_.-' |
`-._ `-._`-.__.-'_.-' _.-'
`-._ `-.__.-' _.-'
`-._ _.-'
`-.__.-'
2239978:X 21 Sep 2024 16:56:34.980 * Sentinel new configuration saved on disk
2239978:X 21 Sep 2024 16:56:34.981 * Sentinel ID is dad236bacdf1f7ef1af264a564be5fc82681fa06
2239978:X 21 Sep 2024 16:56:34.981 # +monitor master myredis 127.0.0.1 6381 quorum 1
2239978:X 21 Sep 2024 16:57:25.052 # +sdown master myredis 127.0.0.1 6381
2239978:X 21 Sep 2024 16:57:25.052 # +odown master myredis 127.0.0.1 6381 #quorum 1/1
2239978:X 21 Sep 2024 16:57:25.052 # +new-epoch 1
2239978:X 21 Sep 2024 16:57:25.052 # +try-failover master myredis 127.0.0.1 6381
2239978:X 21 Sep 2024 16:57:25.061 * Sentinel new configuration saved on disk
2239978:X 21 Sep 2024 16:57:25.061 # +vote-for-leader dad236bacdf1f7ef1af264a564be5fc82681fa06 1
2239978:X 21 Sep 2024 16:57:25.061 # +elected-leader master myredis 127.0.0.1 6381
2239978:X 21 Sep 2024 16:57:25.061 # +failover-state-select-slave master myredis 127.0.0.1 6381
2239978:X 21 Sep 2024 16:57:25.133 # -failover-abort-no-good-slave master myredis 127.0.0.1 6381
2239978:X 21 Sep 2024 16:57:25.223 * Next failover delay: I will not start a failover before Sat Sep 21 17:03:26 2024这个时候master宕机了话,这个时候就会从从机中随机选择一个服务器! (这里面有一个投票算法!)
也就是之前配置文件中的所写将会变成master
并且如果主机此时回来了,只能归并到新的主机下,当做从机,这就是哨兵模式的规则
哨兵模式
优点:
- 哨兵集群,基于主从复制模式,所有的主从配置优点,它全有
- 主从可以切换,故障可以转移,系统的可用性就会更好
- 哨兵模式就是主从模式的升级,手动到自动,更加健壮!
缺点:
- Redis 不好在线扩容的,集群容量一旦到达上限,在线扩容就十分麻烦
- 实现哨兵模式的配置其实是很麻烦的,里面有很多选择
哨兵模式的全部配置
1 | # Example sentinel.conf |
十二、redis穿透和雪崩
在这里我们不会详细的区分析解决方案的底层!
Redis缓存的使用,极大的提升了应用程序的性能和效率,特别是数据查询方面。但同时,它也带来了一些问题。其中,最要害的问题,就是数据的一致性问题,从严格意义上讲,这个问题无解。如果对数据的一致性要求很高,那么就不能使用缓存。
另外的一些典型问题就是,缓存穿透、缓存雪崩和缓存击穿。目前,业界也都有比较流行的解决方案。
1、缓存穿透(查不到)
概念
缓存穿透的概念很简单,用户想要查询一个数据,发现redis内存数据库没有,也就是缓存没有命中,于是向持久层数据库查询。发现也没有,于是本次查询失败。当用户很多的时候,缓存都没有命中(秒杀!),于是都去请求了持久层数据库。这会给持久层数据库造成很大的压力,这时候就相当于出现了缓存穿透。
解决方案
1.布隆过滤器
布隆过滤器是一种数据结构,对所有可能查询的参数以hash形式存储,在控制层先进行校验,不符合则丢弃,从而避免了对底层存储系统的查询压力;
2.缓存空对象
当存储层不命中后,即使返回的空对象也将其缓存起来,同时会设置一个过期时间,之后再访问这个数据将会从缓存中获取,保护了后端数据源;
但是这种方法会存在两个问题:
- 如果空值能够被缓存起来,这就意味着缓存需要更多的空间存储更多的键,因为这当中可能会有很多的空值的键
- 即使对空值设置了过期时间,还是会存在缓存层和存储层的数据会有一段时间窗口的不一致,这对于需要保持一致性的业务会有影响
2、缓存击穿
概述(热点key过期)
这里需要注意和缓存击穿的区别,缓存击穿,是指一个key非常热点,在不停的扛着大并发,大并发集中、对这一个点进行访问,当这个key在失效的瞬间,持续的大并发就穿破缓存,直接请求数据库,就像在一个屏障上凿开了一个洞。
当某个key在过期的瞬间,有大量的请求并发访问,这类数据一般是热点数据,由于缓存过期,会同时访问数据库来查询最新数据,并且回写缓存,会导使数据库瞬间压力过大
解决方案
1.设置热点数据永不过期
从缓存层面来看,没有设置过期时间,所以不会出现热点 key 过期后产生的问题
2.加互斥锁
分布式锁:使用分布式锁,保证对于每个key同时只有一个线程去查询后端服务,其他线程没有获得分布式锁的权限,因此只需要等待即可。这种方式将高并发的压力转移到了分布式锁,因此对分布式锁的考验很大。
3、缓存雪崩(缓存集中过期,宕机)
概念
缓存雪崩,是指在某一个时间段,缓存集中过期失效。
产生雪崩的原因之一,比如在写本文的时候,马上就要到双十二零点,很快就会迎来一波抢购,这波商品时间比较集中的放入了缓存,假设缓存一个小时。那么到了凌晨一点钟的时候,这批商品的缓存就都过期了。而对这批商品的访问查询,都落到了数据库上,对于数据库而言,就会产生周期性的压力波峰。于是所有的请求都会达到存储层,存储层的调用量会暴增,造成存储层也会挂掉的情况。
其实集中过期,倒不是非常致命,比较致命的缓存雪崩,是缓存服务器某个节点宕机或断网。因为自然形成的缓存雪崩,一定是在某个时间段集中创建缓存,这个时候,数据库也是可以顶住压力的。无非就是对数据库产生周期性的压力而已。而缓存服务节点的宕机,对数据库服务器造成的压力是不可预知的,很有可能瞬间就把数据库压垮。
解决方案
1.redis高可用
这个思想的含义是,既然redis有可能挂掉,那我多增设几台redis,这样一台挂掉之后其他的还可以继续工作,其实就是搭建的集群。(异地多活!)
2.限流降级
这个解决方案的思想是,在缓存失效后,通过加锁或者队列来控制读数据库写缓存的线程数量。比如对某个key只允许一个线程查询数据和写缓存,其他线程等待。
3.数据预热
数据加热的含义就是在正式部署之前,我先把可能的数据先预先访问一遍,这样部分可能大量访问的数据就会加载到缓存中。在即将发生大并发访问前手动触发加载缓存不同的key,设置不同的过期时间,让缓存失效的时间点尽量均匀。