redis-4 集群

应用场景

为什么需要redis集群？

当主备复制场景，无法满足主机的单点故障时，需要引入集群配置。

一般数据库要处理的读请求远大于写请求 ，针对这种情况，我们优化数据库可以采用读写分离的策略。我们可以部署一台主服务器主要用来处理写请求，部署多台从服务器，处理读请求。

基本原理

哨兵选举机制，如果有半数节点发现某个异常节点，共同决定改异常节点的状态，如果该节点是主节点，对应的备节点自动顶替为主节点。Sentinel（哨兵）是Redis 的高可用性解决方案：由一个或多个Sentinel 实例组成的Sentinel 系统可以监视任意多个主服务器，以及这些主服务器属下的所有从服务器，并在被监视的主服务器进入下线状态时，自动将下线主服务器属下的某个从服务器升级为新的主服务器。

主从复制的作用

1、数据冗余：主从复制实现了数据的热备份，是持久化之外的一种数据冗余方式。

2、故障恢复：当主节点出现问题时，可以由从节点提供服务，实现快速的故障恢复；实际上是一种服务的冗余。

3、负载均衡：在主从复制的基础上，配合读写分离，可以由主节点提供写服务，由从节点提供读服务（即写Redis数据时应用连接主节点，读Redis数据时应用连接从节点），分担服务器负载；尤其是在写少读多的场景下，通过多个从节点分担读负载，可以大大提高Redis服务器的并发量。

4、读写分离：可以用于实现读写分离，主库写、从库读，读写分离不仅可以提高服务器的负载能力，同时可根据需求的变化，改变从库的数量。

5、高可用基石：除了上述作用以外，主从复制还是哨兵和集群能够实施的基础，因此说主从复制是Redis高可用的基础；

配置集群所需要的环境

Redis集群至少需要3个节点，因为投票容错机制要求超过半数节点认为某个节点挂了该节点才是挂了，所以2个节点无法构成集群。

要保证集群的高可用，需要每个节点都有从节点，也就是备份节点，所以Redis集群至少需要6台服务器。因为我没有那么多服务器，也启动不了那么多虚拟机，所在这里搭建的是伪分布式集群，即一台服务器虚拟运行6个redis实例，修改端口号为（7001-7006），当然实际生产环境的Redis集群搭建和这里是一样的。

为什么搭建redis集群？

主从复制不满足生产需求；

搭建集群的时候使用的三个节点，主节点，从节点；

搭建集群

1.首先至少需要准备6台服务器，分别为redis的三主三从；

用一台虚拟机模拟6个节点，一台机器6个节点，创建出3 master、3 salve 环境。虚拟机是 CentOS7 ，ip地址192.168.146.8

注：电脑性能好的可以使用6台虚拟机来，修改虚拟机的IP地址来完成redis集群搭建；

如电脑带不起来6台虚拟机的话，我们还是来搭建一个伪集群来做演示，只需修改端口号即可；

6台服务器的端口号分别为：7001、7002、7003、7004、7005、7006；

2.开始搭建redis伪集群

第一步：创建目录，我们在/usr/myredis文件下分别创建7001、7002、7003、7004、7005、7006文件夹 mkdir 7001 7002 7003 7004 7005 7006;

第二步：现在7001文件夹里创建7001.conf文件或redis.conf文件，配置7001.conf文件；

vim 7001.conf

include /usr/yym/redis/redis-5.0.14/redis.conf
port 7001
pidfile "/var/run/redis_7001.pid"
dbfilename "dump_7001.rdb"
dir "/usr/myredis/7001"
logfile "/usr/myredis/7001/redis_err_7001.log"
bind 0.0.0.0
protected-mode no
daemonize yes
cluster-enabled yes
cluster-config-file nodes-7001.conf
cluster-node-timeout 15000

第一个配置文件写完以后，可以把7001.conf的配置文件分别拷贝到7002、7003、7004、7005、7006文件目录中；

使用命令：

echo ./7002 ./7003 ./7004 ./7005 ./7006 | xargs -n 1 cp -v /usr/myredis/7001/7001.conf

拷贝成功以后，把7001.conf的配置文件里的端口号都改成自己对应的端口号。

例如：7006文件夹下的7001.conf文件

使用 :%s/7001/7006/g 把7001全部替换为7006即可；

第三步：启动这6台redis服务;

一个一个启动太麻烦！我们可以使用脚本实现一键启动；

1.在/usr/myredis文件夹下创建一个stredis文件；

vim stredis

#!/bin/bash
/usr/local/bin/redis-server /usr/myredis/7001/7001.conf
/usr/local/bin/redis-server /usr/myredis/7002/7001.conf
/usr/local/bin/redis-server /usr/myredis/7003/7001.conf
/usr/local/bin/redis-server /usr/myredis/7004/7001.conf
/usr/local/bin/redis-server /usr/myredis/7005/7001.conf
/usr/local/bin/redis-server /usr/myredis/7006/7001.conf

2.给stredis文件给予权限 chmod 777 stredis

3.启动redis ./stredis

4.查看进程，看看这6台redis服务是否可以启动打开；

第四步：配置集群

Redis-cli --cluster create 节点（ip:端口号） --cluster-replicas 1

/usr/local/bin/redis-cli --cluster create 192.168.146.8:7001 192.168.146.8:7002 192.168.146.8:7003 192.168.146.8:7004 192.168.146.8:7005 192.168.146.8:7006 --cluster-replicas 1

是否接受：yes

集群创建成功；

（注：集群配置一般不要设置密码）

第五步：连接集群

-c cluster 不能省略

-h 主机ip 可以省略

-p 端口号

/usr/local/bin/redis-cli -c -h 192.168.184.33 -p 7002

查看集群的节点的信息：cluster nodes

检查集群的状态 /usr/local/bin/redis-cli --cluster check 192.168.146.8:7001

第六步：添加主节点

1.创建7007和7008新节点 /usr/myredis文件夹下创建 mkdir 7007 7008;

2.将7001文件夹下的7001.conf配置文件拷贝过来；

cp ./7001/7001.conf ./7007/7001.conf

3.启动7007服务

/usr/local/bin/redis-server /usr/myredis/7007/7001.conf

查看7007的进程是否启动 ps -ef|grep redis

添加主节点

主节点：写数据有槽；

从节点：读数据没有槽；

/usr/local/bin/redis-cli --cluster add-node 新节点集群中的节点

/usr/local/bin/redis-cli --cluster add-node 192.168.146.8:7007 192.168.146.8:7003

查看7007的集群状态

添加从节点

1.cp ./7007/7001.conf ./7008/7001.conf

vim 7001.conf

启动7008

/usr/local/bin/redis-server /usr/myredis/7008/7001.conf

查看7008进程是否启动

2.配置7008端口号称为7007的从节点

/usr/local/bin/redis-cli --cluster add-node 192.168.146.8:7008 192.168.146.8:7002

--cluster-slave --cluster-master-id 9f401a1f10eb09cc8d0bbd73a5c8847f3c69233b

再次查看集群状态 /usr/local/bin/redis-cli --cluster check 192.168.146.8:7001

主节点分配槽

槽点一共是16384；

7001占5461

7002占5462

7003占5461

1.重新分配槽

关键字：reshard

/usr/local/bin/redis-cli --cluster reshard 192.168.146.8:7001（集群中的节点）

我们使用指定的ID，这500全部从7002上拿出来

分配完成

再次查看集群状态，看看7007是否有500槽

/usr/local/bin/redis-cli --cluster check 192.168.146.8:7001

删除节点

删除从节点

我们这里删除从节点7008 关键字：del-node

/usr/local/bin/redis-cli --cluster 集群节点删除节点的ID

/usr/local/bin/redis-cli --cluster del-node 192.168.146.8:7001 9f6c31770b47dd29a495c83b55ad47101b43e775

再次查看集群状态，看看7008从节点是否从集群中删除

/usr/local/bin/redis-cli --cluster check 192.168.146.8:7001

也可以通过进程查看7008是否关闭 ps -ef|grep redis

删除主节点

1.先把槽分配出去；如不分配直接删除的话，错误提示7007不为空，删除不了；

2.分配槽 /usr/local/bin/redis-cli --cluster reshard 192.168.146.8:7001

查看集群状态，看看7007的槽是否分配出去

/usr/local/bin/redis-cli --cluster check 192.168.146.8:7001

3.删除主节点；

/usr/local/bin/redis-cli --cluster del-node 192.168.146.8:7001 9f401a1f10eb09cc8d0bbd73a5c8847f3c69233b

注：删除主节点注意 1.先后归还槽；2在删除主节点；

批量添加

在集群中批量添加

在集群中是不允许批量添加的

/usr/local/bin/redis-cli -c -p 7001

要想使用批量添加加上分组{名字} 当设置了组名的时候分配槽的时候是根据组的名字分配的槽

取值

测试集群

关闭redis服务: /usr/local/bin/redis-cli -p 7002 shutdown

启动redis服务：/usr/local/bin/redis-server /usr/myredis/7002/7001.conf

故障测试

验证集群是否生效：

关闭一个主节点查看对应的备用节点是不是能够顶替主节点成为主节点

存/取数据的时候查看对应的端口号；（关闭主节点以后需要耐心等待一会儿让他重新分配一下空间）；

我们测试一下7002主和7005从；

/usr/local/bin/redis-cli -p 7002 shutdown

查看7002进程是否关闭；

查看一下集群状态，看看7005是否从从机转为主机了；

/usr/local/bin/redis-cli --cluster check 192.168.146.8:7001

重新启动7002服务，此时7002就变成了从机；

/usr/local/bin/redis-server /usr/myredis/7002/7001.conf

配置一键关机shutdown文件

在/usr/myredis文件下创建shutdown关机配置文件

vim shutdown

关机的配置文件内容：

#!/bin/bash
/usr/local/bin/redis-cli -h 192.168.146.8 -p 7001 shutdown
/usr/local/bin/redis-cli -h 192.168.146.8 -p 7002 shutdown
/usr/local/bin/redis-cli -h 192.168.146.8 -p 7003 shutdown
/usr/local/bin/redis-cli -h 192.168.146.8 -p 7004 shutdown
/usr/local/bin/redis-cli -h 192.168.146.8 -p 7005 shutdown
/usr/local/bin/redis-cli -h 192.168.146.8 -p 7006 shutdown

配置完成以后给shutdown文件给予权限 chmod 777 shutdown

关机 ./shutdown

注：重启之后集群还在；

关机一定使用shutdown 禁止使用 kill -9 进程号

通过使用shutdown关机的话，集群还在；

通过使用kill -9 进程号强制关机的话，集群就被破环了；

什么是slots

[OK] All 16384 slots covered.

一个 Redis 集群包含 16384 个插槽（hash slot），数据库中的每个键都属于这 16384 个插槽的其中一个，

集群使用公式 CRC16(key) % 16384 来计算键 key 属于哪个槽，其中 CRC16(key) 语句用于计算键 key 的 CRC16 校验和。

name 2 [0-5460]

集群中的每个节点负责处理一部分插槽。举个例子，如果一个集群可以有主节点，其中：

节点 A 负责处理 0 号至 5460 号插槽。

节点 B 负责处理 5461 号至 10922 号插槽。

节点 C 负责处理 10923 号至 16383 号插槽。

在集群中录入的值

在redis-cli每次录入、查询键值，redis都会计算出该key应该送往的插槽，如果不是该客户端对应服务器的插槽，redis会报错，并告知应前往的redis实例地址和端口。

redis-cli客户端提供了 –c 参数实现自动重定向。

如 redis-cli -c –p 7000登入后，再录入、查询键值对可以自动重定向。

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

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

redis集群的优点

实现扩容

分摊压力

无中心配置相对简单

redis集群的不足

多键操作是不被支持的

多键的Redis事务是不被支持的

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

redis的应用问题

1.缓存穿透

缓存和数据库中都没有的数据

解决方法:

a.设置白名单

b.缓存预热

c.布隆过滤器

所有可能访问的数据存放到bitmaps

d.进行实时监控：当发现Redis的命中率开始急速降低，需要排查访问对象和访问的数据，和运维人员配合，可以设置黑名单限制服务

1/10 = 0.1

0/100=0

2.缓存击穿

电介质在足够高的电场强度作用下瞬间(10～10s)失去介电功能的现象

缓存失效的一瞬间

缓存击穿是指缓存中没有但数据库中有的数据（一般是缓存时间到期），这时由于并发用户特别多，同时读缓存没读到数据，又同时去数据库去取数据，引起数据库压力瞬间增大，造成过大压力。

访问同一条数据

Name

100

解决方案:

预先设置热门数据
实时调整
锁

3. 缓存雪崩

缓存中没有数据库中有

缓存雪崩是指缓存同一时间大面积的失效，所以，后面的请求都会落到数据库上，造成数据库短时间内承受大量请求而崩掉。

Redis 多个key 同时失效

（1） 构建多级缓存架构：nginx缓存 + redis缓存 +其他缓存（ehcache等）;

（2）使用锁;

（3）设置过期标志更新缓存;

（4）将缓存失效时间分散开：

分布式锁

问题描述

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

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

1. 基于数据库实现分布式锁

2. 基于缓存（Redis等）

3. 基于Zookeeper

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

1. 性能：redis最高

2. 可靠性：zookeeper最高

这里，我们就基于redis实现分布式锁。

解决方案：使用redis实现分布式锁

redis:命令

# set sku:1:info “OK” NX PX 10000

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 ：只在键已经存在时，才对键进行设置操作。

setnx 键不存在的时候设值

setnx lock test

业务逻辑

del lock

1. 多个客户端同时获取锁（setnx）

2. 获取成功，执行业务逻辑{从db获取数据，放入缓存}，执行完成释放锁（del）

3. 其他客户端等待重试

package com.aaa.controller;

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;

@RestController
@RequestMapping("fb")
public class myRedisController {

    //加锁
    @Resource
    private RedisTemplate redisTemplate;

    @GetMapping
    //使用分布式
    public void fblock() throws InterruptedException {
        //创建一个分布式锁 锁名叫lock
        //Boolean aBoolean = redisTemplate.opsForValue().setIfAbsent("lock", "mylock", 1, TimeUnit.MINUTES);
        Boolean aBoolean = redisTemplate.opsForValue().setIfAbsent("lock", "mylock");
        //抢到锁返回true;没有抢到锁返回false;
        if(aBoolean){
            //加锁成功，执行业务，执行完成删除锁
            System.out.println("执行业务");
            System.out.println("执行成功");
            //删除锁
            redisTemplate.delete("lock");
        }else{
            System.out.println("没有抢到锁，枪锁失败");
            //没有抢到锁，等待0.3s重新执行fblick方法;
            Thread.sleep(300);
            fblock();
            //System.out.println("没有抢到锁，枪锁失败");
        }
    }
}

进行压力测试

问题：setnx刚好获取到锁，业务逻辑出现异常，导致锁无法释放

解决：设置过期时间，自动释放锁。

优化之设置锁的过期时间

设置过期时间有两种方式：

1. 首先想到通过expire设置过期时间（缺乏原子性：如果在setnx和expire之间出现异常，锁也无法释放）

2. 在set时指定过期时间（推荐）

设置过期时间：

代码中设置过期时间

Boolean lock = redisTemplate.opsForValue()

.setIfAbsent("lock", "111",3,TimeUnit.SECONDS);

问题：可能会释放其他服务器的锁。

场景：如果业务逻辑的执行时间是7s。执行流程如下

1. index1业务逻辑没执行完，3秒后锁被自动释放。

2. index2获取到锁，执行业务逻辑，3秒后锁被自动释放。

3. index3获取到锁，执行业务逻辑

4. index1业务逻辑执行完成，开始调用del释放锁，这时释放的是index3的锁，导致index3的业务只执行1s就被别人释放。

最终等于没锁的情况。

解决：setnx获取锁时，设置一个指定的唯一值（例如：uuid）；释放前获取这个值，判断是否自己的锁

优化之UUID防误删

问题：删除操作缺乏原子性。

场景：

1. index1执行删除时，查询到的lock值确实和uuid相等

uuid=v1

set(lock,uuid)；

2. index1执行删除前，lock刚好过期时间已到，被redis自动释放

在redis中没有了lock，没有了锁。

3. index2获取了lock

index2线程获取到了cpu的资源，开始执行方法

uuid=v2

set(lock,uuid)；

4. index1执行删除，此时会把index2的lock删除

index1 因为已经在方法中了，所以不需要重新上锁。index1有执行的权限。index1已经比较完成了，这个时候，开始执行

删除的index2的锁！

lUA脚本

Lua 是一个小巧的脚本语言，Lua脚本可以很容易的被C/C++ 代码调用，也可以反过来调用C/C++的函数，Lua并没有提供强大的库，一个完整的Lua解释器不过200k，所以Lua不适合作为开发独立应用程序的语言，而是作为嵌入式脚本语言。

很多应用程序、游戏使用LUA作为自己的嵌入式脚本语言，以此来实现可配置性、可扩展性。

这其中包括魔兽争霸地图、魔兽世界、博德之门、愤怒的小鸟等众多游戏插件或外挂。

Lua 教程_w3cschool

Lua脚本基础入门及其案例_51CTO博客_lua脚本语言入门

LUA脚本在Redis中的优势

将复杂的或者多步的redis操作，写为一个脚本，一次提交给redis执行，减少反复连接redis的次数。提升性能。

LUA脚本是类似redis事务，有一定的原子性，不会被其他命令插队，可以完成一些redis事务性的操作。

但是注意redis的lua脚本功能，只有在Redis 2.6以上的版本才可以使用。

在/usr/myredis文件下创建myluatets文件，进入文件里面配置以下内容；

redis.call('set',KEYS[1],ARGV[1])
redis.call('set',KEYS[2],ARGV[2])
local n1 = tonumber(redis.call('get',KEYS[1]))
local n2 = tonumber(redis.call('get',KEYS[2]))
if n1 > n2 then
    return 1
end
if n1 == n2 then
    return 0
end
if n1 < n2 then
    return 2
end

配置完成，执行命令 /usr/local/bin/redis-cli -a zhk --eval /usr/myredis/myluatest k1 k2 , 10 20

注：

redis-cli --eval set.lua K1 K2 , 18 20

注意事项： key 和参数之间要用，隔开并且，前后两端还有空格

lua脚本实例

local userid=KEYS[1]; 
local prodid=KEYS[2];
local qtkey="sk:"..prodid..":qt";
local usersKey="sk:"..prodid..":usr"; 
local userExists=redis.call("sismember",usersKey,userid);
if tonumber(userExists)==1 then 
  return 2;
end
local num= redis.call("get" ,qtkey);
if tonumber(num)<=0 then 
  return 0; 
else 
  redis.call("decr",qtkey);
  redis.call("sadd",usersKey,userid);
end
return 1;

出错

针对如上错误，作如下处理：

1）查看打开文件的上限和redis服务进程，修改上限：

输入如下命令，查看其上限：

ulimit -a

设置上限

ulimit -n 10032

重启redis即可

redisson

Redisson是一个在Redis的基础上实现的Java驻内存数据网格（In-Memory Data Grid）。它不仅提供了一系列的分布式的Java常用对象，还提供了许多分布式服务，其中就包含了各种分布式锁的实现。简单说就是redis在分布式系统上工具的集合,Redission提供了分布式锁的多种多样的功能.

使用redissoncheck

自定义redis分布式锁无法自动续期，比如，一个锁设置了1分钟超时释放，如果拿到这个锁的线程在一分钟内没有执行完毕，那么这个锁就会被其他线程拿到，可能会导致严重的线上问题，在秒杀场景下，很容易因为这个缺陷导致的超卖了。

10 2s

redission 超时时间1m 执行逻辑的时候3m

锁的分类:

1 、乐观锁与悲观锁

乐观锁

悲观锁

2 、可重⼊锁和⾮可重⼊锁

可重⼊锁：当在⼀个线程中第⼀次成功获取锁之后，在此线程中就可以再次获取

⾮可重⼊锁

3 、公平锁和⾮公平锁

公平锁：按照线程的先后顺序获取锁

⾮公平锁：多个线程随机获取锁

4 、阻塞锁和⾮阻塞锁

阻塞锁：不断尝试获取锁，直到获取到锁为⽌

⾮阻塞锁：如果获取不到锁就放弃，但可以⽀持在⼀定时间段内的重试

—— 在⼀段时间内如果没有获取到锁就放弃；

Redission的使⽤

1 、获取锁 —— 公平锁和⾮公平锁

JAVA


    // 获取公平锁
    RLock lock = redissonClient . getFairLock ( skuId );
    // 获取⾮公平锁
    RLock lock = redissonClient . getLock ( skuId );

2 、加锁 —— 阻塞锁和⾮阻塞锁

JAVA


  // 阻塞锁（如果加锁成功之后，超时时间为 30s ；加锁成功开启看⻔狗，剩 5s 延⻓过期时间）
    lock . lock ();
    // 阻塞锁（如果加锁成功之后，设置⾃定义 20s 的超时时间）
    lock . lock ( 20 , TimeUnit . SECONDS );
    // ⾮阻塞锁（设置等待时间为 3s ；如果加锁成功默认超时间为 30s ）
    boolean b = lock . tryLock ( 3 , TimeUnit . SECONDS );
    // ⾮阻塞锁（设置等待时间为 3s ；如果加锁成功设置⾃定义超时间为 20s ）
    boolean b = lock . tryLock ( 3 , 20 , TimeUnit . SECONDS );

3.释放锁； lock . unlock ();

4.应用实例

JAVA

  // 公平⾮阻塞锁
    RLock lock = redissonClient . getFairLock ( skuId );
    boolean b = lock . tryLock ( 3 , 20 , TimeUnit . SECONDS );

Redisson 锁加锁流程：线程去获取锁，获取成功则执行lua脚本，保存数据到redis数据库。如果获取失败: 一直通过while循环尝试获取锁(可自定义等待时间，超时后返回失败)。Redisson提供的分布式锁是支持锁自动续期的，也就是说，如果线程仍旧没有执行完，那么redisson会自动给redis中的目标key延长超时时间，这在Redisson中称之为 Watch Dog 机制。

示例

使用redission

第一步：在pom文件中添加jar包；

 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

        <!--配置redission-->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson-spring-boot-starter</artifactId>
            <version>3.12.5</version>
        </dependency>

第二步：配置application文件；

# 设置redis的信息
spring.redis.host=192.168.174.72
spring.redis.database=0
spring.redis.password=yyl
spring.redis.port=6379

第三步：配置类在config层

package com.example.bootdemo.aaa.config;

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RedissonConfig {

    @Value("${spring.redis.host}")
    private String host;

    @Value("${spring.redis.port}")
    private String port;

    @Value("${spring.redis.password}")
    private String redisPassword;

    @Bean
    public RedissonClient getRedisson(){

        Config config = new Config();
// //多节点config.useClusterServers()
        //单机模式  依次设置redis地址和密码
        config.useSingleServer().
                setAddress("redis://" + host + ":" + port).
                setPassword(redisPassword);
        return Redisson.create(config);
    }
}

第四步：创建controller层；

package com.aaa.controller;

import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

@RestController
@RequestMapping("redkill")
public class RedissonSeckillController {

    //初始化库存
    @Resource
    private RedisTemplate redisTemplate;
   // private String LOCK_KEY="lining";

    //y引入redis的客户端
    @Resource
    private RedissonClient redissonClient;

    @GetMapping("init")
    public void initKuCun(){
        redisTemplate.opsForValue().set("ln",10);
    }

    @GetMapping
    //抢购,秒杀
    public void ms(){
        //防止商品超卖
        //加锁
        //阻塞所

        //先获取一下锁
        RLock lockpro = redissonClient.getLock("lockpro");
        //加阻塞锁  默认时间30s
        try {
            lockpro.lock(10, TimeUnit.SECONDS);//10秒中的看门狗
            //开始处理业务
            //先获取一下商品数量，>0秒杀成功，<0活动没开始或者秒杀失败
            //先把商品数量转为字符串
            String ln = String.valueOf(redisTemplate.opsForValue().get("ln"));
            //在转为数字
            int i = Integer.parseInt(ln);
            if (i > 0) {
                //开始抢购
                redisTemplate.opsForValue().decrement("ln");
                redisTemplate.opsForSet().add("userList", UUID.randomUUID());
                System.out.println("秒杀成功");
            } else {
                System.out.println("秒杀活动已经结束");
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //手动释放阻塞锁
            lockpro. unlock ();
        }
    }
}