- lock.lock(timeout, TimeUnit.SECONDS):锁定,timeout:超时时间 ,TimeUnit.SECONDS:单位。
- lock.lock(); 锁定,没有超时间时间,如果当前线程一直不释放锁资源,其他线程将会一直处于阻塞状态。 lock.unlock();解锁。
我们直接来看单元测试的执行结果:
我们可以发现,Thread-3 在15:04:18.947 获取到了锁,而这个时候 Thread-4 还处于阻塞状态,直到5秒之后 15:04:23.977 Thread-3释放了锁,Thread-4 在 15:04:23.991 获取到了锁,Thread-4 大概阻塞了5秒钟,可以理解为 Thread-4 一直在等待锁资源的释放,如果只有锁的线程一直不释放锁,那么 Thread-4 将会一直处于等待状态,那你可能就会有疑问了,Thread-4 会等他多久呢?不要怀疑它的专一,它会等到天荒地老,海枯石烂,宇宙毁灭。说直白一点就是,除非有其他线程执行 Thread-4 线程的 interrupted()方法,否者 它的等待将用于休止。
我们将这种无休止的等待称为:不可中断
,我们使用 RLock 中的lock() 方法的特性就是不可中断,这种锁存在比较大二点安全隐患,稍不注意,就能让你程序万劫不复。这点可以参考java并发编程的明星锁:synchronized,它也是一种不可中断类型的锁。
我们的例子中是设置的锁的过期时间,他还支持不设置过期时间,这种情况下,只要程序不解锁,那么其他线程都将一直处于阻塞状态,这样就会引发一个很严重的问题,那就是在线程获取到了锁之后,程序或者服务器突然宕机,等重启完成之后,其他线程也会一直处于阻塞状态,因为宕机前获取的锁还没有被释放。
redisson也为我们考虑到了这个问题,所以它设置一个看门狗。它的作用是在Redisson实例被关闭前,不断的延长锁的有效期。默认情况下,看门狗的检查锁的超时时间是30秒钟,也可以通过修改Config.lockWatchdogTimeout来另行指定。
说直白一点,如果你加的锁没有指定过期时间,那么redisson会默认将这个锁的过期时间设置为 30 秒,快到 30 的程序去自动续期,直到程序把锁释放,如果这个时候服务器宕机了,那么程序的续期功能自然也就不存在了,锁最多还能再存活 30 秒,这个大家可以自己去测试一下,我这里就不做测试了,很简单,不带超时间锁定之后,去redis中查看当前锁的有效期是不是你 Config.lockWatchdogTimeout 参数指定的时间,然后过了这个时间,有效期是否自动刷新。
我们先来看看RLock 给我提供的可中断锁的方法有哪些
boolean tryLock();
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
boolean tryLock(long waitTime, long leaseTime, TimeUnit unit) throws InterruptedException;
RFuture tryLockAsync(long waitTime, long leaseTime, TimeUnit unit);
RFuture tryLockAsync();
RFuture tryLockAsync(long threadId);
RFuture tryLockAsync(long waitTime, TimeUnit unit);
RFuture tryLockAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId);
tryLock():很好理解,尝试着加锁,这里面有几个参数讲解一下:
-
time:等待锁的最长时间。
-
unit:时间单位。
-
waitTime:与time一致,等待锁的最长时间。
-
leaseTime:锁的过期时间。
-
threadId:线程id。
大致意思说的就是一个线程带等待 time/waitTime时长后如果还没有获取到锁,那么当前线程将会放弃获取锁资源的机会,去干其他事情。Async结尾的几个方法主要就是异步加锁的意思。
我们一起来写一个单元测试:
RedissonTemplate.java中添加如下方法:
/**
-
可中断锁
-
@param lockName 锁名称
-
@param waitTimeout 等待时长
-
@param unit 时间单位
-
@return
*/
public boolean tryLock(String lockName, long waitTimeout, TimeUnit unit) {
checkRedissonClient();
RLock lock = getLock(lockName);
try {
boolean res = lock.tryLock(waitTimeout,unit);
if (!res) {
log.debug(" get lock fail ,lockKey:{}", lockName);
return false;
}
log.debug(" get lock success ,lockKey:{}", lockName);
return true;
} catch (Exception e) {
log.error(" get lock fail,lockKey:{}, cause:{} ",
lockName, e.getMessage());
return false;
}
}
单元测试:
package com.nlx.redisson;
import com.nlx.redisson.core.RedissonTemplate;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
@SpringBootTest
@Slf4j
class SpringbootRedissonApplicationTests {
@Autowired
private RedissonTemplate redissonTemplate;
private CountDownLatch count = new CountDownLatch(2);
@Test
void contextLoads() {
String lockName = "hello-t 需要zi料+ 绿色徽【vip1024b】
est";
new Thread(() ->{
String threadName = Thread.currentThread().getName();
log.info(“线程:{} 正在尝试获取锁。。。”,threadName);
boolean lock = redissonTemplate.tryLock(lockName, 2L,TimeUnit.SECONDS);
doSomthing(lock,lockName,threadName);
}).start();
new Thread(() ->{
String threadName = Thread.currentThread().getName();
log.info(“线程:{} 正在尝试获取锁。。。”,threadName);
boolean lock = redissonTemplate.tryLock(lockName, 2L,TimeUnit.SECONDS);
doSomthing(lock,lockName,threadName);
}).start();
try {
count.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
log.info(“子线程都已执行完毕,main函数可以结束了!”);
}
private void doSomthing(boolean lock,String lockName,String threadName) {
if(lock){
log.info(“线程:{},获取到了锁”,threadName);
try{
try {
TimeUnit.SECONDS.sleep(5L);
} catch (InterruptedException e) {
e.printStackTrace();
}
}finally {
redissonTemplate.unlock(lockName);
log.info(“线程:{},释放了锁”,threadName);
}
}else{
log.info(“线程:{},没有获取到锁,过了等待时长,结束等待”,threadName);
}
count.countDown();
}
}
输出结果:
Thread-3 在 20:22:52.494 的时候尝试获取锁,20:22:52.527 的时候获取到了锁,并且进入到了休眠状态,Thread-4 在 20:22:52.494 的时候尝试获取锁,直到 20:22:54.513 也没有获取到,然后 Thread-4就放弃了等待,直接结束了线程,期间花费了两秒钟的时间,而我们设置的等待时间刚好就是两秒,所以单元测试通过。
基于 Redis 的 Redisson 分布式可重入公平锁也是实现了 java.util.concurrent.locks.Lock 接口的一种 RLock 对象。同时还提供了异步(Async)、反射式(Reactive)和 RxJava2 标准的接口。它保证了当多个Redisson客户端线程同时请求加锁时,优先分配给先发出请求的线程。所有请求线程会在一个队列中排队,当某个线程出现宕机时,Redisson 会等待5秒后继续下一个线程,也就是说如果前面有5个线程都处于等待状态,那么后面的线程会等待至少25秒。
何为公平?就是所谓的先来后到,先获取锁的线程先拿到锁,后面的线程都在后面排着,这里你可以理解为你去做核算检测,工作人员刚把棚子搭好的时候,你就去了,这个时候没有人,你一去就直接做,第二次核算检测的时候,你正好在上班,下班回来之后发现做核算的队伍排得老长老长,这个时候你就不得不排在那些人的后面,等待前面的人核算都做完了,才会轮到你,这就是程序里面的公平锁。前两的那两种都不是公平锁,什么意思呢?非公平锁可以把他想象成小车过十字路,在没有红绿灯以及交警指挥的时候,每辆车都想自己最先通过十字路口,然后疯狂的向前开,然后就导致了后面的堵车,映射程序中利用大量cas去获取锁,非常消耗cpu,这也是为什么十字路口需要红路灯和交警的原因,但是有些十字路口也不需要红绿灯,因为这个十字路口几乎没有什么车,不会造成拥堵,程序也是这样,没有大量的线程竞争的时候,就没有必要设置成公平锁,毕竟红绿灯和公平锁也是需要成本的。
我们一起来看看公平锁的实现方式
/**
-
公平锁
-
@param lockName
-
@param waitTimeout
-
@param timeout
-
@param unit
-
@return
*/
public boolean getFairLock(String lockName, long waitTimeout,long timeout, TimeUnit unit){
checkRedissonClient();
RLock lock = redissonClient.getFairLock(DEFAULT_LOCK_NAME + lockName);
try {
boolean res = lock.tryLock(waitTimeout,timeout,unit);
if (!res) {
log.debug(" get lock fail ,lockKey:{}", lockName);
return false;
}
log.debug(" get lock success ,lockKey:{}", lockName);
return true;
} catch (Exception e) {
log.error(" get lock fail,lockKey:{}, cause:{} ",
lockName, e.getMessage());
return false;
}
}
/**
- 公平锁
*/
@Test
public void testFairLock() throws InterruptedException {
CountDownLatch countDown = new CountDownLatch(3);
String lockName = “hello-test”;
new Thread(() -> {
log.info(“进入thread1 ======”);
log.info(“thread1 正在尝试获取锁。。。”);
boolean lock = redissonTemplate.getFairLock(lockName, 20L, 7L,TimeUnit.SECONDS);
doSomthing(lock, lockName, “thread1”);
}).start();
new Thread(() -> {
log.info(“进入thread2 ======”);
try {
TimeUnit.SECONDS.sleep(2L);
} catch (InterruptedException e) {
e.printStackTrace();
}
log.info(“thread2 休眠结束 正在尝试获取锁。。。”);
boolean lock = redissonTemplate.getFairLock(lockName, 20L,7L, TimeUnit.SECONDS);
doSomthing(lock, lockName, “thread2”);
}).start();
new Thread(() -> {
log.info(“进入thread3 ======”);
try {
TimeUnit.SECONDS.sleep(3L);
} catch (InterruptedException e) {
e.printStackTrace();
}
log.info(“thread3 休眠结束 正在尝试获取锁。。。”);
boolean lock = redissonTemplate.getFairLock(lockName, 20L,7L, TimeUnit.SECONDS);
doSomthing(lock, lockName, “thread3”);
}).start();
countDown.await();
}
2021-06-27 11:22:13.753 INFO 1128 — [ Thread-3] c.n.r.SpringbootRedissonApplicationTests : 进入thread1 ======
2021-06-27 11:22:13.754 INFO 1128 — [ Thread-4] c.n.r.SpringbootRedissonApplicationTests : 进入thread2 ======
2021-06-27 11:22:13.754 INFO 1128 — [ Thread-3] c.n.r.SpringbootRedissonApplicationTests : thread1 正在尝试获取锁。。。
2021-06-27 11:22:13.754 INFO 1128 — [ Thread-5] c.n.r.SpringbootRedissonApplicationTests : 进入thread3 ======
2021-06-27 11:22:13.796 INFO 1128 — [ Thread-3] c.n.r.SpringbootRedissonApplicationTests : 线程:thread1,获取到了锁
2021-06-27 11:22:15.759 INFO 1128 — [ Thread-4] c.n.r.SpringbootRedissonApplicationTests : thread2 休眠结束 正在尝试获取锁。。。
2021-06-27 11:22:16.767 INFO 1128 — [ Thread-5] c.n.r.SpringbootRedissonApplicationTests : thread3 休眠结束 正在尝试获取锁。。。
2021-06-27 11:22:18.810 INFO 1128 — [ Thread-3] c.n.r.SpringbootRedissonApplicationTests : 线程:thread1 正在释放了锁
2021-06-27 11:22:18.867 INFO 1128 — [ Thread-4] c.n.r.SpringbootRedissonApplicationTests : 线程:thread2,获取到了锁
2021-06-27 11:22:23.869 INFO 1128 — [ Thread-4] c.n.r.SpringbootRedissonApplicationTests : 线程:thread2 正在释放了锁
2021-06-27 11:22:23.912 INFO 1128 — [ Thread-5] c.n.r.SpringbootRedissonApplicationTests : 线程:thread3,获取到了锁
2021-06-27 11:22:28.914 INFO 1128 — [ Thread-5] c.n.r.SpringbootRedissonApplicationTests : 线程:thread3 正在释放了锁
基于Redis的Redisson分布式联锁RedissonMultiLock对象可以将多个RLock对象关联为一个联锁,每个RLock对象实例可以来自于不同的Redisson实例。
联锁指的是:同时对多个资源进行加索操作,只有所有资源都加锁成功的时候,联锁才会成功。
@Test
public void testMultiLock(){
RLock lock1 = redissonTemplate.getLock(“lock1” );
RLock lock2 = redissonTemplate.getLock(“lock2”);
RLock lock3 = redissonTemplate.getLock(“lock3”);
RedissonMultiLock lock = new RedissonMultiLock(lock1, lock2, lock3);
boolean flag = lock.tryLock();
if(flag){
try {
log.info(“联锁加索成功”);
}finally {
//一定要释放锁
lock.unlock();
}
}
}
基于Redis的Redisson红锁RedissonRedLock对象实现了Redlock介绍的加锁算法。该对象也可以用来将多个RLock对象关联为一个红锁,每个RLock对象实例可以来自于不同的Redisson实例
与联锁比较相似,都是对多个资源进行加锁,但是红锁与连锁不同的是,红锁只需要在大部分资源加锁成功即可,
/**
- 红锁
*/
@Test
public void testRedLock(){
RLock lock1 = redissonTemplate.getLock(“lock1” );
RLock lock2 = redissonTemplate.getLock(“lock2”);
RLock lock3 = redissonTemplate.getLock(“lock3”);
RedissonRedLock lock = new RedissonRedLock (lock1, lock2, lock3);
boolean flag = lock.tryLock();
if(flag){
try {
log.info(“红锁加索成功”);
}finally {
//一定要释放锁
lock.unlock();
}
}
}
基于Redis的Redisson分布式可重入读写锁RReadWriteLock Java对象实现了java.util.concurrent.locks.ReadWriteLock接口。其中读锁和写锁都继承了RLock接口。
分布式可重入读写锁允许同时有多个读锁和一个写锁处于加锁状态。这点相当于java并发sdk并发包中的 StampedLock 。
如果大家对读写锁还不太熟悉的话,可以参考我的另外两篇文章:
【并发编程】java并发编程之ReentrantReadWriteLock读写锁
/**
- 读写锁
*/
@Test
public void testReadWriteLock(){
RReadWriteLock rwlock = redissonTemplate.getReadWriteLock(“testRWLock”);
rwlock.readLock().lock();
rwlock.writeLock().lock();
}
/**
-
获取读写锁
-
@param lockName
-
@return
*/
public RReadWriteLock getReadWriteLock(String lockName) {
return redissonClient.getReadWriteLock(lockName);
}
基于Redis的Redisson的分布式信号量(Semaphore)Java对象RSemaphore采用了与java.util.concurrent.Semaphore相似的接口和用法。同时还提供了异步(Async)、反射式(Reactive)和RxJava2标准的接口。
/**
-
信号量
-
@param semaphoreName
-
@return
*/
public RSemaphore getSemaphore(String semaphoreName) {
return redissonClient.getSemaphore(semaphoreName);
}
/**
- 信号量
*/
@Test
public void testSemaphore() throws InterruptedException {
RSemaphore semaphore = redissonTemplate.getSemaphore(“testSemaphore”);
//设置许可个数
semaphore.trySetPermits(10);
// //设置许可个数 异步
// semaphore.acquireAsync();
// //获取5个许可
// semaphore.acquire(5);
// //尝试获取一个许可
// semaphore.tryAcquire();
// //尝试获取一个许可 异步
// semaphore.tryAcquireAsync();
// //尝试获取一个许可 等待5秒如果未获取到,则返回false
// semaphore.tryAcquire(5, TimeUnit.SECONDS);
// //尝试获取一个许可 等待5秒如果未获取到,则返回false 异步
// semaphore.tryAcquireAsync(5, TimeUnit.SECONDS);
// //释放一个许可,将其返回给信号量
// semaphore.release();
// //释放 6 个许可 ,将其返回给信号量
// semaphore.release(6);
// //释放一个许可,将其返回给信号量 异步
// semaphore.releaseAsync();
CountDownLatch count = new CountDownLatch(10);
for (int i= 0;i< 15 ;++i){
new Thread(() -> {
try {
String threadName = Thread.currentThread().getName();
log.info(“线程:{} 尝试获取许可。。。。。。。。。。。。。”,threadName);
//默认获取一个许可,如果没有获取到,则阻塞线程
semaphore.acquire();
log.info(“线程:{}获取许可成功。。。。。。。”, threadName);
count.countDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
count.await();
}
在实现信号量的时候一定要注意许可数量,如果被使用完,而你用完之后并没有将许可归还给信号量,那么有可能在许可用完之后,之后的线程一直处于阻塞阶段。
关于信号量还有一个:可过期性信号量(PermitExpirableSemaphore),获取到的许可有效期只有你设置的时长,
/**
-
可过期性信号量
-
@param permitExpirableSemaphoreName
-
@return
*/
public RPermitExpirableSemaphore getPermitExpirableSemaphore(String permitExpirableSemaphoreName) {
return redissonClient.getPermitExpirableSemaphore(permitExpirableSemaphoreName);
}
/**
- 信号量
*/
@Test
public void testPermitExpirableSemaphore() throws InterruptedException {
RPermitExpirableSemaphore semaphore = redissonTemplate.getPermitExpirableSemaphore(“testPermitExpirableSemaphore”);
//设置许可个数
semaphore.trySetPermits(10);
// 获取一个信号,有效期只有2秒钟。
String permitId = semaphore.acquire(1, TimeUnit.SECONDS);
log.info(“许可:{}”,permitId);
semaphore.release(permitId);
}
基于Redisson的Redisson分布式闭锁(CountDownLatch)Java对象RCountDownLatch采用了与java.util.concurrent.CountDownLatch相似的接口和用法。
我在例子中也是用到了java sdk并发包中的 CountDownLatch ,主要是线程同步的作用,redisson同样也实现了这样的功能,我们一起来看一下redisson的代码实现
@Test
public void testCountDownLatch() throws InterruptedException {
RCountDownLatch latch = redissonTemplate.getCountDownLatch(“testCountDownLatch”);
latch.trySetCount(2);
new Thread(() ->{
log.info(“这是一个服务的线程”);
try {
TimeUnit.SECONDS.sleep(3);
log.info(“线程:{},休眠结束”,Thread.currentThread().getName());
latch.countDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
new Thread(() ->{
log.info(“这是另外一个服务的线程”);
try {
TimeUnit.SECONDS.sleep(3);
log.info(“线程:{},休眠结束”,Thread.currentThread().getName());
latch.countDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
latch.await();
log.info(“子线程执行结束。。。。。。”);
}
/**
-
闭锁
-
@param countDownLatchName
-
@return
*/
public RCountDownLatch getCountDownLatch(String countDownLatchName) {
return redissonClient.getCountDownLatch(countDownLatchName);
}
springboot整合redisson实现强大的分布式锁到这里就讲的差不多了,最后在贴一份单元测试和 RedissonTemplate 的完整代码吧。
package com.nlx.redisson.core;
import lombok.extern.slf4j.Slf4j;
import org.redisson.api.*;
import org.redisson.client.codec.Codec;
import org.redisson.codec.MarshallingCodec;
import org.springframework.context.annotation.Configuration;
import org.springframework.util.StringUtils;
import java.util.concurrent.TimeUnit;
/**
-
@ClassName RedissonTemplate
-
redisson封装操作类
-
@author nlx
*/
@Configuration
@Slf4j
public class RedissonTemplate {
private final RedissonClient redissonClient;
/**
- 锁前缀
*/
private final String DEFAULT_LOCK_NAME = “nlx-instance”;
public RedissonTemplate(RedissonClient redissonClient) {
this.redissonClient = redissonClient;
}
/**
-
加锁(可重入),会一直等待获取锁,不会中断
-
@param lockName waitTimeout timeout
-
@return boolean
-
@author ymy
-
@date 2021/5/13 17:53
*/
public boolean lock(String lockName, long timeout) {
checkRedissonClient();
RLock lock = getLock(lockName);
try {
if(timeout != -1){
// timeout:超时时间 TimeUnit.SECONDS:单位
lock.lock(timeout, TimeUnit.SECONDS);
}else{
lock.lock();
}
log.debug(" get lock success ,lockKey:{}", lockName);
return true;
} catch (Exception e) {
log.error(" get lock fail,lockKey:{}, cause:{} ",
lockName, e.getMessage());
return false;
}
}
/**
-
可中断锁
-
@param lockName 锁名称
-
@param waitTimeout 等待时长
-
@param unit 时间单位
-
@return
*/
public boolean tryLock(String lockName, long waitTimeout, TimeUnit unit) {
checkRedissonClient();
RLock lock = getLock(lockName);
try {
boolean res = lock.tryLock(waitTimeout,unit);
if (!res) {
最后
学习视频:
大厂面试真题:
sonTemplate(RedissonClient redissonClient) {
this.redissonClient = redissonClient;
}
/**
-
加锁(可重入),会一直等待获取锁,不会中断
-
@param lockName waitTimeout timeout
-
@return boolean
-
@author ymy
-
@date 2021/5/13 17:53
*/
public boolean lock(String lockName, long timeout) {
checkRedissonClient();
RLock lock = getLock(lockName);
try {
if(timeout != -1){
// timeout:超时时间 TimeUnit.SECONDS:单位
lock.lock(timeout, TimeUnit.SECONDS);
}else{
lock.lock();
}
log.debug(" get lock success ,lockKey:{}", lockName);
return true;
} catch (Exception e) {
log.error(" get lock fail,lockKey:{}, cause:{} ",
lockName, e.getMessage());
return false;
}
}
/**
-
可中断锁
-
@param lockName 锁名称
-
@param waitTimeout 等待时长
-
@param unit 时间单位
-
@return
*/
public boolean tryLock(String lockName, long waitTimeout, TimeUnit unit) {
checkRedissonClient();
RLock lock = getLock(lockName);
try {
boolean res = lock.tryLock(waitTimeout,unit);
if (!res) {
最后
学习视频:
[外链图片转存中…(img-0CCaXGGT-1710369703934)]
大厂面试真题:
[外链图片转存中…(img-wh0HWpTW-1710369703934)]