Redis学习笔记

一、NoSQL数据库

1、No数据库概述SQL

NoSQL（ NoSQL = Not Only SQL ），意即不仅仅是 SQL，泛指非关系型的数据库。

NoSQL不依赖业务逻辑方式存储，而以简单的 key-value 模式存储。因此大大的增加了数据库的扩展能力。

• 不遵循 SQL 标准。
• 不支持 ACID。
• 远超于 SQL 的性能。

2、适用于的场景

• 对数据高并发的读写；
• 海量数据的读写；
• 对数据高可扩展性的。

3、不适用的场景

• 需要事务支持；
• 基于sql的结构化查询存储，处理复杂的关系，需要即席查询。

4、常见的 NoSQL 数据库

• Redis
• MongoDB

二、Redis概述、安装

Redis 是典型的 NoSQL 数据库。

redis官网：https://redis.io/download

Redis 是一个开源的 key-value存储系统。

和 Memcached 类似，它支持存储的 value 类型相对更多，包括 string*、*list、set、zset、sorted set、hash。

这些数据类型都支持 push/pop、add/remove 及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。

在此基础上，Redis 支持各种不同方式的排序。

与 memcached一样，为了保证效率，数据都是缓存在内存中。

区别的是 Redis 会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件。

并且在此基础上实现了master-slave （主从）同步。

单线程 + IO 多路复用。

1、应用场景

a.配合关系型数据库做高速缓存

1. 高频次，热门访问的数据，降低数据库IO
2. 分布式架构，做session共享

2、安装与启动

a.安装 C 语言的编译环境

yum install centos-release-scl scl-utils-build
yum install -y devtoolset-8-toolchain
scl enable devtoolset-8 bash

b.通过 wget 下载

wget https://download.redis.io/releases/redis-6.2.6.tar.gz

// 下载路径：/opt

c.解压至当前目录

tar -zxvf redis-6.2.6.tar.gz

d.解压完成后进入目录

cd redis-6.2.6

e.在当前目录下执行 make

make && make install

默认安装在 /usr/local/bin

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aRyEGGxy-1666015242667)(C:\Users\AbleLynn\AppData\Roaming\Typora\typora-user-images\image-20221015102309871.png)]

redis-benchmark：性能测试工具，可以在自己本子运行，看看自己本子性能如何
redis-check-aof：修复有问题的AOF文件，rdb和aof后面讲
redis-check-dump：修复有问题的dump.rdb文件
redis-sentinel：Redis集群使用
redis-server：Redis服务器启动命令
redis-cli：客户端，操作入口

f.前台启动

/usr/local/bin 目录下启动 redis，则次窗口不能在进行操作和关闭，不推荐

redis-server(前台启动)

g.后台启动：

• 安装 redis的目录 /opt/redis-6.2.6 中将 redis.conf 复制到任意一个文件夹下

  cp redis.conf /etc/redis.conf

  // 将redis.conf复制到/etc/下

• 修改 /etc/redis.conf 配置文件

  daemonize no 修改为 daemonize yes

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-k6p59DyO-1666015242668)(C:\Users\AbleLynn\AppData\Roaming\Typora\typora-user-images\image-20221015103507520.png)]

• /usr/local/bin 目录下启动 redis

  redis-server /etc/redis.conf #启动redis服务

  redis-cli 连接redis服务

h.关闭 redis

• kill进程
• 命令 shutdown

默认值

默认端口号：6379

默认使用0号库

三、redis优势

Redis是单线程+多路IO复用技术

多路复用是指使用一个线程来检查多个文件描述符（Socket）的就绪状态，比如调用select和poll函数，传入多个文件描述符，如果有一个文件描述符就绪，则返回，否则阻塞直到超时。得到就绪状态后进行真正的操作可以在同一个线程里执行，也可以启动线程执行（比如使用线程池）

串行 vs 多线程+锁（memcached） vs 单线程+多路IO复用(Redis

与Memcache三点不同: 支持多数据类型，支持持久化，单线程+多路IO复用

四、常用的五大数据类型

1、Redis键(Key)

keys * 查看当前库所有key (匹配：keys *1)

exists key 判断某个key是否存在

type key 查看你的key是什么类型

del key 删除指定的key数据

unlink key 根据value选择非阻塞删除,仅将keys从keyspace元数据中删除，真正的删除会在后续异步操作。

expire key 10 10秒钟：为给定的key设置过期时间, -2表示已过期，-1表示永不过期

ttl key 查看还有多少秒过期，-1表示永不过期，-2表示已过期

select 数字 命令切换数据库

dbsize 查看当前数据库的key的数量

flushdb 清空当前库

flushall 通杀全部库

2、Redis字符串(String)

a.简介

String是Redis最基本的类型，一个key对应一个value。String类型是二进制安全的。意味着Redis的string可以包含任何数据。比如jpg图片或者序列化的对象

b.常用命令

set <key><value> 添加键值对

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7m6TyZ2b-1666015242668)(C:\Users\AbleLynn\AppData\Roaming\Typora\typora-user-images\image-20221015105144977.png)]

*NX：当数据库中key不存在时，可以将key-value添加数据库

*XX：当数据库中key存在时，可以将key-value添加数据库，与NX参数互斥

*EX：key的超时秒数

*PX：key的超时毫秒数，与EX互斥

get <key> 查询对应键值

append <key><value> 将给定的 追加到原值的末尾

strlen <key>获得值的长度

setnx <key><value> 只有在 key 不存在时 设置 key 的值

incr <key>将 key 中储存的数字值增1,只能对数字值操作，如果为空，新增值为1

decr <key>将 key 中储存的数字值减1,只能对数字值操作，如果为空，新增值为-1

incrby / decrby <key><步长>将 key 中储存的数字值增减。自定义步长

mset <key1><value1><key2><value2> ..... 同时设置一个或多个 key-value对 ,原子性，有一个失败则都失败

mget <key1><key2><key3> .....同时获取一个或多个 value ,原子性，有一个失败则都失败

msetnx <key1><value1><key2><value2> ..... 同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在, 原子性，有一个失败则都失败

getrange <key><起始位置><结束位置>获得值的范围

setrange <key><起始位置><value>用 覆写所储存的字符串值，从<起始位置>开始(索引从0开始)

setex <key><过期时间><value> 设置键值的同时，设置过期时间，单位秒

getset <key><value>以新换旧，设置了新值同时获得旧值

c.数据结构

String的数据结构为简单动态字符串,是可以修改的字符串,内部结构实现上类似于Java的ArrayList,注意,字符串最大长度为512M

原子性

所谓 原子 操作是指不会被线程调度机制打断的操作；

这种操作一旦开始，就一直运行到结束，中间不会有任何 context switch （切换到另一个线程）

• 在单线程中， 能够在单条指令中完成的操作都可以认为是"原子操作"，因为中断只能发生于指令之间

• 在多线程中，不能被其它进程（线程）打断的操作就叫原子操作

Redis 单命令的原子性主要得益于 Redis 的单线程

3、Redis列表(list)

a.简介

单键多值

Redis 列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）或者尾部（右边）

它的底层实际是个双向链表，对两端的操作性能很高，通过索引下标的操作中间的节点性能会较差

b.常用命令

lpush/rpush <key><value1><value2><value3> .... 从左边/右边插入一个或多个值。

lpop/rpop <key>从左边/右边吐出一个值。值在键在，值光键亡。

rpoplpush <key1><key2> 从列表右边吐出一个值，插到列表左边。

lrange <key><start><stop>按照索引下标获得元素(从左到右)

lrange mylist 0 -1 0左边第一个，-1右边第一个，（0-1表示获取所有）

lindex <key><index>按照索引下标获得元素(从左到右)

llen <key>获得列表长度

linsert <key> before <value><newvalue>在的后面插入插入值

lrem <key><n><value>从左边删除n个value(从左到右)

lset<key><index><value>将列表key下标为index的值替换成value

c.数据结构

List的数据结构为快速链表quickList

首先在列表元素较少的情况下会使用一块连续的内存存储，这个结构是ziplist（压缩列表）。它将所有的元素紧挨着一起存储，分配的是一块连续的内存

当数据量比较多的时候才会改成quicklist

因为普通的链表需要的附加指针空间太大，会比较浪费空间。比如这个列表里存的只是int类型的数据，结构上还需要两个额外的指针prev和next

Redis将链表和ziplist结合起来组成了quicklist。也就是将多个ziplist使用双向指针串起来使用。这样既满足了快速的插入删除性能，又不会出现太大的空间冗余

4、Redis集合(set)

a.简介

Redis set是可以自动排重的无序列表，并且set提供了判断某个成员是否在一个set集合内的重要接口

Redis的Set是string类型的无序集合。它底层其实是一个value为null的hash表，所以添加，删除，查找的复杂度都是O(1)

b.常用命令

sadd <key><value1><value2> ..... 将一个或多个 member 元素加入到集合 key 中，已经存在的 member 元素将被忽略

smembers <key> 取出该集合的所有值

sismember <key><value> 判断集合是否为含有该值，有1，没有0

scard<key> 返回该集合的元素个数

srem <key><value1><value2> .... 删除集合中的某个元素

spop <key>随机从该集合中吐出一个值

srandmember <key><n>随机从该集合中取出n个值。不会从集合中删除

smove <source><destination>value把集合中一个值从一个集合移动到另一个集合

sinter <key1><key2>返回两个集合的交集元素

sunion <key1><key2>返回两个集合的并集元素

sdiff <key1><key2>返回两个集合的差集元素(key1中的，不包含key2中的)

c.数据结构

Set数据结构是dict字典，字典是用哈希表实现的

5、Redis哈希(Hash)

a.简介

Redis hash 是一个键值对集合

Redis hash是一个string类型的field和value的映射表，hash特别适合用于存储对象

类似Java里面的Map<String,Object>

用户ID为查找的key，存储的value用户对象包含姓名，年龄，生日等信息，如果用普通的key/value结构来存储

b.常用命令

hset <key><field><value>给集合中的 键赋值

hget <key1><field>从集合取出 value

hmset <key1><field1><value1><field2><value2>... 批量设置hash的值

hexists<key1><field>查看哈希表 key 中，给定域 field 是否存在

hkeys <key>列出该hash集合的所有field

hvals <key>列出该hash集合的所有value

hincrby <key><field><increment>为哈希表 key 中的域 field 的值加上增量increment

hsetnx <key><field><value>将哈希表 key 中的域 field 的值设置为 value ，当且仅当域 field 不存在

c.数据结构

Hash类型对应的数据结构是两种：ziplist（压缩列表），hashtable（哈希表）。当field-value长度较短且个数较少时，使用ziplist，否则使用hashtable

6、Redis有序集合Zset(sorted set)

a.简介

Redis有序集合Zset是一个没有重复元素的有序字符串集合

不同之处是有序集合的每个成员都关联了一个评分（score）,这个评分（score）被用来按照从最低分到最高分的方式排序集合中的成员。集合的成员是唯一的，但评分可以重复

可以根据评分（score）或者次序（position）来获取一个范围的元素

b.常用命令

zadd <key><score1><value1><score2><value2>…将一个或多个 member 元素及其 score 值加入到有序集 key 当中

zrange <key><start><stop> [WITHSCORES] 返回有序集 key 中，下标在 之间的元素，带WITHSCORES，可以让分数一起和值返回到结果集

zrangebyscore key min max [withscores] [limit offset count]返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列。

zrevrangebyscore key max min [withscores] [limit offset count] 同上，改为从大到小排列。

zincrby <key><increment><value> 为元素的score加上增量

zrem <key><value>删除该集合下，指定值的元素

zcount <key><min><max>统计该集合，分数区间内的元素个数

zrank <key><value>返回该值在集合中的排名，从0开始，从小到大

c.数据结构

ortedSet(zset)是Redis提供的一个非常特别的数据结构，一方面它等价于Java的数据结构Map<String, Double>，可以给每一个元素value赋予一个权重score，另一方面它又类似于TreeSet，内部的元素会按照权重score进行排序，可以得到每个元素的名次，还可以通过score的范围来获取元素的列表。

zset底层使用了两个数据结构

（1）hash，hash的作用就是关联元素value和权重score，保障元素value的唯一性，可以通过元素value找到相应的score值

（2）跳跃表，跳跃表的目的在于给元素value排序，根据score的范围获取元素列表

五、Redis配置文件

1、Units单位

配置大小单位,开头定义了一些基本的度量单位，只支持bytes，不支持bit，不区分大小写

2、INCLUDES包含

类似jsp中的include，多实例的情况可以把公用的配置文件提取出来

3、网络相关配置

a.bind

默认情况bind=127.0.0.1只能接受本机的访问请求

不写的情况下，无限制接受任何ip地址的访问

生产环境肯定要写你应用服务器的地址；服务器是需要远程访问的，所以需要将其注释掉

保存配置，停止服务，重启启动查看进程，不再是本机访问

b.protected-mode

将本机访问保护模式设置no

c.Port

默认端口号6379

d.tcp-backlog

设置tcp的backlog，backlog其实是一个连接队列，backlog队列总和=未完成三次握手队列 + 已经完成三次握手队列

e.timeout

一个空闲的客户端维持多少秒会关闭，0表示关闭该功能。即永不关闭

f.tcp-keepalive

对访问客户端的一种心跳检测，每个n秒检测一次。单位为秒，如果设置为0，则不会进行Keepalive检测，建议设置成60

4、GENERAL通用

a.daemonize

是否为后台进程，设置为yes

守护进程，后台启动

b.pidfile

存放pid文件的位置，每个实例会产生一个不同的pid文件

c.loglevel

指定日志记录级别，Redis总共支持四个级别：debug、verbose、notice、warning，默认为notice

d.logfile

日志文件名称

e.databases 16

设定库的数量 默认16，默认数据库为0，可以使用SELECT 命令在连接上指定数据库id

5、SECURITY安全

a.设置密码

访问密码的查看、设置和取消

在命令中设置密码，只是临时的。重启redis服务器，密码就还原了

永久设置，需要再配置文件中进行设置

6、LIMITS限制

a.maxclients

设置redis同时可以与多少个客户端进行连接

默认情况下为10000个客户端

如果达到了此限制，redis则会拒绝新的连接请求，并且向这些连接请求方发出“max number of clients reached”以作回应

b.maxmemory

建议必须设置，否则，将内存占满，造成服务器宕机

设置redis可以使用的内存量。一旦到达内存使用上限，redis将会试图移除内部数据，移除规则可以通过maxmemory-policy来指定

如果redis无法根据移除规则来移除内存中的数据，或者设置了“不允许移除”，那么redis则会针对那些需要申请内存的指令返回错误信息，比如SET、LPUSH等

但是对于无内存申请的指令，仍然会正常响应，比如GET等。如果你的redis是主redis（说明你的redis有从redis），那么在设置内存使用上限时，需要在系统中留出一些内存空间给同步队列缓存，只有在你设置的是“不移除”的情况下，才不用考虑这个因素

c.maxmemory-policy

volatile-lru：使用LRU算法移除key，只对设置了过期时间的键；（最近最少使用）

allkeys-lru：在所有集合key中，使用LRU算法移除key

volatile-random：在过期集合中移除随机的key，只对设置了过期时间的键

allkeys-random：在所有集合key中，移除随机的key

volatile-ttl：移除那些TTL值最小的key，即那些最近要过期的key

noeviction：不进行移除。针对写操作，只是返回错误信息

d.maxmemory-asmples

设置样本数量，LRU算法和最小TTL算法都并非是精确的算法，而是估算值，所以你可以设置样本的大小，redis默认会检查这么多个key并选择其中LRU的那个

一般设置3到7的数字，数值越小样本越不准确，但性能消耗越小

六、Redis的发布和订阅

1、发布与订阅概念

Redis 发布订阅 (pub/sub) 是一种消息通信模式：发送者 (pub) 发送消息，订阅者 (sub) 接收消息

Redis 客户端可以订阅任意数量的频道

2、Redis的发布与订阅

1、客户端可以订阅频道如下图

2、当给这个频道发布消息后，消息就会发送给订阅的客户端

3、发布订阅命令行实现

a.打开一个客户端订阅channel1

b.打开另一个客户端，给channel1发布消息hello

c.打开第一个客户端可以看到发送的消息

七、Redis新数据类型

1、Bitmaps

a.简介

Redis提供了Bitmaps这个“数据类型”可以实现对位的操作：

1. Bitmaps本身不是一种数据类型， 实际上它就是字符串（key-value） ， 但是它可以对字符串的位进行操作
2. Bitmaps单独提供了一套命令， 所以在Redis中使用Bitmaps和使用字符串的方法不太相同。 可以把Bitmaps想象成一个以位为单位的数组， 数组的每个单元只能存储0和1， 数组的下标在Bitmaps中叫做偏移量

b.命令

setbit

getbit<key><offset>获取Bitmaps中某个偏移量的值

每个独立用户是否访问过网站存放在Bitmaps中， 将访问的用户记做1， 没有访问的用户记做0， 用偏移量作为用户的id。设置键的第offset个位的值（从0算起），假设现在有20个用户，userid=1， 6， 11， 15， 19的用户对网站进行了访问， 那么当前Bitmaps初始化结果如图

unique:users:20201106代表2022-10-15这天的独立访问用户的Bitmaps

注：

很多应用的用户id以一个指定数字（例如10000） 开头， 直接将用户id和Bitmaps的偏移量对应势必会造成一定的浪费， 通常的做法是每次做setbit操作时将用户id减去这个指定数字。

在第一次初始化Bitmaps时， 假如偏移量非常大， 那么整个初始化过程执行会比较慢， 可能会造成Redis的阻塞。

getbit

getbit<key><offset>获取Bitmaps中某个偏移量的值

获取id=8的用户是否在2022-10-15这天访问过， 返回0说明没有访问过：

获取id=6的用户是否在2022-10-15这天访问过， 返回1说明访问过：

bitcount

统计字符串被设置为1的bit数

一般情况下，给定的整个字符串都会被进行计数，通过指定额外的 start 或 end 参数，可以让计数只在特定的位上进行。start 和 end 参数的设置，都可以使用负数值：比如 -1 表示最后一个位，而 -2 表示倒数第二个位，start、end 是指bit组的字节的下标数，二者皆包含

bitcount<key>[start end] 统计字符串从start字节到end字节比特值为1的数量

计算2022-10-15这天的独立访问用户数量

计算用户id在第1个字节到第3个字节之间的独立访问用户数， 对应的用户id是11， 15， 19

注意：

一个字节有8位，用户id为存放的位数，bitmaps内的字节从左到右以0开始，位数从左到右以0开始

bitop

bitop and(or/not/xor) <destkey> [key…]bitop是一个复合操作，可以做多个Bitmaps的and（交集）、 or（并集）、not（非）、xor（异或）操作并将结果保存在destkey中

假设：

• 2022-10-15 日访问网站的userid=1,6,11,15
• 2022-10-10 日访问网站的userid=1,3,6,11

计算出两天都访问过网站的用户数量

c.Bitmaps与set对比

使用Bitmaps能节省很多的内存空间，但假如网站每天的独立访问用户很少， 例如只有10万（大量的僵尸用户） ， 那么这时候使用Bitmaps就不太合适了， 因为基本上大部分位都是0，此时可以使用set集合

2、HyperLogLog

a.简介

Redis HyperLogLog 是用来降低一定的精度来平衡存储空间做基数统计的算法，HyperLogLog 的优点是，在输入元素的数量或者体积非常非常大时，计算基数所需的空间总是固定的、并且是很小的

但HyperLogLog 只会根据输入元素来计算基数，而不会储存输入元素本身，所以 HyperLogLog 不能像集合那样，返回输入的各个元素

比如数据集 {1, 3, 5, 7, 5, 7, 8}， 那么这个数据集的基数集为 {1, 3, 5 ,7, 8}, 基数(不重复元素)为5。 基数估计就是在误差可接受的范围内，快速计算基数

求集合中不重复元素个数的问题，像UV（UniqueVisitor，独立访客）、独立IP数、搜索记录数等需要去重和计数的问题称为基数问题

解决基数问题的方案：

（1）数据存储在MySQL表中，使用distinct count计算不重复个数

（2）使用Redis提供的hash、set、bitmaps等数据结构来处理

以上的方案结果精确，但随着数据不断增加，导致占用空间越来越大，对于非常大的数据集是不切实际的

b.命令

pfadd

pfadd <key>< element> [element ...] 添加指定元素到 HyperLogLog 中

pfcount

pfcount<key> [key ...] 计算近似基数

pfmerge

pfmerge<destkey><sourcekey> [sourcekey ...] 将一个或多个pf合并后的结果存储在另一个pf中

3、Geospatial

a.简介

Redis 3.2 中增加了对GEO类型的支持。GEO，Geographic，地理信息的缩写。该类型，就是元素的2维坐标，在地图上就是经纬度。redis基于该类型，提供了经纬度设置，查询，范围查询，距离查询，经纬度Hash等常见操作。

b.命令

geoadd

geoadd<key>< longitude><latitude><member> [longitude latitude member...] 添加地理位置（经度，纬度，名称）

注意

• 两极无法直接添加，一般会下载城市数据，直接通过 Java 程序一次性导入
• 有效的经度从 -180 度到 180 度。有效的纬度从 -85.05112878 度到 85.05112878 度
• 当坐标位置超出指定范围时，该命令将会返回一个错误
• 已经添加的数据，是无法再次往里面添加的

geopos

geopos <key><member> [member...] 获得指定地区的坐标值

geodist

geodist<key><member1><member2> [m|km|ft|mi ] 获取两个位置之间的直线距离

• 单位：
• m 表示单位为米[默认值]。
• km 表示单位为千米。
• mi 表示单位为英里。
• ft 表示单位为英尺。
• 如果用户没有显式地指定单位参数， 那么 GEODIST 默认使用米作为单位

georadius

georadius<key>< longitude><latitude>radius m|km|ft|mi 以给定的经纬度为中心，找出某一半径内的元素

八、Redis_Jedis_测试

1、Jedis所需要的jar包

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

2、连接Redis注意事项

测试连接Redis

    @Test
    public void JedisTest(){
        //创建Jedis对象
        Jedis jedis = new Jedis("192.168.117.100",6379);
        //Jedis jedis = new Jedis("ablelynn100",6379);  //注意也可以使用hosts文件中设置的ip地址的别名来进行连接
        //测试
        String ping = jedis.ping();
        System.out.println(ping);
    }

测试连接Redis失败主要原因有

未修改redis.conf配置文件

• 将bind注释掉
• 将protected-mode yes 中的yes修改为no

未将虚拟机中的防火墙关闭

• 查看防火墙状态
  • systemctl status firewalld
• 关闭防火墙
  • systemctl stop firewalld

3、Jedis常用操作

a.创建动态的工程

b.创建测试程序

4、测试相关数据类型

a.Jedis-API: Key

    @Test
    public void KeyTest() {
        Jedis jedis = new Jedis("192.168.117.100", 6379);
        Set<String> keys = jedis.keys("*");
        for (String key : keys) {
            System.out.println(key);
        }
        jedis.set("key1", "v1");
        jedis.set("key2", "v2");
        System.out.println(jedis.get("key1"));
        System.out.println(jedis.exists("key1"));
        jedis.close();
    }

b.Jedis-API: String

    @Test
    public void KeyString() {
        Jedis jedis = new Jedis("192.168.117.100", 6379);
        jedis.set("str1", "v1");
        jedis.set("str2", "v2");
        System.out.println(jedis.get("str1"));
        System.out.println(jedis.strlen("str2"));
        jedis.close();
    }

c.Jedis-API: List

    @Test
    public void KeyList() {
        Jedis jedis = new Jedis("192.168.117.100", 6379);
        jedis.lpush("list1", "v1");
        jedis.lpush("list1", "v2");
        jedis.lpush("list1", "v3");
        System.out.println(jedis.lrange("list1", 0, -1));
        System.out.println(jedis.lindex("list1", 0));
        System.out.println(jedis.llen("list1"));
        jedis.close();
    }

d.Jedis-API: Set

    @Test
    public void KeySet() {
        Jedis jedis = new Jedis("192.168.117.100", 6379);
        jedis.sadd("set1", "v1", "v2", "v3");
        jedis.sadd("set2", "v0", "v1", "v2");
        System.out.println(jedis.smembers("set1"));
        System.out.println(jedis.sismember("set1", "v1"));
        System.out.println(jedis.scard("set1"));
        System.out.println(jedis.sinter("set1", "set2"));
        System.out.println(jedis.sunion("set1", "set2"));
        System.out.println(jedis.sdiff("set1", "set2"));
        jedis.close();
    }

e.Jedis-API: Hash

    @Test
    public void KeyHash() {
        Jedis jedis = new Jedis("192.168.117.100", 6379);
        jedis.hset("hash","name","无名氏");
        HashMap<String,String> hashMap = new HashMap<String,String>();
        hashMap.put("name","张三");
        hashMap.put("age","24");
        hashMap.put("gender","男");
        jedis.hmset("user",hashMap);
        System.out.println(jedis.hkeys("user"));
        System.out.println(jedis.hvals("user"));
        System.out.println(jedis.hexists("hash","age"));
        jedis.close();
    }

f.Jedis-API: Zset

    @Test
    public void KeyZset() {
        Jedis jedis = new Jedis("192.168.117.100", 6379);
        jedis.zadd("zset", 100d, "java");
        jedis.zadd("zset", 80d, "python");
        jedis.zadd("zset", 60d, "mysql");
        jedis.zadd("zset", 40d, "redis");
        Set<String> zrange1 = jedis.zrange("zset", 0, -1);
        for (String zset : zrange1) {
            System.out.println(zset);
        }
        System.out.println(jedis.zrangeByScore("zset",0,100));
        System.out.println(jedis.zrevrangeByScore("zset",100,0));
        System.out.println(jedis.zrank("zset","java"));
        jedis.close();
    }

九、Redis事务、锁机制、秒杀

1、Redis的事务定义

Redis事务是一个单独的隔离操作：事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断

Redis事务的主要作用就是串联多个命令，防止别的命令插队。

2、Multi、Exec、discard

从输入Multi命令开始，输入的命令都会依次进入命令队列中，但不会执行，直到输入Exec后，Redis会将之前的命令队列中的命令依次执行。组队的过程中可以通过discard来放弃组队，之前进入命令队列的命令都将不执行

3、事务的错误处理

1. 组队中某个命令出现了报告错误，执行时整个的所有队列都会被取消
2. 如果执行阶段某个命令报出了错误，则只有报错的命令不会被执行，而其他的命令都会执行，不会回滚

4、事务冲突的问题

a.例子

• 一个请求想给金额减8000
• 一个请求想给金额减5000
• 一个请求想给金额减1000

b.悲观锁

悲观锁(Pessimistic Lock)，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会block直到它拿到锁。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁

c.乐观锁

乐观锁(Optimistic Lock)，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制，利用使用过后更新版本号，则当前操作的版本号与更新后的版本号不一致，则不进行操作，乐观锁适用于多读的应用类型，这样可以提高吞吐量。Redis就是利用这种check-and-set机制实现事务

d.WATCH key [key …]

在执行multi之前，先执行watch key1 [key2],可以监视一个(或多个) key ，如果在事务执行之前这个(或这些) key 被其他命令所改动，那么事务将被打断

e.unwatch

取消 WATCH 命令对所有 key 的监视

如果在执行 WATCH 命令之后，EXEC 命令或DISCARD 命令先被执行了的话，那么就不需要再执行UNWATCH 了

5、Redis事务的三大特性

1. 单独的隔离操作
   • 事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。
2. 没有隔离级别的概念
   • 队列中的命令没有提交之前都不会实际被执行，因为事务提交前任何指令都不会被实际执行
3. 不保证原子性
   • 事务中如果有一条命令执行失败，其后的命令仍然会被执行，没有回滚

十、Redis持久化之RDB(Redis DataBase)

1、概念

在指定的时间间隔内将内存中的数据集快照写入磁盘，也就是行话讲的Snapshot快照，它恢复时是将快照文件直接读到内存里

数据集快照：当前时间点的数据

2、执行备份

Redis会单独创建（fork）一个子进程来进行持久化，会先将数据写入到一个临时文件中，待持久化过程都结束了，再用这个临时文件替换上次持久化好的文件。整个过程中，主进程是不进行任何IO操作的，这就确保了极高的性能，如果需要进行大规模数据的恢复，且对于数据恢复的完整性不是非常敏感，那RDB方式要比AOF方式更加的高效。RDB的缺点是最后一次持久化后的数据可能丢失。

3、Fork

• Fork的作用是复制一个与当前进程一样的进程。Rork出的新进程中所有数据（变量、环境变量、程序计数器等） 数值都和原进程一致，但是是一个全新的进程，并作为原进程的子进程
• 在Linux程序中，fork()会产生一个和父进程完全相同的子进程，但子进程在此后多会exec系统调用，出于效率考虑，Linux中引入了“写时复制技术”
• 一般情况父进程和子进程会共用同一段物理内存，只有进程空间的各段的内容要发生变化时，才会将父进程的内容复制一份给子进程。

4、RDB持久化流程

5、dump.rdb文件

在redis.conf中配置文件名称，默认为dump.rdb

6、配置位置

rdb文件的保存路径，也可以修改。默认为Redis启动时命令行所在的目录下

dir “/myredis/”

7、触发RDB快照；保持策略

a.配置文件中默认的快照配置

b.命令 save VS bgsave

save ：save时只管保存，其它不管，全部阻塞。手动保存。不建议。

bgsave：Redis会在后台异步进行快照操作， 快照同时还可以响应客户端请求。

可以通过lastsave 命令获取最后一次成功执行快照的时间

c.flushall 命令

执行flushall命令，也会产生dump.rdb文件，但里面是空的，无意义

d.Save

格式：save 秒钟 写操作次数

默认是1分钟内改了1万次，或5分钟内改了10次，或15分钟内改了1次。禁用，不设置save指令，或者给save传入空字符串

e.stop-writes-on-bgsave-error

f.rdbcompression 压缩文件

对于存储到磁盘中的快照，可以设置是否进行压缩存储

g.rdbchecksum 检查完整性

在数据持久化之前，检查数据的完整性

h. rdb的备份

1. 复制dimp.rdb文件cp dump.rdb d.rdb
2. 删除dump.rdb文件rm -f dump.rdb
3. 关闭redis shutdown
4. 将需要恢复的备份文件改名mv d.rdb dump.rdb
5. 启动redis，备份数据自动恢复

8、优势

• 适合大规模的数据恢复
• 对数据完整性和一致性要求不高更适合使用
• 节省磁盘空间
• 恢复速度快

9、劣势

• Fork的时候，内存中的数据被克隆了一份，大致2倍的膨胀性需要考虑
• 虽然Redis在fork时使用了写时拷贝技术,但是如果数据庞大时还是比较消耗性能
• 在备份周期在一定间隔时间做一次备份，所以如果Redis意外down掉的话，就会丢失最后一次快照后的所有修改

10、如何停止

动态停止RDB：redis-cli config set save “”#save后给空值，表示禁用保存策略

十一、Redis持久化之AOF（Append Only File）

1、概念

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

2、AOF持久化流程

AOF默认不开启，改为YES即开启

生成文件的名称

1. 客户端的请求写命令会被append追加到AOF缓冲区内
2. AOF缓冲区根据AOF持久化策略[always,everysec,no]将操作sync同步到磁盘的AOF文件中
3. AOF文件大小超过重写策略或手动重写时，会对AOF文件rewrite重写，压缩AOF文件容量
4. Redis服务重启时，会重新load加载AOF文件中的写操作达到数据恢复的目的

3、AOF与RDB的优先级

AOF和RDB同时开启，系统默认取AOF的数据（数据不会存在丢失）

4、AOF启动、修复、恢复

AOF的备份和恢复的操作同RDB一样，都是拷贝备份文件，需要恢复时再拷贝到Redis工作目录下，启动系统即加载

正常恢复

1. 修改默认的appendonly no，改为yes
2. 复制aof的备份文件 cp appendonly.aof a.aof
3. 删除appendonly.aof文件rm -f appendonly.aof
4. 修改想要恢复的备份文件文件mv a.aof appendonly.aof
5. 恢复：重启redis，然后重新加载

异常恢复

1. 修改默认的appendonly no，改为yes
2. 如遇到AOF文件损坏，通过/usr/local/bin/redis-check-aof--fix appendonly.aof进行恢复
3. 备份被写坏的AOF文件
4. 恢复：重启redis，然后重新加载

5、AOF同步频率设置

appendfsync always

始终同步，每次Redis的写入都会立刻记入日志；性能较差但数据完整性比较好

appendfsync everysec

每秒同步，每秒记入日志一次，如果宕机，本秒的数据可能丢失

appendfsync no

redis不主动进行同步，把同步时机交给操作系统

6、Rewrite压缩

a.概念

AOF采用文件追加方式，文件会越来越大为避免出现此种情况，新增了重写机制, 当AOF文件的大小超过所设定的阈值时，Redis就会启动AOF文件的内容压缩， 只保留可以恢复数据的最小指令集.可以使用命令bgrewriteaof

b.重写原理

redis4.0版本后的重写，是指上就是把rdb 的快照，以二级制的形式附在新的aof头部，作为已有的历史数据，替换掉原来操作

• Redis会记录上次重写时的AOF大小，默认配置是当AOF文件大小是上次rewrite后大小的一倍且文件大于64M时触发
• 重写虽然可以节约大量磁盘空间，减少恢复时间。但是每次重写还是有一定的负担的，因此设定Redis要满足一定条件才会进行重写
• auto-aof-rewrite-percentage：设置重写的基准值，文件达到100%时开始重写（文件是原来重写后文件的2倍时触发）
• auto-aof-rewrite-min-size：设置重写的基准值，最小文件64MB。达到这个值开始重写
• 系统载入时或者上次重写完毕时，Redis会记录此时AOF大小，设为base_size
• 如果Redis的AOF**当前大小>= base_size +base_size*100% (默认)且当前大小>=64mb(默认)**的情况下，Redis会对AOF进行重写。

c.重写流程

1. bgrewriteaof触发重写，判断是否当前有bgsave或bgrewriteaof在运行，如果有，则等待该命令结束后再继续执行
2. 主进程fork出子进程执行重写操作，保证主进程不会阻塞
3. 子进程遍历redis内存中数据到临时文件，客户端的写请求同时写入aof_buf缓冲区和aof_rewrite_buf重写缓冲区保证原AOF文件完整以及新AOF文件生成期间的新的数据修改动作不会丢失
4. 子进程写完新的AOF文件后，向主进程发信号，父进程更新统计信息
5. 主进程把aof_rewrite_buf中的数据写入到新的AOF文件
6. 使用新的AOF文件覆盖旧的AOF文件，完成AOF重写

7、优势

• 备份机制更稳健，丢失数据概率更低
• 可读的日志文本，通过操作AOF稳健，可以处理误操作

8、劣势

• 比起RDB占用更多的磁盘空间
• 恢复备份速度要慢
• 每次读写都同步的话，有一定的性能压力
• 存在个别Bug，造成恢复不能

十二、Redis持久化操作

RDB与AOF的选择

• 官方推荐两个都启用。
• 如果对数据不敏感，可以选单独用RDB。
• 不建议单独用 AOF，因为可能会出现Bug。
• 如果只是做纯内存缓存，可以都不用。

十三、Redis主从复制

1、概念

主机数据更新后根据配置和策略， 自动同步到备机的Master/Slave机制，Master以写为主，Slave以读为主

注意：

• 只能有一个主服务器，可以有多个从服务器

2、作用

• 读写分离，性能扩展
• 容灾快速恢复
  • 当一台服务器宕机，则可以快速的切换到另一台服务器中，读取其中复制的写操作

3、步骤

a.配置一主两从

1. 创建/myredis文件mkdir myredis

2. 复制redis.conf配置文件到myredis文件夹中cp /etc/redis.conf /myredis/redis.conf

3. 创建三个配置文件

   1. vim redisXXXX.conf
   2. 新建redis6379.conf
   3. 新建redis6380.conf
   4. 新建redis6381.conf

4. 三个配置文件中写入内容

   1. include /myredis/redis.conf

      pidfile /var/run/redis_XXXX.pid

      port XXXX

      dbfilename dumpXXXX.rdb

5. 启动三台Redis服务器

6. 查看系统进程，三台服务器是否启动

   

7. 连接三个服务器

   1. redis-cli -p XXX

8. 查看三台服务器运行情况

   1. info replication

9. 配从(库)不配主(库)

   1. 6379作为主机，6380、6381作为从机
   2. slaveof 127.0.0.1 XXXX配置从机，注意XXXX为主机的端口(port)号

   

   

   

注意

只能在主机上写数据，在从机上读数据

如果主机挂掉，只需要重启即可

如果从机挂架，重启后需要重新配置从机slaveof 127.0.0.1 XXXX，注意XXXX为主机的端口(port)号

4、特点

a.一主两从

1. 当从机挂掉，重新启动从服务器，并且配置从机后，此从机会从头开始加载主机的内容，即在从机挂掉后主机的写操作也会重新加载到此从机中
2. 主机挂掉，但从机依然为挂掉的主机的从机
3. 当主机挂掉重启后，新增数据，所属的从机依旧会自动添加数据

b.薪火相传

上一个Slave可以是下一个slave的Master，Slave同样可以接收其他 slaves的连接和同步请求，那么该slave作为了链条中下一个的master, 可以有效减轻master的写压力,去中心化降低风险

例如

• 6379是6380的主机
• 6380是6381的主机

c.反客为主

当一个master宕机后，后面的slave可以立刻升为master，其后面的slave不用做任何修改

用 slaveof no one 将从机变为主机

5、复制原理

• Slave启动成功连接到master后会发送一个sync命令
• Master接到命令启动后台的存盘进程，同时收集所有接收到的用于修改数据集命令，在后台进程执行完毕之后，master将传送整个数据文件到slave，以完成一次完全同步
• 全量复制：slave服务在接收到数据库文件数据后，将其存盘并加载到内存中。
• 增量复制：Master继续将新的所有收集到的修改命令依次传给slave，完成同步
• 只要是重新连接master,一次完全同步（全量复制）将被自动执行

6、哨兵模式

a.概念

反客为主的自动版，能够后台监控主机是否故障，如果故障了根据投票数自动将从库转换为主库

b.步骤

1. 调整为一主二仆模式，6379带着6380、6381

2. 自定义的/myredis目录下新建sentinel.conf文件，名字绝不能错

   1. vim sentinel.conf

3. 配置哨兵,填写内容

   1. sentinel monitor mymaster 127.0.0.1 XXXX 1
   2. 其中mymaster为监控对象起的服务器名称，1为至少有多少个哨兵同意迁移的数量，XXXX主机的端口(prot)号

4. 启动哨兵

   1. redis-sentinel sentinel.conf

5. 当主机挂掉，从机选举中产生新的主机

   1. 选择新主机的顺序

      1. 选择优先级靠前的，优先级在redis.conf中默认：replica-priority 100 ，值越小优先级越高
      2. 选择偏移量最大的，偏移量是指获得原主机数据最全的
      3. 选择runid最小的，每个redis实例启动后都会随机生成一个40位的runid

      

      

   

   2. 原主机重启后会变成从机

   

6. 复制延时

   由于所有的写操作都是先在Master上操作，然后同步更新到Slave上，所以从Master同步到Slave机器有一定的延迟，当系统很繁忙的时候，延迟问题会更加严重，Slave机器数量的增加也会使这个问题更加严重

c.故障恢复

1. 选择新主机的顺序
   1. 选择优先级靠前的，优先级在redis.conf中默认：replica-priority 100 ，值越小优先级越高
   2. 选择偏移量最大的，偏移量是指获得原主机数据最全的
   3. 选择runid最小的，每个redis实例启动后都会随机生成一个40位的runid

d.主从复制

private static JedisSentinelPool jedisSentinelPool=null;

public static  Jedis getJedisFromSentinel(){
if(jedisSentinelPool==null){
            Set<String> sentinelSet=new HashSet<>();
            sentinelSet.add("192.168.11.103:26379");//26379为sentinel启动后自动生成的端口号

            JedisPoolConfig jedisPoolConfig =new JedisPoolConfig();
            jedisPoolConfig.setMaxTotal(10); //最大可用连接数
jedisPoolConfig.setMaxIdle(5); //最大闲置连接数
jedisPoolConfig.setMinIdle(5); //最小闲置连接数
jedisPoolConfig.setBlockWhenExhausted(true); //连接耗尽是否等待
jedisPoolConfig.setMaxWaitMillis(2000); //等待时间
jedisPoolConfig.setTestOnBorrow(true); //取连接的时候进行一下测试 ping pong

jedisSentinelPool=new JedisSentinelPool("mymaster",sentinelSet,jedisPoolConfig);//mymaster为监控对象起的服务器名称
return jedisSentinelPool.getResource();

十四、集群

1、概念

Redis 集群实现了对Redis的水平扩容，即启动N个redis节点，将整个数据库分布存储在这N个节点中，每个节点存储总数据的1/N。Redis 集群通过分区（partition）来提供一定程度的可用性（availability）： 即使集群中有一部分节点失效或者无法进行通讯， 集群也可以继续处理命令请求，任何一台主机都可以作为集群的入口

无中心化集群配置解决

1. 容量不够，redis如何进行扩容?
2. 并发写操作， redis如何分摊？
3. 另外，主从模式，薪火相传模式，主机宕机，导致ip地址发生变化，应用程序中配置需要修改对应的主机地址、端口等信息

2、删除持久化数据

将rdb,aof文件都删除掉。

3、测试：配置六个实例(6379、6380、6381、6389、6390、6391)

• 6379是6389的主机
• 6380是6390的主机
• 6381是6391的主机

a.配置基本信息

• 开启daemonize yes
• Pid文件名字
• 指定端口
• Log文件名字
• Dump.rdb名字
• Appendonly 关掉或者换名字

b.redisXXXX.conf配置修改

• cluster-enabled yes 打开集群模式

• cluster-config-file nodes-6379.conf 设定节点配置文件名

• cluster-node-timeout 15000 设定节点失联时间，超过该时间（毫秒），集群自动进行主从切换

• eg：6379

  • include /home/bigdata/redis.conf

    port 6379

    pidfile "/var/run/redis_6379.pid"

    dbfilename "dump6379.rdb"

    cluster-enabled yes

    cluster-config-file nodes-6379.conf

    cluster-node-timeout 15000

c.启动6个redis服务

d.将六个节点合成一个集群

• 组合前确保所有redis实例启动，并且nodes-xxxx.conf文件生成正常

• cd /opt/redis-6.2.1/src下进行合并

• redis-cli --cluster create --cluster-replicas 1 192.168.117.100:6379 192.168.117.100:6380 192.168.117.100:6381 192.168.117.100:6389 192.168.117.100:6390 192.168.117.100:6391

  

• redis-cli -c -p XXXX通过集群的方式连接redis

4、-c 采用集群策略连接，设置数据会自动切换到响应的主机

redis-cli -c -p XXXX通过集群的方式连接redis

5、通过cluster nodes命令查看集群信息

通过cluster nodes命令查看集群信息

可以查看到当前连接的端口号、是否为主机或从机、当前服务器的主机或者从机

6、redis cluster 分配六个节点

一个集群至少要有三个主节点。

redis-cli --cluster create --cluster-replicas 1 192.168.117.100:6379 192.168.117.100:6380 192.168.117.100:6381 192.168.117.100:6389 192.168.117.100:6390 192.168.117.100:6391中的--cluster-replicas 1 表示我们希望为集群中的每个主节点创建一个从节点。

分配原则尽量保证每个主数据库运行在不同的IP地址，每个从库和主库不在一个IP地址上。

7、slots(插槽)

[OK] All nodes agree about slots configuration.

>>> Check for open slots...

>>> Check slots coverage...

[OK] All 16384 slots covered.

一个 Redis 集群包含 16384 个插槽（hash slot），数据库中的每个键都属于这 16384 个插槽的其中一个，集群使用公式 CRC16(key) % 16384 来计算键 key 属于哪个槽，其中 CRC16(key) 语句用于计算键 key 的 CRC16 校验和

根据设置的key，来计算key属于哪个插槽，则这个key中的数据就存放在哪个插槽中

集群中的每个节点负责处理一部分插槽

例如上面六个节点的集群中，有三个主机，则三个主机均分16384个插槽

8、在集群中录入值

eg：在6379中创建键k1，显示k1存放在6381中，则自动切换到6381中

注意

• 创建键只能在主机中创建，并且只能自动切换到键存放的相应的主机中
• 可以在任意的主机中创建键，会自动切换主机

a.注意

不在一个slot下的键值，不能使用mget,mset等多键操作

可以通过{}来定义组的概念，从而使key中{}内相同内容的键值对放到一个slot中去

9、查询集群中的值

eg：获取在6379中创建的键k1

CLUSTER GETKEYSINSLOT <slot><count> 返回 count 个 slot 槽中的键

注意

• 只能看端口号对应的slot槽范围内的键

10、故障恢复

如果主节点下线，15秒后，从节点自动升为主节点

主节点恢复后，主节点回来变成从机

如果某一段插槽的主从都挂掉，而redis.conf中的参数 cluster-require-full-coverage 为yes ，那么 ，整个集群都挂掉

如果某一段插槽的主从都挂掉，而redis.conf中的参数 cluster-require-full-coverage 为no ，那么，该插槽数据全都不能使用，也无法存储

11、集群的Jedis开发

即使连接的不是主机，集群会自动切换主机存储。主机写，从机读

无中心化主从集群。无论从哪台主机写的数据，其他主机上都能读到数据

        //创建对象
        HostAndPort hostAndPort = new HostAndPort("192.168.117.100", 6379);
        JedisCluster jedisCluster = new JedisCluster(hostAndPort);
        //进行操作
        jedisCluster.set("k1","v1");
        String k1 = jedisCluster.get("k1");
        System.out.println(k1);
        jedisCluster.close();

12、Redis集群的好处

• 实现扩容
• 分摊压力
• 无中心配置相对简单

13、Redis集群的不足

• 多键操作是不被支持的
• 多键的Redis事务是不被支持的。lua脚本不被支持
• 由于集群方案出现较晚，很多公司已经采用了其他的集群方案，而代理或者客户端分片的方案想要迁移至redis cluster，需要整体迁移而不是逐步过渡，复杂度较大

十五、Redis应用问题解决(重要)

1、缓存穿透

a.问题描述

1. 应用服务器压力变大：key对应的数据在数据源并不存在，每次针对此key的请求从缓存获取不到，请求都会压到数据源，从而可能压垮数据源
2. redis命中率降低，redis查询不到数据
3. 一直查询数据库，导致数据库压力过大
4. 最后导致服务器瘫痪

b.解决方案

1. 对空值缓存：如果一个查询返回的数据为空（不管是数据是否不存在），仍然把这个空结果（null）进行缓存，设置空结果的过期时间会很短，最长不超过五分钟
2. 设置可访问的名单（白名单）：使用bitmaps类型定义一个可以访问的名单，名单id作为bitmaps的偏移量，每次访问和bitmap里面的id进行比较，如果访问id不在bitmaps里面，进行拦截，不允许访问。
3. 采用布隆过滤器（Bloom Filter）：实际上是一个很长的二进制向量(位图)和一系列随机映射函数（哈希函数）。布隆过滤器可以用于检索一个元素是否在一个集合中。它的优点是空间效率和查询时间都远远超过一般的算法，缺点是有一定的误识别率和删除困难。
   1. 将所有可能存在的数据哈希到一个足够大的bitmaps中，一个一定不存在的数据会被 这个bitmaps拦截掉，从而避免了对底层存储系统的查询压力。
4. 进行实时监控：当发现Redis的命中率开始急速降低，需要排查访问对象和访问的数据，和运维人员配合，可以设置黑名单限制服务

2、缓存击穿

a.问题描述

redis中某个key过期，但瞬间有大量的访问使用此key，导致访问缓存失败，从而转向访问数据库，导致数据库访问压力瞬间增加

b.解决方案

1. 预先设置热门数据：在redis高峰访问之前，把一些热门数据提前存入到redis里面，加大这些热门数据key的时长
2. 实时调整：现场监控哪些数据热门，实时调整key的过期时长
3. 使用锁：
   1. 就是在缓存失效的时候（判断拿出来的值为空），不是立即去load db
   2. 先使用缓存工具的某些带成功操作返回值的操作（比如Redis的SETNX）去set一个mutex key
   3. 当操作返回成功时，再进行load db的操作，并回设缓存，最后删除mutex key
   4. 当操作返回失败，证明有线程在load db，当前线程睡眠一段时间再重试整个get缓存的方法

3、缓存雪崩

a.问题描述

redis中大量key过期，但瞬间有大量的访问使用这些key，导致访问缓存失败，从而转向访问数据库，导致数据库访问压力瞬间增加

缓存雪崩与缓存击穿的区别

• 缓存雪崩针对很多key缓存
• 缓存击穿针对某一个key

正常访问

缓存失效瞬间

b.解决方案

1. 构建多级缓存架构：nginx缓存 + redis缓存 +其他缓存（ehcache等）
2. 使用锁或队列：用加锁或者队列的方式保证来保证不会有大量的线程对数据库一次性进行读写，从而避免失效时大量的并发请求落到底层存储系统上。不适用高并发情况
3. 设置过期标志更新缓存：记录缓存数据是否过期（设置提前量），如果过期会触发通知另外的线程在后台去更新实际key的缓存
4. 将缓存失效时间分散开：比如我们可以在原有的失效时间基础上增加一个随机值，比如1-5分钟随机，这样每一个缓存的过期时间的重复率就会降低，就很难引发集体失效的事件

4、分布式锁

a.问题描述

由于分布式系统多线程、多进程并且分布在不同机器上，使原单机部署情况下的并发控制锁策略失效，单纯的Java API并不能提供分布式锁的能力。为了解决这个问题就需要一种跨JVM的互斥机制来控制共享资源的访问，这就是分布式锁要解决的问题

• 分布式锁主流的实现方案：

  1. 基于数据库实现分布式锁
  2. 基于缓存（Redis等）
  3. 基于Zookeeper

• 每一种分布式锁解决方案都有各自的优缺点：

• 性能：redis最高

• 可靠性：zookeeper最高

b.解决方案：使用Redis实现分布式锁

加锁

• EX second ：设置键的过期时间为 second 秒。 SET key value EX second 效果等同于 SETEX key second value
• PX millisecond ：设置键的过期时间为 millisecond 毫秒。 SET key value PX millisecond 效果等同于 PSETEX key millisecond value
• NX ：只在键不存在时，才对键进行设置操作。 SET key value NX 效果等同于 SETNX key value
• XX ：只在键已经存在时，才对键进行设置操作
• set key value nx ex second：对key上锁，并且设置过期时间为second秒

释放锁

• del <key>

十六、Redis6.0新功能

1、1.1. ACL

a.简介

Redis ACL是Access Control List（访问控制列表）的缩写，该功能允许根据可以执行的命令和可以访问的键来限制某些连接。

在Redis 5版本之前，Redis 安全规则只有密码控制 还有通过rename 来调整高危命令比如 flushdb ， KEYS* ， shutdown 等。Redis 6 则提供ACL的功能对用户进行更细粒度的权限控制 ：

（1）接入权限:用户名和密码

（2）可以执行的命令

（3）可以操作的 KEY

b.命令

2、1.1. IO多线程

a.简介

b.原理架构

3、1.1. 工具支持 Cluster

4、…

Redis6新功能还有：

1. RESP3新的 Redis 通信协议：优化服务端与客户端之间通信
2. Client side caching客户端缓存：基于 RESP3 协议实现的客户端缓存功能。为了进一步提升缓存的性能，将客户端经常访问的数据cache到客户端。减少TCP网络交互。
3. Proxy集群代理模式：Proxy 功能，让 Cluster 拥有像单实例一样的接入方式，降低大家使用cluster的门槛。不过需要注意的是代理不改变 Cluster 的功能限制，不支持的命令还是不会支持，比如跨 slot 的多Key操作。
4. Modules API：Redis 6中模块API开发进展非常大，因为Redis Labs为了开发复杂的功能，从一开始就用上Redis模块。Redis可以变成一个框架，利用Modules来构建不同系统，而不需要从头开始写然后还要BSD许可。Redis一开始就是一个向编写各种系统开放的平台。

用高并发情况
3. 设置过期标志更新缓存：记录缓存数据是否过期（设置提前量），如果过期会触发通知另外的线程在后台去更新实际key的缓存
4. 将缓存失效时间分散开：比如我们可以在原有的失效时间基础上增加一个随机值，比如1-5分钟随机，这样每一个缓存的过期时间的重复率就会降低，就很难引发集体失效的事件