Redis学习笔记--尚硅谷
一、NoSQL
NoSQL数据库概述
解决各种问题用到的技术
解决功能性的问题:ava、Jsp、RDBMS、Tomcat、HTML、Linux、JDBC、SVNe
解决扩展性的问题:Struts、Spring、SpringMVC、Hibernate、Mybatise
解决性能的问题:NoSQL、Java线程、Hadoop、Nginx、MQ、ElasticSearch
·不遵循SQL标准
·不支持ACID
·远超于SQL性能
使用场景
对数据的高并发
海量数据的读写
读数据访问的高扩展性
各种NoSQL数据库
Memcache:
Redis:
MongoDB:
HBase:
Neo4j(图关系型数据库):
二、Redis数据库安装
1. 安装条件
Redis官网: www.Redis.io
安装环境: CentOS 7 （建议安装在Liunx）、 GCC编译环境
2.安装GCC编译环境
yum install centos-release-scl scl-utils-build
yum install -y devtoolset-8-toolchain scl
enable devtoolset-8 bash
输入版本命令检查是否成功：
gcc -v
3.安装Redis
下载最新的Release版本的Redis放到/opt目录下 下载命令： wget https://download.redis.io/releases/redis-6.2.6.tar.gz
解压下载的gz包： tar -zxvf redis-6.2.6.tar.gz (不能报错)
解压完成后生成 redis-6.2.6目录
进入生成的redis-6.2.6目录进行编译: 执行make命令， 如果编译过程报错会终止编译 （解决方案：运行make distclean）
输入make test检查编译是否成功 (由于版本问题可能低版本无法执行，则跳过)
输入make install安装刚编译的文件，默认安装目录 /usr/local/bin
4.开启Redis服务
前台启动
必须时刻开着，关闭或退出页面服务也会关闭： 命令 redis-server
后台启动
开启后只能用命令关闭, 关闭终端也不会关闭服务
将redis-6.2.6中的redis.conf文件先备份一份，并使用命令修改启动设置 daemonize no设置为yes
vi /redis-6.2.6/redis.conf (在只读模式中输入/ daemonize可以查询位置)
修改完成后使用命令 redis-service redis.conf(修改后的)启动Redis
使用ps -ef|grep redis命令能查看名称为redis的进程
redis-cli能进入客服端
用ping命令来检查是否运行正常
关闭
客服端关闭：shutdown
单实例关闭：redis-cli shutdown
三、Redis介绍
简介
Redis默认有16个库， 进入时默认使用的是第0个数据库
使用 select [index] 可以切换
dbsize 查看当前Key-Value数量
flushdb 清空数据库
flushdb 清空所有数据库
Redis所用的技术是 单线程 + 多路IO复用
Memcache： 多线程 + 锁
多路复用是指使用一个线程来检查多个文件描述符（Socket）的就绪状态，比如调用select和poll函数，传入多个文件描述符，如果有一个文件描述符就绪，则 返回，否则阻塞直到超时。得到就绪状态后进行真正的操作可以在同一个线程里执行，也可以启动线程执行（比如使用线程池）
原子性
所谓原子操作是指不会被线程调度机制打断的操作；
要么都成功才会成功，有一个失败就都失败
四、数据类型
1.Key
Redis中的所有数据都是以键值对形式进行存储的，每一种类型的数据都要有一个键值对来对应。
**keys ** 查看所有的key
exists [key] 查看是否有[key] 返回1存在，0不存在
type [key] 查看key的类型
delete [key] 删除指定的key
unlink [key] 根据value选择非阻塞删除 (仅将keys从keyspace元数据中删除，真正的删除会在后续异步操作)
expire [key] [s] 设置过期时间，单位 秒
ttl [key] 查看剩余过期时间 （-1）表示无过期时间 （-2）表示已经过期
2.string
String是Redis最基本的类型
String类型是二进制安全的。意味着Redis的string可以包含任何数据
String类型是Redis最基本的数据类型，一个Redis中字符串value最多可以是512M
数据结构：
String的数据结构为简单动态字符串(Simple Dynamic String,缩写SDS)。是可以修改的字符串，内部结构实现上类似于Java的ArrayList，采用预分配冗余空间的 方式来减少内存的频繁分配.
如图中所示，内部为当前字符串实际分配的空间capacity一般要高于实际字符串长度len。当字符串长度小于1M时，扩容都是加倍现有的空间，如果超过1M，扩 容时一次只会多扩1M的空间。需要注意的是字符串最大长度为512M。
set [key] [value] 添加键值对
**get [key] ** 查询对应键值
**append [key] [value] ** 将给定的[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] [起始位置] [结束位置] 获得值的范围，类似java中的substring，包括前后
setrange [key] [起始位置] [value] 用 [value]覆写[key]所储存的字符串值，从[起始位置]开始(索引从0开始)。
setex [key] [过期时间] [value] 设置键值的同时，设置过期时间，单位秒。
getset [key] [value] 以新换旧，设置了新值同时获得旧值。
3.List
特点: 单键多值
数据结构：快速链表quickList (双链表)
首先在列表元素较少的情况下会使用一块连续的内存存储，这个结构是ziplist，也即是压缩列表。
它将所有的元素紧挨着一起存储，分配的是一块连续的内存。
当数据量比较多的时候才会改成quicklist。
因为普通的链表需要的附加指针空间太大，会比较浪费空间。比如这个列表里存的只是int类型的数据，结构上还需要两个额外的指针prev和next。
Redis将链表和ziplist结合起来组成了quicklist。也就是将多个ziplist使用双向指针串起来使用。这样 既满足了快速的插入删除性能，又不会出现太大的空间冗 余。
l开头代表从左开始，r开头代表从右开始
lpush/rpush [][] [key] [value1] [value2] [value3] … 一键多值，插入数据
lpop/rpop [key] 弹出数据并返回
rpoplpush [key1] [key2] 从key1的右边弹出数据加入到key2的左边
lrange [key] [start] [end] 查看列表索引start到end的值， end为-1时表示最后一个
lindex [key] [index] 按照索引获取数据
llen [key] 获取key对应的列表的长度
linsert [key] before/after [value] [newValue] 在value之前/之后添加新值
lrem [key] [num] [value] 从左边开始往右删除num个value
lset [key] [index] [value] 将下标为index的值替换为value
4.Set
Redis set对外提供的功能与list类似是一个列表的功能，特殊之处在于set是可以自动排重的，当你 需要存储一个列表数据，又不希望出现重复数据时，set是一个很好的选择，并且set提供了判断某个 成员是否在一个set集合内的重要接口，这个也是list所不能提供的。
Redis的Set是string类型的无序集合。它底层其实是一个value为null的hash表，所以添加，删除，查 找的复杂度都是O(1)。
一个算法，随着数据的增加，执行时间的长短，如果是O(1)，数据增加，查找数据的时间不变
数据结构
Set数据结构是dict字典，字典是用哈希表实现的。
Java中HashSet的内部实现使用的是HashMap，只不过所有的value都指向同一个对象。Redis的set结构也是一样，它的内部也使用hash结构，所有的value都 指向同一个内部值。
sadd [key] [value1] [value2]… 将数据添加到key对应的集合中，不能重复
smembers [key] 查询集合中所有的数据
sismember [key] [value] 判断key集合中是否有value，返回1或0
scard [key] 返回集合中的元素个数
srem [key] [value1] [value2]… 删除集合中的元素
spop [key] 随机从集合中突出一个值
srandmember [key] [n] 随机从集合中获取n个值，但不删除
smove [key1] [key2] [value] 从key1中取出value加入到key2中
sinter [key1] [key2] 返回两个集合的交集元素
sunion [key1] [key2] 返回两个集合的并集
sdiff [key1] [key2] 返回两个集合的差集 (key1 - key2， key1中有的但是key2中没有的)
5.Hash
Redis hash 是一个键值对集合
Redis hash是一个string类型的field和value的映射表，hash特别适合用于存储对象
通过 key(用户ID) + field(属性标签) 就可以操作对应属性数据了，既不需要重复存储数据，也不会带来序列化和并发修改控制的问题
Hash类型对应的数据结构是两种：ziplist（压缩列表），hashtable（哈希表）。当field-value长度较短且个数较少时，使用ziplist，否则使用hashtable。
Hash类型对应的数据结构是两种：ziplist（压缩列表），hashtable（哈希表）。当field-value长度较短且个数较少时，使用ziplist，否则使用hashtable。
hset [key] [field] [value]… 给key对应的hash添加键为field值为value的键值对
hget [key] [field] 从集合中取出键为field的键值对
hmget [key] [field1] 获取多个键值对的值
hdel key [field1] [field2]… 删除一个或多个哈希表字段
hexists [key] [field] 查看键field是否存在
hkeys [key] 列出所有key对应的hash的键值对的键
hvals [key] 列出所有key对应的hash的键值对的值
hgetall [key] 获取hash中所有的键值对
hincrby [key] [field] [increment] 给field对应的值添加增量
hsetnx [key] [field] [value] 只有在字段field不存在时，设置hash值
hlen key 获取hash中的字段数
6.zset有序集合
Redis有序集合zset与普通集合set非常相似，是一个没有重复元素的字符串集合。
不同之处是有序集合的每个成员都关联了一个**评分（ ** score ）,这个评分（score）被用来按照从最低分到最高分的方式排序集合中的成员。集合的成员 是唯 一的，但是评分可以是重复了 。
因为元素是有序的, 所以你也可以很快的根据评分（score）或者次序（position）来获取一个范围的元素。
访问有序集合的中间元素也是非常快的,因此你能够使用有序集合作为一个没有重复成员的智能列表。
数据结构
SortedSet(zset)是Redis提供的一个非常特别的数据结构，一方面它等价于Java的数据结构Map
zset底层使用了两个数据结构
（1）hash，hash的作用就是关联元素value和权重score，保障元素value的唯一性，可以通过元素value找到相应的score值。
（2）跳跃表，跳跃表的目的在于给元素value排序，根据score的范围获取元素列表。
zadd [key] [score1] [value1] [score2] [value2]… 将一个或多个 member 元素及其 score 值加入到有序集 key 当中。
zrange [key] [start] [stop] [withscores] 返回有序集 key 中，下标在start stop之间的元素带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开始。
7. Bitmaps
Bitmaps本身不是一种数据类型， 实际上它就是字符串（key-value） ， 但是它可以对字符串的位进行操作。
value中的值只有1和0, 每个值占用1个bit, 字符串最大512M, 所以长度大约为2^32次方
setbit [key] [offset] [1/0] 将offset设置为0或1
getbit [key] [offset] 获取offset位置的值
bitcount [key] 统计被设置为1的bit数
bitop [and/or/not/xor] [destkey] [key1] [key2] … bitop是一个复合操作， 它可以做多个Bitmaps的and(交集)、 or(并 集) 、not(非) 、 xor(异或) 操作并将结果保存在destkey中
8.HyperLogLog
Redis HyperLogLog 是用来做基数统计的算法，HyperLogLog 的优点是，在输入元素的数量或者体积非常非常大时，计算基数所需的 空间总是固定 的、并且是很小的。
在 Redis 里面，每个 HyperLogLog 键只需要花费 12 KB 内存，就可以计算接近 2^64 个不同元素的基 数。这和计算基数时，元素越多 耗费内存就越多的集合形成鲜明对比。
但是，因为 HyperLogLog 只会根据输入元素来计算基数，而不会储存输入元素本身，所以 HyperLogLog 不能像集合那样，返回输入 的各个元素。
pfadd [key] [value1] [value2] … 添加指定元素到 HyperLogLog 中
pfcount [key] 返回给定 HyperLogLog 的基数估算值。
pfmerge [destkey] [sourcekey1] [sourcekey2] 将多个 HyperLogLog 合并为一个 destkey
五、发布与订阅
Redis 发布订阅 (pub/sub) 是一种消息通信模式：发送者 (pub) 发送消息，订阅者 (sub) 接收消息。
Redis 客户端可以订阅任意数量的频道。
subscribe [channel] 客户端订阅频道channel
publish [channel] [message] 客户段向频道发送信息，其他订阅频道的客户端能收到此信息
六、外部连接Redis
#### 条件
1.修改配置文件redis.conf
protected-mode no 将本机保护模式protected-mode设置为no, 默认为yes
port 6307 设置端口号
注释掉bind=127.0.0.1 默认情况bind=只能接受本机的访问请求。不写的情况下，无限制接受任何ip地址的访问
2.关闭防火墙
使用命令 systemctl status firewalld 查看防火墙状态
开启防火墙:
systemctl start firewalld
关闭防火墙:
systemctl stop firewalld
关闭防火墙后，外界可以访问主机
RedisPlus连接
RedisPlus是一个免费的Redis可视化图形工具，方便操作和查看Redis
七、Jedis
1.导入Jedis相关的jar包
maven依赖:
<dependency>
<groupId>redis.clientsgroupId>
<artifactId>jedisartifactId>
<version>3.2.0version>
dependency>
2.连接Redis
Jedis jedis = new Jedis("hostip", port); // (String hostip, int port )
构造方法第一个参数是Redis所在主机的ip地址，第二个是端口号
3.使用Jedis进行相关操作
Jedis类中有着对应Redis命令的方法，可以调用这些方法进行操作
public class RedisTest {
@Test
public void test1() {
Jedis jedis = new Jedis("192.168.135.100", 6379);
jedis.set("k1", "String");
Set<String> keys = jedis.keys("*");
System.out.println(keys);
Set<String> s1 = jedis.smembers("s1");
System.out.println(s1);
}
}
4.Jedis模拟验证码
生成验证码
public String generateVerification(String phoneNum) {
StringBuilder code = new StringBuilder();
String count = null;
Jedis jedis = new Jedis("192.168.135.100", 6379);
String codeKey = phoneNum + ":code";
String countKey = phoneNum + ":count";
// 获取验证码次数
count = jedis.get(countKey);
//判断次数
if (count == null) {
jedis.set(countKey, "3");
jedis.close();
return generateVerification(phoneNum);
} if (Integer.parseInt(count) > 0) {
//生成六位数验证码
Random random = new Random();
for (int i = 0; i < 6; i++) {
code.append(String.valueOf(random.nextInt(10)));
}
//将生成验证码的次数减一
jedis.decr(countKey);
//验证码加入到key中
jedis.setex(codeKey, 120, code.toString());
System.out.println(jedis.get(codeKey));
} else {
System.out.println("生成验证码次数超过三次");
jedis.close();
return "";
}
jedis.close();
return code.toString();
}
获取验证码
public String getVerificationCode(String phoneNum) {
Jedis jedis = new Jedis("192.168.135.100", 6379);
String codeKey = phoneNum + ":code";
String countKey = phoneNum + ":count";
if (jedis.ttl(codeKey) == -2) {
jedis.close();
System.out.println("验证码已过期或未生成验证码");
return "";
}
String code = jedis.get(codeKey);
System.out.println("验证码:" + code);
return code;
}
@Test
public void test1() {
String phoneNum = "10086";
generateVerification(phoneNum);
getVerificationCode(phoneNum);
}
八、SpringBoot与Redis整合
依赖导入
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-data-redisartifactId>
dependency>
<dependency>
<groupId>org.apache.commonsgroupId>
<artifactId>commons-pool2artifactId>
<version>2.6.0version>
dependency>
<dependency>
<groupId>com.fasterxml.jackson.coregroupId>
<artifactId>jackson-databindartifactId>
<version>2.11.4version>
dependency>
SpringBoot配置类
@EnableCaching
@Configuration
public class RedisConfig extends CachingConfigurerSupport {
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
RedisTemplate<String, Object> template = new RedisTemplate<>();
RedisSerializer<String> redisSerializer = new StringRedisSerializer();
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
template.setConnectionFactory(factory);
//key序列化方式
template.setKeySerializer(redisSerializer);
//value序列化
template.setValueSerializer(jackson2JsonRedisSerializer);
//value hashmap序列化
template.setHashValueSerializer(jackson2JsonRedisSerializer);
return template;
}
@Bean
public CacheManager cacheManager(RedisConnectionFactory factory) {
RedisSerializer<String> redisSerializer = new StringRedisSerializer();
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
//解决查询缓存转换异常的问题
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
// 配置序列化（解决乱码的问题）,过期时间600秒
RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
.entryTtl(Duration.ofSeconds(600))
.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
.disableCachingNullValues();
RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
.cacheDefaults(config)
.build();
return cacheManager;
}
}
application.properties配置
# 应用名称
spring.application.name=springbootredis
#Redis服务器地址
spring.redis.host=192.168.135.100
#Redis服务器连接端口
spring.redis.port=6379
#Redis数据库索引（默认为0）
spring.redis.database= 0
#连接超时时间（毫秒）
spring.redis.timeout=1800000
#连接池最大连接数（使用负值表示没有限制）
spring.redis.lettuce.pool.max-active=20
#最大阻塞等待时间(负数表示没限制)
spring.redis.lettuce.pool.max-wait=-1
#连接池中的最大空闲连接
spring.redis.lettuce.pool.max-idle=5
#连接池中的最小空闲连接
spring.redis.lettuce.pool.min-idle=0
九、事务
Redis事务定义
Redis事务是一个单独的隔离操作：事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。
Redis事务的主要作用就是串联多个命令防止别的命令插队
Redis 事务可以一次执行多个命令， 并且带有以下三个重要的保证：
- 批量操作在发送 EXEC 命令前被放入队列缓存。
- 收到 EXEC 命令后进入事务执行，事务中任意命令执行失败，其余的命令依然被执行。
- 在事务执行过程，其他客户端提交的命令请求不会插入到事务执行命令序列中。
一个事务从开始到执行会经历以下三个阶段：
- 开始事务。
- 命令入队。
- 执行事务。
Multi、Exec、discard
| 命令 | 描述 |
|---|---|
| discard | 取消事务，放弃执行事务块内的所有命令。 |
| exec | 执行所有事务块内的命令。 |
| multi | 标记一个事务块的开始。 |
| UNWATCH | 取消 WATCH 命令对所有 key 的监视。 |
| watch [key1]… | 监视一个(或多个) key ，如果在事务执行之前这个(或这些) key 被其他命令所改动，那么事务将被打断。 |
事务的错误处理
组队中某个命令出现了报告错误，执行时整个的所有队列都会被取消。
如果执行阶段某个命令报出了错误，则只有报错的命令不会被执行，而其他的命令都会执行，不会回滚。
锁
乐观锁
乐观锁(Optimistic Lock),每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。乐观锁适用于多读的应用类型，这样可以提高吞吐量。Redis就是利用这种check-and-set机制实现事务的。
悲观锁
悲观锁(Pessimistic Lock)，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会block直到它拿到锁。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁
Redis事务三大特性
-
单独的隔离操作
事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。
-
没有隔离级别的概念
队列中的命令没有提交之前都不会实际被执行，因为事务提交前任何指令都不会被实际执行
-
不保证原子性
事务中如果有一条命令执行失败，其后的命令仍然会被执行，没有回滚
十、秒杀测试案例
测试工具
Apache Bench
安装
- yum -y install httpd-tools
测试命令
- ab -n 500 -c 100 -p postfile -T application/x-www-form-urlencoded http://192.168.1.105:8080/Seckill/doseckill
| 参数 | 描述 |
|---|---|
| -n | 测试次数 |
| -c | 并发线程个数 |
| -p | POST数据文件(参数文件) |
| -T | Content-type头信息 |
并发控制
- 请求次数的量巨大，避免重复创建对象导致时间问题，使用连接池来解决超时问题
public static JedisPool getJedisPoolInstance() {
if (null == jedisPool) {
synchronized (JedisPoolUtil.class) {
if (null == jedisPool) {
JedisPoolConfig poolConfig = new JedisPoolConfig();
poolConfig.setMaxTotal(200);
poolConfig.setMaxIdle(32);
poolConfig.setMaxWaitMillis(100*1000);
poolConfig.setBlockWhenExhausted(true);
poolConfig.setTestOnBorrow(true); // ping PONG
jedisPool = new JedisPool(poolConfig, "192.168.135.100", 6379, 60000 );
}
}
}
return jedisPool;
}
以常规的形式去测试，会发现在请求数大于秒杀库存的情况下，会出现库存变为负值的情况
- 加入事务控制(乐观锁)来优化案例
//秒杀过程
public static boolean doSecKill(String uid,String prodid) throws IOException {
//1 uid和prodid非空判断
if (uid == null || prodid == null) {
return false;
}
//2 连接redis
//可以解决超时问题
JedisPool pool = JedisPoolUtil.getJedisPoolInstance();
Jedis jedis = pool.getResource();
//通过连接池得到jedis对象
//3 拼接key
// 3.1 库存key
String kcKey = "sk:" + prodid + ":qt";
// 3.2 秒杀成功用户key
String userKey = "sk:" + prodid + ":user";
//监视库存
jedis.watch(kcKey);
//4 获取库存，如果库存null，秒杀还没有开始
String kc = jedis.get(kcKey);
if (kc == null) {
System.out.println("秒杀还没开始");
jedis.close();
return false;
}
// 5 判断用户是否重复秒杀操作
if (jedis.sismember(uid, userKey)) {
System.out.println("已经秒杀过不能再秒杀了");
jedis.close();
return false;
}
//6 判断如果商品数量，库存数量小于1，秒杀结束
if (Integer.parseInt(kc) <= 0) {
System.out.println("秒杀已结束");
jedis.close();
return false;
}
//7 秒杀过程
//使用事务
Transaction transaction = jedis.multi();
//组队操作
//7.1 库存-1
//7.2 把秒杀成功用户添加清单里面
transaction.decr(kcKey);
transaction.sadd(userKey, uid);
//执行
List<Object> list = transaction.exec();
if (list != null && list.size() != 0) {
System.out.println("秒杀成功");
} else {
System.out.println("秒杀失败");
}
//7.1 库存-1
//7.2 把秒杀成功用户添加清单里面
/*jedis.decr(kcKey);
jedis.sadd(userKey, uid);*/
jedis.close();
return true;
}
这种方式在库存与请求数差别不大的时候可能会导致冗余库存， 用悲观锁可以有效解决这个问题
- 使用lua脚本实现悲观锁
static String secKillScript ="local userid=KEYS[1];\r\n" +
"local prodid=KEYS[2];\r\n" +
"local qtkey='sk:'..prodid..\":qt\";\r\n" +
"local usersKey='sk:'..prodid..\":user\";\r\n" +
"local userExists=redis.call(\"sismember\",usersKey,userid);\r\n" +
"if tonumber(userExists)==1 then \r\n" +
" return 2;\r\n" +
"end\r\n" +
"local num= redis.call(\"get\" ,qtkey);\r\n" +
"if tonumber(num)<=0 then \r\n" +
" return 0;\r\n" +
"else \r\n" +
" redis.call(\"decr\",qtkey);\r\n" +
" redis.call(\"sadd\",usersKey,userid);\r\n" +
"end\r\n" +
"return 1";
static String secKillScript2 =
"local userExists=redis.call(\"sismember\",\"{sk}:0101:usr\",userid);\r\n" +
" return 1";
public static boolean doSecKill(String uid,String prodid) throws IOException {
JedisPool jedispool = JedisPoolUtil.getJedisPoolInstance();
Jedis jedis=jedispool.getResource();
//String sha1= .secKillScript;
String sha1= jedis.scriptLoad(secKillScript);
Object result= jedis.evalsha(sha1, 2, uid,prodid);
String reString=String.valueOf(result);
if ("0".equals( reString ) ) {
System.err.println("已抢空！！");
}else if("1".equals( reString ) ) {
System.out.println("抢购成功！！！！");
}else if("2".equals( reString ) ) {
System.err.println("该用户已抢过！！");
}else{
System.err.println("抢购异常！！");
}
jedis.close();
return true;
}
十一、持久化储存
RDB
Redis会单独创建（fork）一个子进程来进行持久化，会先将数据写入到 一个临时文件中，待持久化过程都结束了，再用这个临时文件替换上次持久化好的文 件整个过程中，主进程是不进行任何IO操作的，这就确保了极高的性能 如果需要进行大规模数据的恢复，且对于数据恢复的完整性不是非常敏感，那RDB方 式要比AOF方式更加的高效。RDB的缺点是最后一次持久化后的数据可能丢失。
RDB持久化是指在指定的时间间隔内将内存中的数据集快照写入磁盘。也是默认的持久化方式，这种方式是就是将内存中数据以快照的方式写入到二进制文件 中,默认的文件名为dump.rdb
触发方式
save触发方式
该命令会阻塞当前Redis服务器，执行save命令期间，Redis不能处理其他命令，直到RDB过程完成为止。
bgsave触发方式
执行该命令时，Redis会在后台异步进行快照操作，快照同时还可以响应客户端请求
自动触发
在redis.conf配置文件中修改，这里是用来配置触发 Redis的 RDB 持久化条件，也就是什么时候将内存中的数据保存到硬盘。比如“save m n”。表示m秒内数据 集存在n次修改时，自动触发bgsave
优势与劣势
优势
（1）RDB文件紧凑，全量备份，非常适合用于进行备份和灾难恢复。
（2）生成RDB文件的时候，redis主进程会fork()一个子进程来处理所有保存工作，主进程不需要进行任何磁盘IO操作。
（3）RDB 在恢复大数据集时的速度比 AOF 的恢复速度要快。
劣势
RDB快照是一次全量备份，存储的是内存数据的二进制序列化形式，存储上非常紧凑。当进行快照持久化时，会开启一个子进程专门负责快照持久化，子进程会 拥有父进程的内存数据，父进程修改内存子进程不会反应出来，所以在快照持久化期间修改的数据不会被保存，可能丢失数据。
AOF
以日志的形式来记录每个写操作（增量保存），将Redis执行过的所有写指令记录下来(读操作不记录)， 只许追加文件但不可以改写文件，redis启动之初会读 取该文件重新构建数据，换言之，redis 重启的话就根据日志文件的内容将写指令从前到后执行一次以完成数据的恢复工作
AOF默认不开启，可以在redis.conf中配置文件名称，默认为 appendonly.aof 修改默认的appendonly no，改为yes
AOF和RDB同时开启，系统默认取AOF的数据（数据不会存在丢失）
AOF持久化流程
（1）客户端的请求写命令会被append追加到AOF缓冲区内；
（2）AOF缓冲区根据AOF持久化策略[always,everysec,no]将操作sync同步到磁盘的AOF文件中；
（3）AOF文件大小超过重写策略或手动重写时，会对AOF文件rewrite重写，压缩AOF文件容量；
（4）Redis服务重启时，会重新load加载AOF文件中的写操作达到数据恢复的目的；
频率设置
appendfsync always 始终同步，每次Redis的写入都会立刻记入日志；性能较差但数据完整性比较好
appendfsync everysec 每秒同步，每秒记入日志一次，如果宕机，本秒的数据可能丢失。
appendfsync no redis不主动进行同步，把同步时机交给操作系统
优势与劣势
优势
-
备份机制更稳健，丢失数据概率更低。
-
可读的日志文本，通过操作AOF稳健，可以处理误操作。
劣势
-
比起RDB占用更多的磁盘空间。
-
恢复备份速度要慢。
-
每次读写都同步的话，有一定的性能压力。
-
存在个别Bug，造成恢复不能。
十二、主从复制
概念
Master主机: 读写操作，只允许一个
Slave主机: 只读不能写，可以多个
准备工作
关闭安全模式: redis.conf中的protected-mode改为 fasle,否则不能进行主从复制
新建redis6379.conf,并引用redis.conf的配置
复制多份redis6379.conf，分别命名为redis6379.conf, redis6380.conf, redis6381.conf, 修改相应的配置
其中redis6379.conf作为主机，其他作为从机，分别使用多个终端启动三个redis服务
使用 info replication 命令查看信息，三个redis的role均为 master 主机
在两个从机的redis-cli中输入 slaveof 命令作为主机的从机
两个从机的 info replication 命令显示role为 slave, 并可显示主机状态和信息，主机也可查看从机的状态和信息。
薪火相传
一个从机下面可以连接多个从机,当父从机挂掉之后，后面的子从机也会挂掉
反客为主
对一个从属服务器执行命令 SLAVEOF NO ONE 将使得这个从属服务器关闭复制功能，并从从属服务器转变回主服务器，原来同步所得的数据集不会被丢弃。
如果主服务器down机，对一个从服务器运行 SLAVEOF NO ONE命令会升级为主机，该服务器下的从机继续正常运行。
哨兵模式
哨兵可以直接在主服务器down时，选择出一个从服务器，将他们作为新的主服务器，其余的从服务器跟随新的主服务器。
down掉的旧主重新启动会变成新主的从服务器
设置哨兵
创建一个sentinel.conf并写入以下内容
sentinel monitor < master-name > < ip > < port > < count >
监控的主节点的名字、IP和端口，最后一个count的意思是有几台 Sentinel 发现有问题，就会发生故障转移，例如 配置为2，代表至少有2个 Sentinel 节点认为主节点不可达，那么这个不可达的判定才是客观的。对于设置的越小，那么达到下线的条件越宽松，反之越严格。一般建议将其设置为 Sentinel 节点的一半加1
例如: sentinel monitor mymaster 127.0.0.1 6379 1
使用命令 **redis-sentinel /myredis/sentinel.conf ** 启动哨兵
哨兵服务
当主机down掉之后 ，根据从机的slave-priority大小选出新的主机，值越小优先级越高。
down掉的旧主重新启动会变成新主的从服务器
集群
Redis 集群实现了对Redis的水平扩容，即启动N个redis节点，将整个数据库分布存储在这N个节点中，每个节点存储总数据的1/N。
Redis 集群通过分区（partition）来提供一定程度的可用性（availability）： 即使集群中有一部分节点失效或者无法进行通讯， 集群也可以继续处理命令请求。
搭建
准备6个redis，分别为redis7001.conf,redis7002.conf, redis7003.conf redis7011.conf, redis7012.conf, redis7013.conf
三个作为主服务器，三个作为从服务器
配置文件中写入 (每个配置文件改为对应端口号)
include /myRedis/redis.conf
port 70**
pidfile "/var/run/redis_70**.pid"
dbfilename "dump70**.rdb"
logfile "/myRedis/cluster/log/redis_err_70**.log"
cluster-enabled yes
cluster-config-file nodes-70**.conf
cluster-node-timeout 15000
启动redis服务确定没有问题能正常启动， node-70**.conf 能正常生成。
进入redis命令目录 cd /opt/redis-6.2.6/src
使用命令启动集群服务
使用命令启动集群服务
redis-cli --cluster create --cluster-replicas 1 192.168.135.100:7001 192.168.135.100:7002 192.168.135.100:7003 192.168.135.100:7011 192.168.135.100:7012 192.168.135.100:7013
--replicas 1 表示主从复制比例为 1:1，即一个主节点对应一个从节点；然后，默认给我们分配好了每个主节点和对应从节点服务，以及 solt 的大小，因为在 Redis 集群中有且仅有 16383 个 solt ，默认情况会给我们平均分配，当然你可以指定，后续的增减节点也可以重新分配
输入yes确认集群的自动分配, 集群启动成功。
每一个服务器都有一个id,可能根据id查看主从关系。
每一个主节点都会分配插槽值范围，总共有1638321， redis会平均插槽给每个主节点。每次想集群中加入数据时会根据key的hash值来决定插槽大小进而决定放在哪个节点中储存。
命令
输入 redis-cli -c - p 以集群方式连接
cluster nodes 可以查看集群节点信息
cluster getkeysinslot 返回 count 个 slot中的键
cluster keyslot 返回key对应的插槽值
cluster countkeysinslot 返回插槽中key的个数
故障恢复
当主节点down后，从节点会自动变为master成为主机。down掉的主机恢复后会变成从机。
如果某一段的插槽对应的节点全部down掉， redis服务会根据以下条件决定。
redis.conf中的cluster-require-full-coverage为yes时,整个集群挂掉，
为no时，该插槽数据全都不能使用，也无法存储。
优点
实现扩容
分摊压力
无中心配置相对简单
十三、Redis可能遇到的问题
缓存穿透
问题描述
key对应的数据在数据源并不存在，每次针对此key的请求从缓存获取不到，请求都会压到数据源，从而可能压垮数据源。比如用一个不存在的用户id获取用户信息，不论缓存还是数据库都没有，若黑客利用此漏洞进行攻击可能压垮数据库。
解决方案
一个一定不存在缓存及查询不到的数据，由于缓存是不命中时被动写的，并且出于容错考虑，如果从存储层查不到数据则不写入缓存，这将导致这个不存在的数据每次请求都要到存储层去查询，失去了缓存的意义。
解决方案：
（1） **对空值缓存：**如果一个查询返回的数据为空（不管是数据是否不存在），我们仍然把这个空结果（null）进行缓存，设置空结果的过期时间会很短，最长不超过五分钟
（2） 设置可访问的名单（白名单）：
使用bitmaps类型定义一个可以访问的名单，名单id作为bitmaps的偏移量，每次访问和bitmap里面的id进行比较，如果访问id不在bitmaps里面，进行拦截，不允许访问。
（3） 采用布隆过滤器：(布隆过滤器（Bloom Filter）是1970年由布隆提出的。它实际上是一个很长的二进制向量(位图)和一系列随机映射函数（哈希函数）。
布隆过滤器可以用于检索一个元素是否在一个集合中。它的优点是空间效率和查询时间都远远超过一般的算法，缺点是有一定的误识别率和删除困难。)
将所有可能存在的数据哈希到一个足够大的bitmaps中，一个一定不存在的数据会被 这个bitmaps拦截掉，从而避免了对底层存储系统的查询压力。
（4） **进行实时监控：**当发现Redis的命中率开始急速降低，需要排查访问对象和访问的数据，和运维人员配合，可以设置黑名单限制服务
缓存击穿
问题描述
key对应的数据存在，但在redis中过期，此时若有大量并发请求过来，这些请求发现缓存过期一般都会从后端DB加载数据并回设到缓存，这个时候大并发的请求可能会瞬间把后端DB压垮。
解决方案
key可能会在某些时间点被超高并发地访问，是一种非常“热点”的数据。这个时候，需要考虑一个问题：缓存被“击穿”的问题。
解决问题：
**（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缓存的方法。
缓存雪崩
问题描述
key对应的数据存在，但在redis中过期，此时若有大量并发请求过来，这些请求发现缓存过期一般都会从后端DB加载数据并回设到缓存，这个时候大并发的请求可能会瞬间把后端DB压垮。
缓存雪崩与缓存击穿的区别在于这里针对很多key缓存，前者则是某一个key
正常访问
缓存失效瞬间
解决方案
缓存失效时的雪崩效应对底层系统的冲击非常可怕！
解决方案：
（1） **构建多级缓存架构：**nginx缓存 + redis缓存 +其他缓存（ehcache等）
（2） 使用锁或队列：
用加锁或者队列的方式保证来保证不会有大量的线程对数据库一次性进行读写，从而避免失效时大量的并发请求落到底层存储系统上。不适用高并发情况
（3） 设置过期标志更新缓存：
记录缓存数据是否过期（设置提前量），如果过期会触发通知另外的线程在后台去更新实际key的缓存。
（4） 将缓存失效时间分散开：
比如我们可以在原有的失效时间基础上增加一个随机值，比如1-5分钟随机，这样每一个缓存的过期时间的重复率就会降低，就很难引发集体失效的事件。
十四、分布式锁
分布式锁的一般实现原理就是大家先抢锁，抢到的人成为Leader（Leader选举机制），然后Leader定期更新状态，以不被其他人把锁抢走。如果失去Leader，则剩下的人继续抢锁。
分布式锁可能会遇到释放别人的锁的情况，设置UUID，在释放的时候判断UUID是否相等就能避免问题。
set lock nx ex
在Java代码中加入lua脚本保证原子性，生成UUID作为版本比较防止释放的锁不对应。
@GetMapping("testLockLua")
public void testLockLua() {
//1 声明一个uuid ,将做为一个value 放入我们的key所对应的值中
String uuid = UUID.randomUUID().toString();
//2 定义一个锁：lua 脚本可以使用同一把锁，来实现删除！
String skuId = "25"; // 访问skuId 为25号的商品 100008348542
String locKey = "lock:" + skuId; // 锁住的是每个商品的数据
// 3 获取锁
Boolean lock = redisTemplate.opsForValue().setIfAbsent(locKey, uuid, 3, TimeUnit.SECONDS);
// 第一种： lock 与过期时间中间不写任何的代码。
// redisTemplate.expire("lock",10, TimeUnit.SECONDS);//设置过期时间
// 如果true
if (lock) {
// 执行的业务逻辑开始
// 获取缓存中的num 数据
Object value = redisTemplate.opsForValue().get("num");
// 如果是空直接返回
if (StringUtils.isEmpty(value)) {
return;
}
// 不是空 如果说在这出现了异常！ 那么delete 就删除失败！ 也就是说锁永远存在！
int num = Integer.parseInt(value + "");
// 使num 每次+1 放入缓存
redisTemplate.opsForValue().set("num", String.valueOf(++num));
/*使用lua脚本来锁*/
// 定义lua 脚本
String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
// 使用redis执行lua执行
DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
redisScript.setScriptText(script);
// 设置一下返回值类型 为Long
// 因为删除判断的时候，返回的0,给其封装为数据类型。如果不封装那么默认返回String 类型，
// 那么返回字符串与0 会有发生错误。
redisScript.setResultType(Long.class);
// 第一个要是script 脚本 ，第二个需要判断的key，第三个就是key所对应的值。
redisTemplate.execute(redisScript, Arrays.asList(locKey), uuid);
} else {
// 其他线程等待
try {
// 睡眠
Thread.sleep(1000);
// 睡醒了之后，调用方法。
testLockLua();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
使用ab工具测试
ab -n 10000 -c 100 http://192.168.22.1:8080/redis/testLock
10000次请求，100个并发。执行完成后，最后redis中的num增加10000。