关于Redis分布式锁这一篇应该是讲的最好的了，先收藏起来再看！
前言
在Java并发编程中，我们通常使用到synchronized 、Lock这两个线程锁，Java中的锁，只能保证对同一个JVM中的线程有效。而在分布式集群环境，这个时候我们就需要使用到分布式锁。
实现分布式锁的方案
- 基于数据库实现分布式锁
- 基于缓存Redis实现分布式锁
- 基于Zookeeper的临时序列化节点实现分布式锁
Redis实现分布式锁
场景：在高并发的情况下，可能有大量请求来到数据库查询三级分类数据，而这种数据不会经常改变，可以引入缓存来存储第一次从数据库查询出来的数据，其他线程就可以去缓存中获取数据，来减少数据库的查询压力。
在集群的环境下，就可以使用分布式锁来控制去查询数据库的次数。
阶段一
private Map<String, List<Catelog2Vo>> getCatalogJsonDBWithRedisLock() {
// 去Redis中抢占位置
Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent("lock", "1111");
if (lock){
// 抢到锁了 执行业务
Map<String, List<Catelog2Vo>> dataFromDb = getDataFromDb();
// 删除锁
stringRedisTemplate.delete("lock");
return dataFromDb;
}else {
// 自旋获取锁
// 休眠100ms
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
return getCatalogJsonDBWithRedisLock();
}
}
得到锁以后，我们应该再去缓存中确定一次，如果没有才需要继续查询，从数据库查到数据以后，应该先把数据放入缓存中，再将数据返回。
private Map<String, List<Catelog2Vo>> getDataFromDb() {
// 得到锁以后，我们应该再去缓存中确定一次，如果没有才需要继续查询
String catalogJson = stringRedisTemplate.opsForValue().get("catalogJson");
if (!StringUtils.isEmpty(catalogJson)) {
// 反序列化 转换为指定对象
Map<String, List<Catelog2Vo>> result = JSON.parseObject(catalogJson, new
TypeReference<Map<String, List<Catelog2Vo>>>() {});
return result;
}
System.out.println("查询数据库了......");
// 查询所有分类数据在进行刷选
List<CategoryEntity> categoryEntityList = baseMapper.selectList(null);
// 查询一级分类
List<CategoryEntity> leave1Categorys = getParent_cid(categoryEntityList, 0L);
Map<String, List<Catelog2Vo>> listMap = leave1Categorys.stream().collect(Collectors.toMap(k -> k.getCatId().toString(), l1 -> {
List<CategoryEntity> categoryL2List = getParent_cid(categoryEntityList, l1.getCatId());
List<Catelog2Vo> catelog2Vos = null;
if (categoryL2List != null) {
catelog2Vos = categoryL2List.stream().map(l2 -> {
Catelog2Vo catelog2Vo = new Catelog2Vo(l2.getParentCid().toString(), null, l2.getCatId().toString(), l2.getName());
List<CategoryEntity> categoryL3List = getParent_cid(categoryEntityList,
l2.getCatId());
if (categoryL3List != null) {
List<Catelog2Vo.Catelog3Vo> catelog3Vos =
categoryL3List.stream().map(l3 -> {
Catelog2Vo.Catelog3Vo catelog3Vo = new
Catelog2Vo.Catelog3Vo(l2.getCatId().toString(),
l3.getCatId().toString(),
l3.getName());
return catelog3Vo;
}).collect(Collectors.toList());
catelog2Vo.setCatalog3List(catelog3Vos);
}
return catelog2Vo;
}).collect(Collectors.toList());
}
return catelog2Vos;
}));
// 最后需将数据加入的缓存中
String jsonString = JSON.toJSONString(listMap);
stringRedisTemplate.opsForValue().set("catalogJson", jsonString, 1L,
TimeUnit.DAYS);
return listMap;
}
阶段二
private Map<String, List<Catelog2Vo>> getCatalogJsonDBWithRedisLock() {
// 去Redis中抢占位置
Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent("lock", "1111");
if (lock){
// 抢到锁了 执行业务
// 设置过期时间
stringRedisTemplate.expire("lock",3,TimeUnit.SECONDS);
Map<String, List<Catelog2Vo>> dataFromDb = getDataFromDb();
// 删除锁
stringRedisTemplate.delete("lock");
return dataFromDb;
}else {
// 自旋获取锁
// 休眠100ms
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
return getCatalogJsonDBWithRedisLock();
}
}
阶段三
private Map<String, List<Catelog2Vo>> getCatalogJsonDBWithRedisLock() {
// 去Redis中抢占位置 保证原子性
Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent("lock",
"1111",300,TimeUnit.SECONDS);
if (lock){
// 抢到锁了 执行业务
Map<String, List<Catelog2Vo>> dataFromDb = getDataFromDb();
// 删除锁
stringRedisTemplate.delete("lock");
return dataFromDb;
}else {
// 自旋获取锁
// 休眠100ms
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
return getCatalogJsonDBWithRedisLock();
}
}
阶段四
private Map<String, List<Catelog2Vo>> getCatalogJsonDBWithRedisLock() {
String uuid = UUID.randomUUID().toString();
// 去Redis中抢占位置 保证原子性
Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent("lock", uuid,300,TimeUnit.SECONDS);
if (lock){
// 抢到锁了 执行业务
Map<String, List<Catelog2Vo>> dataFromDb = getDataFromDb();
String s = stringRedisTemplate.opsForValue().get("lock");
if (uuid.equals(s)){
// 删除锁
stringRedisTemplate.delete("lock");
}
return dataFromDb;
}else {
// 自旋获取锁
// 休眠100ms
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
return getCatalogJsonDBWithRedisLock();
}
}
阶段五
private Map<String, List<Catelog2Vo>> getCatalogJsonDBWithRedisLock() {
String uuid = UUID.randomUUID().toString();
// 去Redis中抢占位置 保证原子性
Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent("lock", uuid,300,TimeUnit.SECONDS);
if (lock){
// 抢到锁了 执行业务
Map<String, List<Catelog2Vo>> dataFromDb = getDataFromDb();
String s = stringRedisTemplate.opsForValue().get("lock");
// 获取值对比+对比成功删除=原子操作 Lua脚本解锁
String script = "if redis.call(\"get\",KEYS[1]) == ARGV[1] then\n" +
" return redis.call(\"del\",KEYS[1])\n" +
"else\n" +
" return 0\n" +
"end";
Long lock1 = stringRedisTemplate.execute(new DefaultRedisScript<Long>(script, Long.class) , Arrays.asList("lock"), uuid);
return dataFromDb;
}else {
// 自旋获取锁
// 休眠100ms
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
return getCatalogJsonDBWithRedisLock();
}
}
小总结
- stringRedisTemplate.opsForValue().setIfAbsent(“lock”, uuid,300,TimeUnit.SECONDS);
- stringRedisTemplate.execute(new DefaultRedisScript(script, Long.class) , Arrays.asList(“lock”), uuid);
- 使用Redis来实现分布式锁需保证加锁【占位+过期时间】和删除锁【判断+删除】操作的原子性。
- Redis锁的过期时间小于业务的执行时间该如何自动续期？
- 设置一个比业务耗时更长的过期时间
Redisson的看门狗机制
Redisson实现分布式锁
Redisson 简介
Redisson是一个在Redis的基础上实现的Java驻内存数据网格（In-Memory Data Grid）。它不仅提供了一系列的分布式的Java常用对象，还提供了许多分布式服务。其中包括(BitSet, Set, Multimap, SortedSet, Map, List, Queue, BlockingQueue, Deque, BlockingDeque, Semaphore, Lock, AtomicLong, CountDownLatch, Publish / Subscribe, Bloom filter, Remote service, Spring cache, Executor service, Live Object service, Scheduler service) Redisson提供了使用Redis的最简单和最便捷的方法。Redisson的宗旨是促进使用者对Redis的关注分离（Separation of Concern），从而让使用者能够将精力更集中地放在处理业务逻辑上。
原理机制
集成Spring Boot 项目
引入依赖 【可引入Spring Boot 封装好的starter】
<!-- https://mvnrepository.com/artifact/org.redisson/redisson -->
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson</artifactId>
<version>3.12.0</version>
</dependency>添加配置类
@Configuration
public class MyRedissonConfig { @Bean(destroyMethod = "shutdown")
public RedissonClient redissonClient(){
// 创建配置 记得加redis://
Config config = new Config();
config.useSingleServer().setAddress("redis://192.168.26.104:6379");
// 根据配置创建RedissClient客户端
RedissonClient redissonClient = Redisson.create(config);
return redissonClient;
}
}
可重入锁 Reentrant Lock
- 获取一把锁 redissonClient.getLock(“my-lock”);
- 给业务代码加锁 lock.lock();
- 解锁 lock.unlock();
- 看门狗机制 锁会自动续期
@ResponseBody
@GetMapping("/hello")
public String hello(){
// 1、获取一把锁，只要锁的名字一样，就是同一把锁
RLock lock = redissonClient.getLock("my-lock");
// 加锁
// 阻塞式等待，默认加的锁都是【看门狗时间】30s时间
//1)、锁的自动续期，如果业务超长，运行期间自动给锁续上新的30s，不用担心业务时间长，锁自动过期被删掉
//2)、加锁的业务只要运行完成，就不会给当前锁续期，即使不手动解锁，锁默认在30s以后自动删除
lock.lock();
try {
System.out.println("加锁成功......."+Thread.currentThread().getId());
Thread.sleep(30000);
} catch (InterruptedException e) {
}finally {
// 释放锁 不会出现死锁状态 如果没有执行解锁，锁有过期时间，过期了会将锁删除
lock.unlock();
System.out.println("解锁成功......"+Thread.currentThread().getId());
}
return "hello";
}
lock方法有一个重载方法 lock(long leaseTime, TimeUnit unit)
public void lock(long leaseTime, TimeUnit unit) {
try {
this.lock(leaseTime, unit, false);
} catch (InterruptedException var5) {
throw new IllegalStateException();
}
}
注意：指定了过期时间后，不会进行自动续期，此时如果有多个线程，即便业务还然在执行，过期时间到了之后，锁就会被释放，其他线程就会争抢到锁。
二个方法对比
如果设置了过期时间，就会发生执行脚本给Redis，进行占锁，设置过期时间为我们指定的时间。
未设置过期时间，就会使用看门狗的默认时间LockWatchdogTimeout 30*1000
只有没有指定过期的时间的方法才有自动续期功能
自动续期实现机制 ：只要占锁成功，就会自动启动一个定时任务【重新给锁设置过期时间，新的过期时间就是看门狗的默认时间】，每隔10s【（ internalLockLeasTime）/3】都会自动续期。
持有锁的机器宕机问题，因为来不及续期，所以锁自动被释放，当该机再次恢复时，因为其后台守护线程是ScheduleTask，所以恢复后会马上执行一次watchDog续期逻辑，执行过程中，它会感知到自己已经丢失了锁，所以不存在共同持有的问题。
读写锁 ReadWriteLock
保证一定能读到最新数据，修改期间，写锁是一个互斥锁，读锁是一个共享锁。
- 写+读 写锁没有释放，读锁就得等待
- 写+写 阻塞方式
- 读+写 写锁等待读锁释放才能加锁
- 读+读 相当于无锁，并发读
@ResponseBody
@GetMapping("/write")
public String writeLock(){
RReadWriteLock readWriteLock = redissonClient.getReadWriteLock("rw-lock");
RLock rLock = readWriteLock.writeLock();
String s = "";
try {
rLock.lock();
System.out.println("写锁加锁成功......"+Thread.currentThread().getId());
s = UUID.randomUUID().toString();
stringRedisTemplate.opsForValue().set("writeLock",s);
Thread.sleep(30000);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
rLock.unlock();
System.out.println("写锁释放成功......"+Thread.currentThread().getId());
}
return s;
}
@ResponseBody
@GetMapping("/read")
public String readLock(){
RReadWriteLock readWriteLock = redissonClient.getReadWriteLock("rw-lock");
RLock rLock = readWriteLock.readLock();
rLock.lock();
String s = "";
try{
System.out.println("读锁加锁成功......"+Thread.currentThread().getId());
s = stringRedisTemplate.opsForValue().get("writeLock");
}catch (Exception e){
e.printStackTrace();
}finally {
System.out.println("读锁释放成功......"+Thread.currentThread().getId());
rLock.unlock();
}
return s;
}
信号量 Semaphore
使用信号量来做分布式限流
@ResponseBody
@GetMapping("/park")
public String park() throws InterruptedException {
RSemaphore park = redissonClient.getSemaphore("park");
// 抢占一个车位
boolean b = park.tryAcquire();
// 如果还可以抢占到 就执行业务代码
if (b){
// 执行业务代码
}else {
return "error";
}
return "ok=>"+b;
}
@ResponseBody
@GetMapping("/go")
public String go() {
RSemaphore park = redissonClient.getSemaphore("park");
// 释放一个车位
park.release();
return "ok";
}
闭锁 CountDownLatch
模拟场景：等待班级放学走了，保安关校门。
@ResponseBody
@GetMapping("/lockdoor")
public String lockDoor() throws InterruptedException {
RCountDownLatch door = redissonClient.getCountDownLatch("door");
door.trySetCount(5);
// 等待闭锁完成
door.await();
return "放假了.....";
}
@GetMapping("/gogogo/{id}")
@ResponseBody
public String gogogo(@PathVariable("id")Long id){
RCountDownLatch door = redissonClient.getCountDownLatch("door");
// 计数减一
door.countDown();
return id+"班级走了....";
}
Redisson解决上面Redis查询问题
/**
* 使用Redisson分布式锁来实现多个服务共享同一缓存中的数据
* @return
*/
private Map<String, List<Catelog2Vo>> getCatalogJsonDBWithRedissonLock() {
RLock lock = redissonClient.getLock("catalogJson-lock");
// 该方法会阻塞其他线程向下执行，只有释放锁之后才会接着向下执行
lock.lock();
Map<String, List<Catelog2Vo>> dataFromDb = null;
try {
dataFromDb = getDataFromDb();
}finally {
lock.unlock();
}
return dataFromDb;
}
最后
欢迎关注公众号：前程有光，领取一线大厂Java面试题总结+各知识点学习思维导+一份300页pdf文档的Java核心知识点总结！
关于Redis分布式锁这一篇应该是讲的最好的了，先收藏起来再看！的更多相关文章
- Redis分布式锁实现Redisson 15问
大家好,我是三友. 在一个分布式系统中,由于涉及到多个实例同时对同一个资源加锁的问题,像传统的synchronized.ReentrantLock等单进程情况加锁的api就不再适用,需要使用分布式锁来 ...
- Redis分布式锁—Redisson+RLock可重入锁实现篇
前言 平时的工作中,由于生产环境中的项目是需要部署在多台服务器中的,所以经常会面临解决分布式场景下数据一致性的问题,那么就需要引入分布式锁来解决这一问题. 针对分布式锁的实现,目前比较常用的就如下几种 ...
- Redis分布式锁—SETNX+Lua脚本实现篇
前言 平时的工作中,由于生产环境中的项目是需要部署在多台服务器中的,所以经常会面临解决分布式场景下数据一致性的问题,那么就需要引入分布式锁来解决这一问题. 针对分布式锁的实现,目前比较常用的就如下几种 ...
- 面试官再问Redis分布式锁如何续期？这篇文章甩 他一脸
一.真实案例 二.Redis分布式锁的正确姿势 据肥朝了解,很多同学在用分布式锁时,都是直接百度搜索找一个Redis分布式锁工具类就直接用了.关键是该工具类中还充斥着很多System.out.prin ...
- redis咋么实现分布式锁，redis分布式锁的实现方式，redis做分布式锁 积极正义的少年
前言 分布式锁一般有三种实现方式:1. 数据库乐观锁:2. 基于Redis的分布式锁:3. 基于ZooKeeper的分布式锁.本篇博客将介绍第二种方式,基于Redis实现分布式锁.虽然网上已经有各种介 ...
- Redis分布式锁的正确实现方式
前言 分布式锁一般有三种实现方式:1. 数据库乐观锁:2. 基于Redis的分布式锁:3. 基于ZooKeeper的分布式锁.本篇博客将介绍第二种方式,基于Redis实现分布式锁.虽然网上已经有各种介 ...
- Redis分布式锁---完美实现
这几天在做项目缓存时候,因为是分布式的所以需要加锁,就用到了Redis锁,正好从网上发现两篇非常棒的文章,来和大家分享一下. 第一篇是简单完美的实现,第二篇是用到的Redisson. Redis分布式 ...
- redis分布式锁实践
分布式锁在多实例部署,分布式系统中经常会使用到,这是因为基于jvm的锁无法满足多实例中锁的需求,本篇将讲下redis如何通过Lua脚本实现分布式锁,不同于网上的redission,完全是手动实现的 我 ...
- springboot+redis分布式锁-模拟抢单
本篇内容主要讲解的是redis分布式锁,这个在各大厂面试几乎都是必备的,下面结合模拟抢单的场景来使用她:本篇不涉及到的redis环境搭建,快速搭建个人测试环境,这里建议使用docker:本篇内容节点如 ...
随机推荐
- Linux （操作二）
1.U盘的装载与卸载(设备都保存在/dev中 /dev存放设备的文件) 1.卸载u盘 umount /media/xxx/xxx (xxx为具体路径) 2.查看设备 sudo fdisk -l ( ...
- 使用qmake编译时拷贝文件
使用qmake构建项目时,需要在make时拷贝一些文件到指定位置,非执行make install,下面总结列举一下我了解的方式 COPIES 示例pro 1 COPY_DIR = $$PWD/copy ...
- Linear basis
Linear basis is a relatively easy to learn but may not be useful algorithm. Below are two blogs that ...
- Spring源码理论
Spring Bean的创建过程: Spring容器获取Bean和创建Bean都会调用getBean()方法. getBean()方法 1)getBean()方法内部最终调用doGetBean()方法 ...
- mysql学习笔记1（mysql的基本架构）
mysql基本架构图 如图所示: 1 . MySQL 可以分为 Server 层和存储引擎层两部分 Server 层包括连接器.查询缓存.分析器.优化器.执行器等,涵盖 MySQL 的大多数核心服务功 ...
- bWAPP----HTML Injection - Reflected (URL)
HTML Injection - Reflected (URL) 核心代码 1 <div id="main"> 2 3 <h1>HTML Injection ...
- 痞子衡嵌入式：揭秘i.MXRT600的ISP模式下用J-Link连接后PC总是停在0x1c04a的原因(Debug Mailbox)
大家好,我是痞子衡,是正经搞技术的痞子.今天痞子衡给大家介绍的是i.MXRT600中的Debug Mailbox实现对JLink调试的影响. 事情缘起痞子衡的同事 - 喜欢打破砂锅问到底的Kerry小 ...
- Camtasia处理音频制作BGM
我们在剪辑自己录制的视频时经常会需要同时对音频进行处理,camtasia是一个可以对视频的音频或者单独的音频文件进行处理的软件,那我们就来看看到底如何使用camtasia 2019(Win)来处理音频 ...
- 用思维导图软件MindManager整理假期
今天带大家使用MindManager2020软件构建出2020年的节假日思维导图. 既然是做2020年的节假日思维导图,那么有个MindManager技巧就是,关于这一类思维导图我们都可以选择时间线导 ...
- 分析一个免杀webshell发现的php特性
文章首发于t00ls,嫌文章太啰嗦的可以直接看结论 起源 之前看到别人分享的一个免杀webshell: <?php @$GLOBALS{next} = $GLOBALS[$GLOBALS[fun ...