redis

背景

例如，08年北京奥运，网上售票崩溃，12306购票崩溃

像一些网站的崩溃，都是因为，高并发，用户量比较大，而当时使用的是关系型数据库。关系型数据库，存在于磁盘中，那么要到cpu中计算需要

cpu—catch —-内存—–磁盘

而磁盘的io性能较低，

关系型数据库的数据逻辑关系复杂，不是适合做大规模集群

解决思路

降低磁盘IO次数，越低越好

去除数据关系。

故出现了在内存中存储，且不存数据关系，这就是Nosql，泛指非关系型的数据库，是对关系型数据库的补充。

常见的Nosql数据库

redis，hbase，MongoDB，memcache

Redis特征

1.数据间没有必然的关联关系。

2.内部采用单线程机制进行工作。

3.高性能。

4.多数据类型支持 String，list, hash, set, sorted_set

5.持久化支持，可以进行数据灾难恢复

Redis应用

为热点数据加速查询（主要场景），如热点商品，热点新闻，热点资讯
任务队列，秒杀，抢购，购票排队
即时信息查询，如各种排行帮，网站访问统计，公交到站信息，在线人数信息，设备信号等
时效信息控制，如验证码控制，投票控制
分布式数据共享，分布式集群架构中session分离
消息队列
分布式锁

Redis基本操作

功能性命令

信息添加

--设置Key，value 数据
--set key value
set name zhangsan

信息查询

--查询命令  如果空值 查询出 nil值
--get key
get name 
Copy

清除屏幕信息

在window

--清除屏幕
clear
Copy

帮助信息查询

获取命令帮助

--help 命令名 可以help 加群组
help get
Copy

退出指令

quit
exit
<ESC>

Redis的数据类型

业务数据的特殊性

1.原始业务功能设计

秒杀
618活动
双十一
排队购票

2.运营平台监控到的突发高频访问数据

突发时政要闻，娱乐大瓜

3.高频复杂的统计数据

在线人数
投票排行榜

4.系统功能优化升级

单服务升级
对tocken的管理

Redis 是基于上述的功能需要设计出数据类型，推出了主要的5种数据类型。也是常用的五种数据类型，但其中数据类型并不止五种。

Redis 自身是一个Map，其中的所有数据都是采用Key：value的形式进行存储的

数据类型指的是存储的数据类型 Value部分，key部分永远都是字符串

String 类型

存储的数据：单个数据，最简单的数据存储类型，也是最常用的数据存储类型

存储数据的格式：一个存储空间一个数据

存储内容：字符串，若字符串按照整数的形式展示、可以作为数字操作使用

String数据操作

--添加修改数据
set key value
--获取数据
get key
--删除数据
del key
--添加多个数据 
mset  key1 value1 key2 value2 key 
--获取多个数据
mget  key1 key2
--获取数据字符个数
strlen  key
--追加信息，有就追加，没有就新建
append key value
--键key不存在时将key的值设置为value 若存在则不变
setnx key value
Copy

对于单数据操作和多数据操作，多数据操作节省，数据发送传递时间。

String类型数据扩展

数值增长

--增长指令，只有当value为数字时才能增长
incr key  
incrby key increment  
incrbyfloat key increment 

--减少指令，有当value为数字时才能减少
decr key  
decrby key increment
Copy

按照数值进行操作，如果原始数据无法转换成数值，或超越了redis数值的上限范围，将报错。 9223372036854775807（java中long型数据最大值，Long.MAX_VALUE）

设置数据生命周期

--设置时间 为values秒过期
setex  key seconds value

--设置时间 为values毫秒过期
psetex key milliseconds value
Copy

后续的向相同的key中放值会覆盖他的值和过期时间，

数据最大的存储量 512MB

String类型业务场景

场景一：“最强女生”，启动海选投票，只能通过微信投票，每个微信号每4个小时只能投1票。

主页高频访问信息显示控制，例如新浪微博大V主页显示粉丝数与微博数。

key的设置约定，在数据库中的表明：主键名：主键值：字段名

Hash类型

对一系列存储的数据进行编组，方便管理，典型应用存储对象信息。

一个存储空间保存多个键值对数据，

底层使用哈希表结构实现数据存储

hash数据操作

--添加数据
hset key field value
--获取数据
hget key field 

hgetall key
--删除数据
hdel key field
Copy

hash操作实例

--添加多个
hmset key field1 value1 field2 value2

--获取多个
hmget key field1 field2

--获取哈希表中字段的数量
hlen key

--获取哈希表中是否存在指定的字段
hexists key field
Copy

hash操作实例2

hash类型数据扩展操作

--获取哈希表中所有的字段名或字段值
hkeys key
hvals key

--设置指定字段的数值数据增加指定范围的值
hincrby key field increment
hincrbyfloat key field increment

--指定字段如果不存在，就增加，存在就不变，
hsetnx key field value
Copy

hash操作实例3

hash类型数据操作注意事项

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

hash类型应用场景

电商购物车设计与实现

将用户的id当成key

将商品编号当成 field

将商品购买数量当成 value，对value进行操作

取值 hget，

增加 hincrby

设值 hset

删除 hdel

全选 hgetall

总量 hlen

清空购物车删除key

购物车模型

思考，当前设计是否增加购物车的呈现，

我们看上面的这张图时，我们主要看的商品信息，而不是数量，用户真正看的是，商品，然后再下单。商品的信息还要去查询数据库。

改进，我们将商品记录保存成两条field

field1:保存购买数量， value 数值

field2:保存用于购物车中显示的信息，文字，图片，商家

value json存储

不过一般购物车不持久化

抢购的设计

抢购设计

商家id当成key

参与抢购的商品id当成field

参与抢购商品的数量当成value

抢购时使用降值得方式控制产品数量，

尽量不要让redis去做业务是否存在得判断

String整体型，读为主

hash分块，更新比较灵活

LIst类型

数据存储需求：存储多个数据，并对数据进入存储空间得数据进行区分。

需要得存储结构：一个存储空间保存多个数据，且通过数据可以体现进入顺序

底层使用双向链表存储结构进行实现

List数据操作

--添加修改数据 左添加，右添加
lpush key value1  [value2]
rpush key value1	[value2]

--获取数据
lrange key start stop
lindex key index
llen key

--获取并移除数据
lpop key
rpop key
Copy

List操作

体会一下左进得顺序。

List数据操作扩展

规定时间获取并移除数据

blpop key1 [key2] timeout
brpop key1 [key2] timeout
Copy

再timeout 时间内取数据，有数据就取无数据就等待，

List数据业务场景

微信朋友圈点赞，要求按照点赞顺序显示点赞好友信息，如果取消点赞，移除对应好友信息。如果取消点赞，则移除指定数据

微信朋友圈

--移除指定数据
lrem key count value
Copy

注意这个数量，因为队列中得数列可以有重复值故要制定其个数，l是left从左边开始删除，count的值为value的元素

list类型数据操作注意事项

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

Set类型

存储需求:存储大量数据，再查询方面提供更高的效率

需要的结构：能保存大量的数据结构，高效的内部的存储机制，便与查询。

set类型：与hash存储结构完全相同，仅存储键，不存储值，

Set的数据操作

--添加数据
sadd key member1 [member2]
--获取全部数据
smembers key
--删除数据
srem key member1 [member2]
--获取集合数据总量
scard key
--判断集合中是否包含指定数据
sismember key member
Copy

捕获2

Set数据操作扩展

随机推荐

每位用户首次使用今日头条时会设置3项爱好的内容，但是后期为了增加用户的活跃度、兴趣点，必须让用户对其他信息类别产生兴趣，增加客户留存度，如何实现。

系统分析出各类最新的数据或最热的信息条目组成set集合

随机条选其中部分信息

配合用户关注的信息分类中的热点信息，组合抽取成全信息集合，例如:前6条你关注的第7条随机抽取的热点信息。

--随机获取集合中指定数量的数据
srandmember key [count]

--随机获取集合中的某个数据并将该数据移出集合
spop key
Copy

--求两个集合的交、并、差集
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
Copy

Set类型操作注意事项

set类型不允许数据重复，如果添加的的数据已经存在将只保存一份

Set类型应用场景

权限控制

这个场景只为举例，具体的权限控制，有具体的权限框架。

解决方案

依赖set集合数据不重复的特征，依赖set集合hash存储结构特征完成数据过滤与快速查询
根据用户id获取用户所有角色
根据用户所有角色获取用户所有操作权限放入set集合
根据用户所有角色获取用户所有数据全选放入set集合

网站的访问数据

解决方案

利用set集合的数据去重，记录各种访问数据
建立String类型数据，利用incr统计日常访问量（PV）
建立set模型记录不同cookie（UV）
建立set模型，记录不同IP数量（IP)

sorted_set类型

存储需求：数据排序有利于数据的有效展示，需要一种可以提供自身特征进行排序的方式

存储结构，在set存储结构基础上添加可排序字段。根据排序字段进行排序。

sorted_set基本操作

--添加数据
zadd key score1 member1 [score2 member2]

--获取全部数据
zrange key start stop [withscores]
zrevrange key start stop [withscores]

--删除数据
zrem key member [member ...]
Copy

--按照条件获取数据
zrangebyscore key min max [withscores] [limit]
zrevrangebyscore key max min [withscores]

--条件删除数据
zremrangebyrank key start stop
zremrangebyscore key min max 
Copy

注意

min和max用于限定搜索条件
start和stop 用于限定查询范围，作用与索引

捕获11

--获取集合数据总量
zcard key
zcount key min max

--集合交、并操作
zinterstore destination numkeys key [key ]
zunionstore destination numkeys key  [key]
Copy

numkeys的值是后面key得个数，必须匹配。
注意交操作：只有都有的适合才会交，他默认将都有的值加起来了。
可以通过帮助命令来查看，求max值，min值

捕获13

sorted_set 类型扩展操作

业务场景

活跃度统计，亲密度排序，榜单类

统计数量，排序

为所有参加排名得资源建立排序依据，根据排序后得结果获取索引

--获取数据对应的索引
zrank key member
zrevrank key member	

--score值获取与修改
zscore key member
zincrby key increment member
Copy

捕获14

sorted_set注意事项

score 保存的数据存储空间是64位,所以有范围。正负九百万亿
score保存的数据也可以是一个双精度的double值，基于双精度浮点数的特征，可能会丢失精度，使用时侯要慎重
sorted_set底层存储还是基于set结构的，因此数据不能重复，如果重复添加相同的数据，score值将被反复覆盖，保留最后一次修改的结果

sorted_set应用场景

定时任务执行管理，任务过期管理

体验VIP，云盘体验VIP，当VIP体验到期后怎么管理。

解决方案

对于基于时间线限定的任务处理，将处理时间记录位score值，利用排序功能区分处理的先后顺序
记录下一个要处理的事件，当到期后处理对应的任务，移除redis中的记录，并记录下一个要处理的时间
当新任务加入时，判定并更新当前下一个要处理的任务时间
为提升sorted_set的性能，通常将任务根据特征存储成若干个sorted_set.例如1小时内，1天内，年度等，操作时逐渐提升，将即将操作的若干个任务纳入到1小时内处理队列中
获取当前系统时间

--获取当前时间，获取秒，毫秒。
time
Copy

任务或消息权重设定应用

对于带有权重的任务，优先处理权重高的任务，采用score记录权重即可

捕获15

注意：这样可能无法保证原子性。这里再删除要用到事务。

KEY通用操作

key基本操作

--删除指定key
del key

--获取key是否存在
exists key

--获取key的类型
type key

--为指定key设置有效期
expire key seconds
pexpire key milliseconds
expireat key timestamp
pexpireat key milliseconds-timestamp

--获取key的有效期
ttl key    
pttl key

--切换key从失效性转换为永久性
persist key
Copy

会返回三种值，当该key不存在时，返回-2，当该key未被设置有效期时，返回-1，当该key设置有有效期时，返回剩余时间。

当一个key被设置有效期后，有效期结束后，该key值将会被清空。

--查询key
keys pattern 
* --匹配任意数量的任意符号
？ --匹配一个任意符号
[]   --匹配一个指定符号

Copy

--为key改名
rename key newkey
renamenx key newkey

--对所有key排序，再list，set，zset中。
sort

--其他key的通用操作，可以使用tab键进行切换
help @generic
Copy

改名操作，谨慎操作，如果错误改名，容易覆盖已有的值。

redis中的数据库

当数据量越来越大的时候，key值难免会发生重复，另外各种类型混杂在一起，易出现冲突。为此redis为每个服务提供了16个数据库，编号0到15，每个数据库之间数据相互独立。

--切换数据库 0-15
select index

--其他操作
quit
ping
echo massage

--移动数据，必须保证目的数据库没有该数据
move key db

--查看库中数据总量
dbsize
Copy

捕获17

默认库是0库，使用move 操作是剪切，如果目标库中有相应的key则移动失败。

--库中元素数量
dbsize
--清除库中的所有元素
flushdb
--清除redis所有库中的所有元素
flushall
Copy

Jedis

JAVA操作Redis需要导入jar或引入Maven依赖

1.连接redis

2.操作redis

3.关闭连接

//参数为Redis所在的ip地址和端口号
Jedis jedis = new Jedis(String host, int port)
//操作redis的指令和redis本身的指令几乎一致,仅在此列出string和list
jedis.set(String key, String value);
jedis.lpush(String key, String value);
//关闭连接。
jedis.close();
Copy

编程案例

使用redis 控制不同用户，有不同免费使用次数。使用最大值控制异常减少次数判断。

public class Service {

    String sa;
    int num;

    public Service(String sa, int num) {
    this.sa=sa;
    this.num=num;
    }

    public void business(Long val) {

        System.out.println("业务执行:"+val);
    }
    public void Service() {
        Jedis jedis = new Jedis("127.0.0.1", 6379);
        String value = jedis.get("compid" + sa);
        try {

            if (value == null) {
                jedis.setex("compid" + sa, 60, Long.MAX_VALUE - num + "");
            } else {
                Long incr = jedis.incr("compid" + sa);
                business(incr-Long.MAX_VALUE+num);
            }
        } catch (Exception e) {
            System.out.println("请提升级别");
        } finally {
            jedis.close();
        }

    }
}
class MyThread extends Thread {
    Service sc;
    MyThread(String sa,int num){
     sc=new Service(sa,num);
    }


    @Override
    public void run() {
        while (true) {
            sc.Service();

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class main{
    public static void main(String[] args) {
        MyThread myThread1 =new MyThread("chuji",10);
        MyThread myThread2=new MyThread("gaoji",20);
        myThread1.start();
        myThread2.start();
    }
}

Copy

捕获18

jedis工具类

public class JedisUtil {
	private static Jedis jedis = null;
	private static String host = null;
	private static int port;
	private static int maxTotal;
	private static int maxIdle;

	//使用静态代码块，只加载一次
	static {
		//读取配置文件
		ResourceBundle resourceBundle = ResourceBundle.getBundle("redis");
		//获取配置文件中的数据
		host = resourceBundle.getString("redis.host");
		port = Integer.parseInt(resourceBundle.getString("redis.port"));
		//读取最大连接数
		maxTotal = Integer.parseInt(resourceBundle.getString("redis.maxTotal"));
		//读取最大活跃数
		maxIdle = Integer.parseInt(resourceBundle.getString("redis.maxIdle"));
		JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
		jedisPoolConfig.setMaxTotal(maxTotal);
		jedisPoolConfig.setMaxIdle(maxIdle);
		//获取连接池
		JedisPool jedisPool = new JedisPool(jedisPoolConfig, host, port);
		jedis = jedisPool.getResource();
	}

	public Jedis getJedis() {
		return jedis;
	}
}
Copy
redis.host=127.0.0.1
redis.port=6379
redis.maxTotal=30
redis.maxIdle=10
Copy

Redis持久化

利用永久性存储介质将数据进行保存，在特定的时间将保存的数据进行恢复的工作机制称为持久化。

防止数据丢失。

持久化过程存什么

将当前数据状态进行保存，快照形式，存储数据结果，关注点在数据，RDB

将数据的操作过程进行保存，日志形式，存储操作过程，存储格式复杂，关注点在数据的操作过程，AOF

捕获19

RDB

RDB启动方式—save

命令

save	
Copy

执行完之后，会在data文件夹中生成rdb文件，

RDB配置相关命令

在配置文件中改写。

dbfilename dump.rdb
- 说明：设置本地数据库文件名，默认值为 dump.rdb
- 经验：通常设置为dump-端口号.rdb
dir
- 说明：设置存储.rdb文件的路径
- 经验：通常设置成存储空间较大的目录中，目录名称data
rdbcompression yes
- 说明：设置存储至本地数据库时是否压缩数据，默认为 yes，采用 LZF 压缩
- 经验：通常默认为开启状态，如果设置为no，可以节省 CPU 运行时间，但会使存储的文件变大（巨大）
rdbchecksum yes
- 说明：设置是否进行RDB文件格式校验，该校验过程在写文件和读文件过程均进行
- 经验：通常默认为开启状态，如果设置为no，可以节约读写性过程约10%时间消耗，但是存储一定的数据损坏风险

Save指令工作原理

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

捕获20

bgsave 指令工作原理

bgsave
Copy

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

捕获21

调用fork函数生成子进程。

自动保存save 配置

配置

在conf文件中进行配置

save second changes 
Copy

满足限定时间范围内key的变化数量达到指定数量即进行持久化

second：监控时间范围
changes：监控key的变化量

控制频度的，时间周期，如果该时间周期过完，未达到变化量，重新计时计数，周期达到，存所有改变。

save配置要根据实际业务情况进行设置，频度过高或过低都会出现性能问题，结果可能是灾难性的
save配置中对于second与changes设置通常具有互补对应关系（一个大一个小），尽量不要设置成包含性关系
save配置启动后执行的是bgsave操作

三种对比

sava配置实际上是bgsava故没有写bgsava

捕获23

可以在关服务器之前使用 shutdown save

RDB优缺点

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

AOF

基于RDB的缺点，提出解决方法

1、不写全数据，仅记录部分数据。

2、改记录数据未记录操作过程

3、对所有操作均进行记录，排除丢失数据的风险

AOF概念

AOF(append only file)持久化：以独立日志的方式记录每次写命令，重启时再重新执行AOF文件中命令，以达到恢复数据的目的。与RDB相比可以简单描述为改记录数据为记录数据产生的过程
AOF的主要作用是解决了数据持久化的实时性，目前已经是Redis持久化的主流方式

AOF写数据过程

捕获24

AOF写数据的三种策略

always（每次）

每次写入操作均同步到AOF中，数据零误差，性能低

everysec(每秒)

每秒将缓冲区的指令同步到AOF中，数据的准确性较高，性能较高，

no（系统控制）

有操作系统控制，每次同步到AOF文件周期不可控。

AOF配置

--是否开启AOF持久化功能，默认为不开启状态
appendonly yes|no
--指定策略
appendfsync always|everysec|no
--配置存储路径
dir
Copy

持久化后会在data文件夹中出现.aof文件。

AOF重写

aof内部的一些机制。

作用

降低磁盘占用量，提高磁盘利用率
提高持久化效率，降低持久化写时间，提高IO性能
降低数据恢复用时，提高数据恢复效率

规则

进程内已超时的数据不再写入文件
忽略

无效指令

，重写时使用进程内数据直接生成，这样新的AOF文件

只保留最终数据的写入命令
- 如del key1、 hdel key2、srem key3、set key4 111、set key4 222等
对同一数据的多条写命令合并为一条命令
- 如lpush list1 a、lpush list1 b、 lpush list1 c 可以转化为：lpush list1 a b c
- 为防止数据量过大造成客户端缓冲区溢出，对list、set、hash、zset等类型，每条指令最多写入64个元素

如何使用

--手动重写
bgrewriteaof
--自动重写
auto-aof-rewrite-min-size size 
auto-aof-rewrite-percentage percentage
Copy

接上图三。在进行3-3步骤后被替换为重写后的aof

缓冲策略

AOF缓冲区同步文件策略，由参数appendfsync控制

write操作会触发延迟写（delayed write）机制，Linux在内核提供页缓冲区用来提高硬盘IO性能。write操作在写入系统缓冲区后直接返回。同步硬盘操作依赖于系统调度机制，列如：缓冲区页空间写满或达到特定时间周期。同步文件之前，如果此时系统故障宕机，缓冲区内数据将丢失。
fsync针对单个文件操作（比如AOF文件），做强制硬盘同步，fsync将阻塞知道写入硬盘完成后返回，保证了数据持久化

RDB和AOF

捕获28

对数据非常

敏感

建议使用默认的

AOF

持久化方案
- AOF持久化策略使用everysecond，每秒钟fsync一次。该策略redis仍可以保持很好的处理性能，当出现问题时，最多丢失0-1秒内的数据。
- 注意：由于AOF文件存储体积较大，且恢复速度较慢
数据呈现

阶段有效性

，建议使用RDB持久化方案
- 数据可以良好的做到阶段内无丢失（该阶段是开发者或运维人员手工维护的），且恢复速度较快，阶段点数据恢复通常采用RDB方案
- 注意：利用RDB实现紧凑的数据持久化会使Redis降的很低
综合比对
- RDB与AOF的选择实际上是在做一种权衡，每种都有利有弊
- 如不能承受数分钟以内的数据丢失，对业务数据非常敏感，选用AOF
- 如能承受数分钟以内的数据丢失，且追求大数据集的恢复速度，选用RDB
- 灾难恢复选用RDB
- 双保险策略，同时开启 RDB 和 AOF，重启后，Redis优先使用 AOF 来恢复数据，降低丢失数据

持久化场景

这些场景，视频中大部分都分散在每个数据类型中的应用场景中，用以熟练理解数据类型。视频传送门见顶部。

捕获29

Redis事务

Redis事务的定义

redis事务就是一个命令执行的队列，将一系列预定义命令包装成一个整体（一个队列）。当执行时，一次性按照添加顺序依次执行，中间不会被打断或者干扰

事务的操作

--开启事务，执行此命令后，所有的命令都会加入到事务队列中直到事务开启
multi

--执行事务  设定事务的结束位置，同时执行事务。与multi成对出现，成对使用
exec

--取消事务  终止当前事务的定义，在multi之后，exec之前
discard 
Copy

捕获30

事务的工作流程

捕获31

事务操作的注意事项

如果在定义事务的过程中，语法格式输入错误，

本次定义全部失效。

指命令格式正确，但是无法正确的执行。例如对list进行incr操作

能够正确运行的命令会执行，运行错误的命令不会被执行

注意：已经执行完毕的命令对应的数据不会自动回滚，需要程序员自己在代码中实现回滚。

锁

基于特定条件的事务执行

业务场景补货不重复

天猫双11热卖过程中，对已经售罄的货物追加补货，4个业务员都有权限进行补货。补货的操作可能是一系列的操作，牵扯到多个连续操作，如何保障不会重复操作？

业务分析

多个客户端有可能同时操作同一组数据，并且该数据一旦被操作修改后，将不适用于继续操作
在操作之前锁定要操作的数据，一旦发生变化，终止当前操作

解决方案

对key添加监视锁，在执行前key发生变化，终止执行，

即使你监控的是name zs，在事务里添加的是 age 12，当你更改name的值，事务添加age 12也会失效

--监控 key1
watch key1 [key2……]

--取消监控
unwatch
Copy

业务场景不超卖

本次补货已经将库存全部清空，如何避免最后一件商品不被多人同时购买？【超卖问题】

业务分析

使用watch监控一个key有没有改变已经不能解决问题，此处要监控的是具体数据
虽然redis是单线程的，但是多个客户端对同一数据同时进行操作时，如何避免不被同时修改？

解决方案

--使用setnx设置公共锁
setnx lock-key value	
Copy

利用setnx命令的返回值特征，有值则返回设置失败，无值则返回设置成功

对于返回设置成功的，拥有控制权，进行下一步的具体业务操作
对于返回设置失败的，不具有控制权，排队或等待
操作完毕通过del lock-key操作释放锁

业务场景死锁

依赖分布式锁的机制，某个用户操作时对应客户端宕机，且此时已经获取到锁。

业务分析

由于锁操作由用户控制加锁解锁，必定会存在加索后未解锁

解锁操作不能只依赖于用户，

解决方案

--设置锁的时限
expire lock-key second
pexpire lock-key milliseconds
Copy

由于操作通常都是微秒或毫秒级，因此该锁定时间不宜设置过大。具体时间需要业务测试后确认。

例如：持有锁的操作最长执行时间127ms，最短执行时间7ms。
测试百万次最长执行时间对应命令的最大耗时，测试百万次网络延迟平均耗时
锁时间设定推荐：最大耗时120%+平均网络延迟110%
如果业务最大耗时<<网络平均延迟，通常为2个数量级，取其中单个耗时较长即可

Redis中的删除策略

数据删除策略

定时删除
惰性删除
定期删除

时效性数据的存储结构

捕获32

在内存占用和cpu占用找一个平衡。

定时删除

创建一个定时器，当key设置有过期时间，且过期时间到达时，由定时器任务立即执行对键的删除操作

捕获33

优点：节约内存

缺点：可能cpu压力大，要删除数据时，无论此时cpu的负载多高，均占用

用cpu换内存

惰性删除

数据到达过期时间，不做处理，等下次访问数据时，如果未过期，返回数据，如果已过期，删除返回不存在，

捕获34

优点：节约cpu，发现必须删除才会删除

缺点：内存压力比较大，出现长期占用内存的数据

拿空间换cpu性能

定期删除

特点1：cpu性能占用设置有峰值，检测频度可以自定义设置

特点2：内存压力不是很大，长期占用内存的冷数据将被清除

逐出算法

当新数据进入redis时，内存不足怎么办。

redis在执行每个命令前，会调用freeMemoryIfNeeded（）检测内存是否充足，如果内存不满足新加入数据的最低要求，redis要临时删除一些数据为当前指令清理存储空间，清理数据的策略称为逐出算法。

注意：逐出数据的过程不是100%能够清理出足够可使用的内存空间，如果不成功则反复执行，反复执行不成功，则报错

--最大可使用内存配置 0不限制，生产环境通常50%以上
maxmemory

--每次选取待删除的个数，随机获取数据的方式
maxmemory-samples

--删除策略  达到最大内存后删除方法
maxmemory-policy
Copy

LRU：最长时间没被使用的数据

LFU：一段时间内使用次数最少的数据

数据逐出策略配置依据

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

捕获35

服务器基础配置

--设置服务器以守护进程的方式运行
daemonize yes|no
--绑定主机地址
bind 127.0.0.1
--设置服务器端口号
port 6379
--设置数据库数量
databases 16
--设置服务器以指定日志记录级别
loglevel debug|verbose|notice|warning
-- 日志记录文件名
logfile 端口号.log

--设置同一时间最大客户端连接数，默认 0无限制。当客户端连接到达上限，Redis会关闭新的连接
maxclients 0
--客户端闲置等待最大时长，达到最大值后关闭连接。如需关闭该功能，设置为 0
timeout 300
--导入并加载指定配置文件信息，用于快速创建redis公共配置较多的redis实例配置文件，便于维护
include /path/server-端口号.conf
Copy

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

Redis高级数据类型

这几种类型主要是解决某个业务场景的业务类型。

Bitmaps

其实这个就是string 中二进制位的操作接口。

利用二进制位保存数据，0否，1是，出现这种能够充分利用内存的结构。

--获取指定位上的值
getbit key offset

--设置指定位上的值  value只能是0或者是1
setbit key offset value
Copy

扩展操作

对指定key按位进行交、并、非、操作，并将结构

--对指定key按位进行  and：交  or：并  not：非xor：异或
bitop op destKey key1 [key2...]
   

--统计指定key中1的数量
bitcount key [start end]
Copy

如果不指定开始结束，就统计全部

HyperLogLog

统计不重复的数据的数量

例：统计独立UV

原始方案：set 存储每个用户id

基数：数据集去重后的元素个数。

HyperLogLog是做基数统计的

--添加数据
pfadd key value

--合并操作
pfmerge destkey sourcekey [sourcekey...]

--统计数据
pfcount key1 key2....
Copy

捕获36

用于进行基数统计，不是集合，不保存数据，只记录数量而不是具体数据
核心是基数估算算法，最终数值存在一定误差
误差范围：基数估计的结果是一个带有 0.81% 标准错误的近似值
耗空间极小，每个hyperloglog key占用了12K的内存用于标记基数
pfadd命令不是一次性分配12K内存使用，会随着基数的增加内存逐渐增大
Pfmerge命令合并后占用的存储空间为12K，无论合并之前数据量多少

GEO

地图信息操作，点与点数据的关联操作。注意他要计算他，假设两点间是水平的。

--添加坐标点
geoadd key longitude latitude member [longitude latitude member ...] 

--获取坐标点

geopos key member [member ...]

--计算坐标点的距离
geodist key member1 member2 [unit]

--根据坐标求范围内数据
georadius key longitude latitude radius m|km|ft|mi [withcoord] [withdist] [withhash] [count count]

--根据点求范围内数据
georadiusbymember key member radius m|km|ft|mi [withcoord] [withdist] [withhash] [count count]

--计算hash值
geohash key member [member ...]


Copy

捕获38

Redis集群

互联网三高架构，高并发，高可用，高性能。

$$ 可用性=运行时长/全年时长 $$

追求99.999%五个九，每年崩溃时长大概在5分钟作用。

单机redis的风险与问题

问题1.机器故障

现象：硬盘故障、系统崩溃
本质：数据丢失，很可能对业务造成灾难性打击
结论：基本上会放弃使用redis.

问题2.容量瓶颈

现象：内存不足，从16G升级到64G，从64G升级到128G，无限升级内存
本质：穷，硬件条件跟不上
结论：放弃使用redis

结论：为了避免单点Redis服务器故障，准备多台服务器，互相连通。将数据复制多个副本保存在不同的服务器上，连接在一起，并保证数据是同步的。即使有其中一台服务器宕机，其他服务器依然可以继续提供服务，实现Redis的高可用，同时实现数据冗余备份。

主从复制简介

捕获39

提供数据方:master 主节点

接收数据方:slave 从节点，

需要解决的问题

数据同步。

主从复制即将master中的数据即时、有效的复制到slave中

特征：一个master可以拥有多个slave，一个slave只对应一个master

职责：

master:
- 写数据
- 执行写操作时，将出现变化的数据自动同步到slave
- 读数据（可忽略）
slave:
- 读数据
- 写数据（禁止）

主从复制作用

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

主从复制工作流程

阶段一：建立连接

建立slave到master的连接，使master能够识别slave，并保存slave端口号

步骤1：设置master的地址和端口，保存master信息

步骤2：建立socket连接

步骤3：发送ping命令（定时器任务）

步骤4：身份验证

步骤5：发送slave端口信息

捕获41

状态：

salve：保存master的地址与端口

master：保存slave的端口

总体：之间创建了连接的socket

主从连接slave连接到master

--方式一：客户端发送命令
--连接成功后，就可以测试，在主节点添加数据从节点读数据了
slaveof <masterip> <masterport>

Copy
--方式二启动时直接指定
redis-server -slaveof <masterip> <masterport>

Copy
--方式三，修改配置文件
slaveof <masterip> <masterport>
Copy

连接成功后可以在，info，查看当前节点的角色，

--主从断开连接，客户端发送命令，从
slaveof no one
Copy

slave断开连接后，不会删除已有的数据，只是不再接受master发送的数据。

授权访问

--master配置文件设置密码
requirepass <password>


--master客户端发送命令设置密码
config set requirepass <password>
config get requirepass

Copy

捕获42

主设置密码后从通过以下放式访问，

--slave客户端发送命令设置密码
auth <password>

--slave配置文件设置密码
masterauth <password>

--启动客户端设置密码
redis-cli -a <password>
Copy

阶段二：数据同步阶段工作流程

在slave初次连接master后，复制master中的所有数据到slave

将slave的数据库状态更新成master当前的数据库状态

步骤1：请求同步数据

步骤2：创建RDB同步数据

步骤3：恢复RDB同步数据

步骤4：请求部分同步数据

步骤5：恢复部分同步数据

捕获43

当前状态：

slave

具有master端全部数据，包含RDB过程接收的数据。

Master

保存slave当前数据同步的位置。

总体：

完成数据克隆。

注意事项

1.如果master 数据量巨大，数据同步策略要避开流量高峰期，避免master阻塞，影响业务执行。

2.复制缓冲区大小设定不合理， 复制缓冲区大小设定不合理，会导致数据溢出。如进行全量复制周期太长，进行部分复制时发现数据已经存在丢失的情况，必须进行第二次全量复制，致使slave陷入死循环状态。

repl-backlog-size 1mb
Copy

3.master单机内存占用主机内存的比例不应过大，建议使用50%-70%的内存，留下30%-50%的内存用于执行bgsave命令和创建复制缓冲区

数据同步阶段slave说明

避免slave进行全量复制，部分复制时，服务器阻塞或数据不同步，建议关闭此期间的对外服务。

slave-serve-stale-data yes|no
Copy

数据同步阶段，master发送给slave信息可以理解master是slave的一个客户端，主动向slave发送命令
多个slave同时对master请求数据同步，master发送的RDB文件增多，会对带宽造成巨大冲击，如果 master带宽不足，因此数据同步需要根据业务需求，适量错峰
slave过多时，建议调整拓扑结构，由一主多从结构变为树状结构，中间的节点既是master，也是 slave。注意使用树状结构时，由于层级深度，导致深度越高的slave与最顶层master间数据同步延迟较大，数据一致性变差，应谨慎选择

阶段三：命令传播阶段

当master数据库状态被修改后，导致主从服务器数据库状态不一致，此时需要让主从数据同步到一致的状态，同步的动作称为命令传播

master将接收到的数据变更命令发送给slave，slave接收命令后执行命令

该阶段可能出现的问题

命令传播阶段出现了断网现象

网络闪断闪连忽略

短时间网络中断部分复制

长时间网络中断全量复制

部分复制的核心要素

服务器的运行id
主服务器的复制积压缓冲区
主从服务器的复制偏移量

服务器运行id

概念：服务器运行id是其身份的标识码。多次运行生产多个运行id

组成：40位16进制的随机字符

作用：用来服务器进行传输，识别服务器

实现方式：id在服务器启动自动生成，master在首次连接slave时，会将自己的运行ID发送给slave，slave保存ID，通过info server命令查看节点的runid

复制缓冲区

概念：复制缓冲区，又名复制积压缓冲区，是一个先进先出（FIFO）的队列，用于存储服务器执行过的命令，每次传播命令，master都会将传播的命令记录下来，并存储在复制缓冲区

捕获44

复制缓冲区的内部工作原理

image-20210203104910534

通过offerset偏移量，区分不同的slave当前数据传播的差异

这个offerset，偏移量，

master记录已发数据的偏移量

slave记录已接受信息的偏移量。

复制缓冲区默认数据存储空间大小是1M，由于存储空间大小是固定的，当入队元素的数量大于队列长度时，最先入队的元素会被弹出，而新元素会被放入队列

由来：每台服务器启动时，如果开启AOF或被连接成为master节点，创建复制缓冲区

作用：保存master收到的所有指令（影响数据变更的指令）

数据来源：当master接受到主客户端指令时，将指令执行，并将指令存储到缓冲区中

复制偏移量

概念：一个数字，描述复制缓冲区中的指令字节位置

master端：发送一次记录一次
slave端：接收一次记录一次

同步信息，比对master与slave的差异，当slave断线后，恢复数据使用

数据同步+整体流程总结

心跳机制

进入命令传播阶段，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
Copy

slave数量少于2个，或者所有slave的延迟都大于等于10秒时，强制关闭master写功能，停止数据同步

slave数量由slave发送REPLCONF ACK命令做确认

slave延迟由slave发送REPLCONF ACK命令做确认

主从复制工作流程整体

捕获47

主从复制常见问题

频繁的全量复制，master重启引发

伴随系统的运行，master的数据量会越来越大，一旦master重启，runid将会发生变化，会导致全部的slave的全量复制

内部优化调整方案：

master内部创建master_replid变量，使用runid相同的策略生成，长度41位，并发送给所有slave

在master关闭时执行命令 shutdown save，进行RDB持久化,将runid与offset保存到RDB文件中

repl-id repl-offset
通过redis-check-rdb命令可以查看该信息

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
Copy

建议设置如下’

测算从master到slave的重连平均时长second /测算回信息的时长
获取master平均每秒产生写命令数据总量write_size_per_second
最优复制缓冲区空间 = 2 * second * write_size_per_secon

频繁的网络中断1

问题现象

master的cpu占用过高，或slave频繁断开连接

问题原因

slave每1秒发送REPLCONF ACK命令到master
当slave接到了慢查询时（keys * ，hgetall等），会大量占用CPU性能
master每1秒调用复制定时函数replicationCron()，比对slave发现长时间没有进行响应

结果

master各种资源（输出缓冲区、带宽、连接等）被严重占用

解决方案

通过设置合理的超时时间，确认是否释放slave

repl-timeout
Copy

频繁的网络中断2

问题现象

slave与master连接断开

问题原因

master发送ping指令频度较低
master设定超时时间较短
ping指令在网络中存在丢包

解决方案

提高ping指令发送的频度

repl-ping-slave-period
Copy

建议

超时时间repl-time的时间至少是ping指令频度的5到10倍，否则slave很容易判定超时

数据不一致

问题现象

多个slave获取相同数据不同步

问题原因

网络信息不同步，数据发送有延迟

解决方案

优化主从间的网络环境，通常放置在同一个机房部署，如使用阿里云等云服务器时要注意此现象
监控主从节点延迟（通过offset）判断，如果slave延迟过大，暂时屏蔽程序对该slave的数据访问

slave-serve-stale-data yes|no
Copy

开启后仅响应info、slaveof等少数命令（慎用，除非对数据一致性要求很高）主要调试用。

哨兵模式

哨兵(sentinel) 是一个分布式系统，用于对主从结构中的每台服务器进行监控，当出现故障时通过投票机制选择新的master并将所有slave连接到新的master。

捕获48

哨兵的作用

监控

检查master 和slave是否正常运行。

通知

当被监控的服务器出现问题，向其他哨兵，服务器，发送通知

自动故障转移（选举）

断开master与slave的连接，选举一个新的slave作为master，将其他slaver连接到新选举的master，告知客户端服务器地址

注意：哨兵也是一台redis服务器，只是不提供数据服务，配置哨兵一般位单数。

配置哨兵

sentinel.conf 配置文件，配置哨兵。

启动哨兵

redis-sentinel    配置文件名.conf
Copy

img

启动顺序，先启动主机，再启动从机，再启动哨兵

哨兵监控原理

监控阶段

通过ping命令

用于同步各个节点的状态信息
- 获取各个sentinel的状态（是否在线）
获取master的状态
- master属性
  - runid
  - role：master
  - 各个slave的详细信息
获取所有slave的状态（根据master中的slave信息）
- slave属性
  - runid
  - role：slave
  - master_host、master_port
  - offset
  - ……

简单来说，哨兵会获取主节点和从节点的信息状态，哨兵和哨兵之间，也共享信息。

通知阶段

维护哨兵信息对等的阶段。

故障转移阶段

确认master下线

当某个哨兵发现主服务器挂掉了，会将master中的SentinelRedistance中的master改为SRI_S_DOWN（主观下线），并通知其他哨兵，告诉他们发现master挂掉了。
其他哨兵在接收到该哨兵发送的信息后，也会尝试去连接master，如果超过半数（配置文件中设置的）确认master挂掉后，会将master中的SentinelRedistance中的master改为SRI_O_DOWN（客观下线）

推选哨兵进行处理

在确认master挂掉以后，会推选出一个哨兵来进行故障转移工作（由该哨兵来指定哪个slave来做新的master）。
筛选方式是哨兵互相发送消息，并且参与投票，票多者当选，谁先收到信息谁得到票（网络状态好），选不出来就再次竞选。

具体处理

由推选出来的哨兵对当前的slave进行筛选，

服务器列表中挑选备选master

在线的
响应慢的 out
与原master断开时间久的 out

优先原则

优先级
offset
runid

发送指令（ sentinel ）

向新的master发送slaveof no one(断开与原master的连接)
向其他slave发送slaveof 新masterIP端口（让其他slave与新的master相连）

集群

集群架构

集群就是使用网络将若干台计算机联通起来，并提供统一的管理方式，使其对外呈现单机的服务效果，

集群作用

分散单台服务器的访问压力，实现负载均衡
分散单台服务器的存储压力，实现可扩展性
降低单台服务器宕机带来的业务灾难

捕获49

Redis集群结构设计

数据存储设计

通过算法设计，计算出key应该保存的位置
将所有的存储空间计划切割成16384份，每台主机保存一部分每份代表的是一个存储空间，不是一个key的保存空间
将key按照计算出的结果放到对应的存储空间

每个Redis中存储的有空间，存储空间中有槽，如果加机器，将槽分一部分到新加的机器中。

集群内部通讯设计

捕获50

各个数据库相互通信，保存各个库中槽的编号数据

一次命中直接返回

一次未命中，告知具体位置。

集群获取数据实操

当我们从集群中获取数据的时候，放入数据时，当你的数据存在不同的槽中时，你在操作时放入数据，当前连接的机器，数据并未在槽中，就会报错。返回该槽的编号。

redis中提供了专门操作集群的命令，这个时客户端启动时的命令当使用这个命令启动时，当存取储数据的时候，他就会自动路由到数据所分配的槽位置所在的服务器。

redis-cli -c

企业级解决方案

1、缓存预热

问题排查

请求数量较高
主从之间数据吞吐量较大，数据同步操作频度较高

解决方案

前置准备工作：
- 日常例行统计数据访问记录，统计访问频度较高的热点数据
- 利用LRU数据删除策略，构建数据留存队列例如：storm与kafka配合
准备工作：
- 将统计结果中的数据分类，根据级别，redis优先加载级别较高的热点数据
- 利用分布式多服务器同时进行数据读取，提速数据加载过程
- 热点数据主从同时预热
实施：
- 使用脚本程序固定触发数据预热过程
- 如果条件允许，使用了CDN（内容分发网络），效果会更好

总结

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

2、缓存雪崩

数据库服务器崩溃（1）

系统平稳运行过程中，忽然数据库连接量激增
应用服务器无法及时处理请求
大量408，500错误页面出现
客户反复刷新页面获取数据
数据库崩溃
应用服务器崩溃
重启应用服务器无效
Redis服务器崩溃
Redis集群崩溃
重启数据库后再次被瞬间流量放倒

问题排查

在一个较短的时间内，缓存中较多的key集中过期
此周期内请求访问过期的数据，redis未命中，redis向数据库获取数据
数据库同时接收到大量的请求无法及时处理
Redis大量请求被积压，开始出现超时现象
数据库流量激增，数据库崩溃
重启后仍然面对缓存中无数据可用
Redis服务器资源被严重占用，Redis服务器崩溃
Redis集群呈现崩塌，集群瓦解
应用服务器无法及时得到数据响应请求，来自客户端的请求数量越来越多，应用服务器崩溃
应用服务器，redis，数据库全部重启，效果不理想

问题分析

短时间范围内
大量key集中过期

解决方案（道）

更多的页面静态化处理
构建多级缓存架构 Nginx缓存+redis缓存+ehcache缓存
检测Mysql严重耗时业务进行优化对数据库的瓶颈排查：例如超时查询、耗时较高事务等
灾难预警机制监控redis服务器性能指标
- CPU占用、CPU使用率
- 内存容量
- 查询平均响应时间
- 线程数
限流、降级短时间范围内牺牲一些客户体验，限制一部分请求访问，降低应用服务器压力，待业务低速运转后再逐步放开访问

解决方案（术）

LRU与LFU切换
数据有效期策略调整
- 根据业务数据有效期进行分类错峰，A类90分钟，B类80分钟，C类70分钟
- 过期时间使用固定时间+随机值的形式，稀释集中到期的key的数量
超热数据使用永久key
定期维护（自动+人工）对即将过期数据做访问量分析，确认是否延时，配合访问量统计，做热点数据的延时
加锁 慎用！

总结

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

3、缓存击穿

数据库服务器崩溃（2）

系统平稳运行过程中
数据库连接量瞬间激增
Redis服务器无大量key过期
Redis内存平稳，无波动
Redis服务器CPU正常
数据库崩溃

问题排查

Redis中某个key过期，该key访问量巨大
多个数据请求从服务器直接压到Redis后，均未命中
Redis在短时间内发起了大量对数据库中同一数据的访问

问题分析

单个key高热数据
key过期

解决方案（术）

预先设定

以电商为例，每个商家根据店铺等级，指定若干款主打商品，在购物节期间，加大此类信息key的过期时长

注意：购物节不仅仅指当天，以及后续若干天，访问峰值呈现逐渐降低的趋势
现场调整
- 监控访问量，对自然流量激增的数据延长过期时间或设置为永久性key
后台刷新数据
- 启动定时任务，高峰期来临之前，刷新数据有效期，确保不丢失
二级缓存
- 设置不同的失效时间，保障不会被同时淘汰就行
加锁分布式锁，防止被击穿，但是要注意也是性能瓶颈，慎重！

总结

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

4、缓存穿透

恶意请求

我们的数据库中的主键都是从0开始的，即使我们将数据库中的所有数据都放到了缓存中。当有人用id=-1来发生恶意请求时，因为redis中没有这个数据，就会直接访问数据库，这就称谓缓存穿透

解决办法

在程序中进行数据的合法性检验，如果不合法直接返回
使用布隆过滤器

布隆过滤器简介

想要尽量避免缓存穿透，一个办法就是对数据进行预校验，在对Redis和数据库进行操作前，先检查数据是否存在，如果不存在就直接返回。如果我们想要查询一个元素是否存在，要保证查询效率，可以选择HashSet，但是如果有10亿个数据，都用HashSet进行存储，内存肯定是无法容纳的。这时就需要布隆过滤器了

布隆过滤器（英语：Bloom Filter）是1970年由布隆提出的。它实际上是一个很长的二进制向量（bit数组）和一系列随机映射函数（hash）。布隆过滤器可以用于检索一个元素是否在一个集合中

因为是基于位数组和hash函数的，所以它的优点是空间效率和查询时间都远远超过一般的算法。但缺点也很明显，那就是有一定的误识别率和删除困难。但是可以通过增加位数组的大小和增加hash函数个数来降低误识别率（只能降低，没法避免）

放入过程

布隆过滤器初始化后，位数组中的值都为0。当一个变量将要放入布隆过滤器时，会通过多个hash函数映射到位数组的各个位上，然后将对应位置为1

查询过程

查询依然是通过多个hash函数映射到位数组的各个位上，如果各个位都为1，说明该元素可能存在，注意是可能存在！！。但是如果通过映射后，位数组对应位上不为1，那么该元素肯定不存在

放入过程图解

比如我们的布隆过滤器位一个8位的位数组，并且有3个hash函数对元素进行计算，映射到数组中的各个位上

我们将字符串”Nyima”放入布隆过滤器中

接下来将字符串”Cpower”放入布隆过滤器中

查询过程图解

比如我们要查询字符串”Cpower”是否存在，通过3个hash函数映射到了位数组的三个位置上，三个位置都为1，那么该字符串可能存在

比如我们要查询字符串”SWPU”是否存在，通过3个hash函数映射到了位数组的三个位置，发现有一个位置不为1，那么该字符串肯定不存在

比如我们要查询字符串”Hulu”是否存在，通过3个hash函数映射到了位数组的三个位置，发现所有位置都为1，但是我们前面并没有将字符串”Hulu”放入布隆过滤器中，所以这里发生了误判

增加位数组的大小和hash函数个数可以降低误判率，但是无法避免误判

posted on 2021-08-22 13:56 Dongdong98 阅读(39) 评论(0) 收藏举报

刷新页面返回顶部

导航

redis

背景

Redis特征

Redis应用

Redis基本操作

功能性命令

清除屏幕信息

帮助信息查询

退出指令

Redis的数据类型

String 类型

String数据操作

String类型数据扩展

数值增长

设置数据生命周期

String类型业务场景

Hash类型

hash数据操作

hash类型数据扩展操作

hash类型数据操作注意事项

hash类型应用场景

电商购物车设计与实现

抢购的设计

LIst类型

List数据操作

List数据操作扩展

List数据业务场景

list类型数据操作注意事项

Set类型

Set的数据操作

Set数据操作扩展

Set类型操作注意事项

Set类型应用场景

sorted_set类型

sorted_set基本操作

sorted_set 类型扩展操作

sorted_set注意事项

sorted_set应用场景

KEY通用操作

key基本操作

redis中的数据库

Jedis

编程案例

jedis工具类

Redis持久化

RDB

RDB启动方式—save

RDB配置相关命令

Save指令工作原理

bgsave 指令工作原理

自动保存save 配置

三种对比

RDB优缺点

AOF

AOF概念

AOF写数据过程

AOF写数据的三种策略

AOF配置

AOF重写

作用

规则

如何使用

RDB和AOF

持久化场景

Redis事务

Redis事务的定义

事务的操作

事务的工作流程

事务操作的注意事项

锁

基于特定条件的事务执行

业务场景补货不重复

业务场景不超卖

业务场景死锁

Redis中的删除策略

数据删除策略

时效性数据的存储结构

定时删除

惰性删除