redisson锁说明
Redisson是基于Netty实现的，是更高性能的第三方库。实现了可重入锁（Reentrant Lock）、公平锁（Fair Lock、联锁（MultiLock）、 红锁（RedLock）、 读写锁（ReadWriteLock）等。
1、加锁机制
线程去获取锁，获取成功: 执行lua脚本，保存数据到redis数据库。
线程去获取锁，获取失败: 一直通过while循环尝试获取锁，获取成功后，执行lua脚本，保存数据到redis数据库。
2、watch dog自动延期机制（性能较差）
在一个分布式环境下，假如一个线程获得锁后，突然服务器宕机了，那么这个时候在一定时间后这个锁会自动释放，你也可以设置锁的有效时间(不设置默认30秒），这样的目的主要是防止死锁的发生。
3、使用lua脚本
通过封装在lua脚本中发送给redis，而且redis是单线程的，这样就保证这段复杂业务逻辑执行的原子性。
Redis分布式锁的缺点
Redis分布式锁会有个缺陷，就是在Redis哨兵模式下:
客户端1 对某个master节点写入了redisson锁，此时会异步复制给对应的 slave节点。但是这个过程中一旦发生 master节点宕机，主备切换，slave节点从变为了 master节点。
这时客户端2 来尝试加锁的时候，在新的master节点上也能加锁，此时就会导致多个客户端对同一个分布式锁完成了加锁。
这时系统在业务语义上一定会出现问题，导致各种脏数据的产生。
缺陷在哨兵模式或者主从模式下，如果 master实例宕机的时候，可能导致多个客户端同时完成加锁。
应用
lock
package com.andon.springbootdistributedlock.util;
import lombok.extern.slf4j.Slf4j;
import org.redisson.Redisson;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.concurrent.TimeUnit;
/**
* @author liu
* @date 2022年05月24日 15:54
*/
@Component
@Slf4j
public class DistributedRedisLock {
@Autowired
private RedissonClient redissonClient;
private static final String DEFAULT_LOCK_NAME = "redisLock_";
//加锁
public boolean lock(String lockName) {
//声明key对象
String key = DEFAULT_LOCK_NAME + lockName;
//获取锁对象
RLock mylock = redissonClient.getLock(key);
//加锁，并且设置锁过期时间3秒，防止死锁的产生 uuid+threadId
mylock.lock();
//加锁成功
return true;
}
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;
}
}
private void checkRedissonClient() {
if (null == redissonClient) {
log.error(" redissonClient is null ,please check redis instance ! ");
throw new RuntimeException("redissonClient is null ,please check redis instance !");
}
if (redissonClient.isShutdown()) {
log.error(" Redisson instance has been shut down !!!");
throw new RuntimeException("Redisson instance has been shut down !!!");
}
}
/**
* 解锁
* @param lockName
*/
public void unlock(String lockName){
checkRedissonClient();
try {
RLock lock = getLock(lockName);
if(lock.isLocked() && lock.isHeldByCurrentThread()){
lock.unlock();
log.debug("key：{}，unlock success",lockName);
}else{
log.debug("key：{}，没有加锁或者不是当前线程加的锁 ",lockName);
}
}catch (Exception e){
log.error("key：{}，unlock error,reason:{}",lockName,e.getMessage());
}
}
private RLock getLock(String lockName) {
String key = DEFAULT_LOCK_NAME + lockName;
return redissonClient.getLock(key);
}
/**
* 可中断锁
* @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;
}
}
}
RLock mylock = redissonClient.getLock(key);
mylock.lock();
RLock 中的lock() 方法的特性就是不可中断，这种锁存在比较大的安全隐患。
不设置过期时间，这种情况下，只要程序不解锁，那么其他线程都将一直处于阻塞状态，这样就会引发一个很严重的问题，那就是在线程获取到了锁之后，程序或者服务器突然宕机，等重启完成之后，其他线程也会一直处于阻塞状态，因为宕机前获取的锁还没有被释放。
redisson也为我们考虑到了这个问题，所以它设置一个看门狗。它的作用是在Redisson实例被关闭前，不断的延长锁的有效期。默认情况下，看门狗的检查锁的超时时间是30秒钟，也可以通过修改Config.lockWatchdogTimeout来另行指定。
说直白一点，如果你加的锁没有指定过期时间，那么redisson会默认将这个锁的过期时间设置为 30 秒，快到 30 的程序去自动续期，直到程序把锁释放，如果这个时候服务器宕机了，那么程序的续期功能自然也就不存在了，锁最多还能再存活 30 秒，不带超时间锁定之后，去redis中查看当前锁的有效期是不是Config.lockWatchdogTimeout 参数指定的时间，然后过了这个时间，有效期不再自动刷新。
可重入锁（Reentrant Lock），可中断
boolean tryLock();
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
boolean tryLock(long waitTime, long leaseTime, TimeUnit unit) throws InterruptedException;
RFuture<Boolean> tryLockAsync(long waitTime, long leaseTime, TimeUnit unit);
RFuture<Boolean> tryLockAsync();
RFuture<Boolean> tryLockAsync(long threadId);
RFuture<Boolean> tryLockAsync(long waitTime, TimeUnit unit);
RFuture<Boolean> tryLockAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId);
time：等待锁的最长时间。
unit：时间单位。
waitTime：与time一致，等待锁的最长时间。
leaseTime：锁的过期时间。
threadId：线程id。
一个线程带等待 time/waitTime时长后如果还没有获取到锁，那么当前线程将会放弃获取锁资源的机会，去干其他事情。Async结尾的几个方法主要就是异步加锁的意思。
/**
* 可中断锁
* @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;
}
}
公平锁（Fair Lock）
先获取锁的线程先拿到锁，后面的线程都在后面排着，它保证了当多个Redisson客户端线程同时请求加锁时，优先分配给先发出请求的线程。所有请求线程会在一个队列中排队，当某个线程出现宕机时，Redisson 会等待5秒后继续下一个线程，也就是说如果前面有5个线程都处于等待状态，那么后面的线程会等待至少25秒。
/**
* 公平锁
* @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;
}
}
联锁（MultiLock）
基于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();
}
}
}
红锁（RedLock）
基于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();
}
}
}
读写锁（ReadWriteLock）
基于Redis的Redisson分布式可重入读写锁RReadWriteLock Java对象实现了java.util.concurrent.locks.ReadWriteLock接口。其中读锁和写锁都继承了RLock接口。
分布式可重入读写锁允许同时有多个读锁和一个写锁处于加锁状态。这点相当于java并发sdk并发包中的 StampedLock 。
/**
* 读写锁
*/
@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);
}
信号量（Semaphore）
基于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);
}
闭锁（CountDownLatch）
基于Redisson的Redisson分布式闭锁（CountDownLatch）Java对象RCountDownLatch采用了与java.util.concurrent.CountDownLatch相似的接口和用法。
@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);
}
package com.andon.springbootdistributedlock.util;
import lombok.extern.slf4j.Slf4j;
import org.redisson.Redisson;
import org.redisson.api.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.concurrent.TimeUnit;
/**
* @author liu
* @date 2022年05月24日 15:54
*/
@Component
@Slf4j
public class DistributedRedisLock {
@Autowired
private RedissonClient redissonClient;
private static final String DEFAULT_LOCK_NAME = "redisLock_";
//加锁
public boolean lock(String lockName) {
//声明key对象
String key = DEFAULT_LOCK_NAME + lockName;
//获取锁对象
RLock mylock = redissonClient.getLock(key);
//加锁，并且设置锁过期时间3秒，防止死锁的产生 uuid+threadId
mylock.lock();
//加锁成功
return true;
}
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;
}
}
private void checkRedissonClient() {
if (null == redissonClient) {
log.error(" redissonClient is null ,please check redis instance ! ");
throw new RuntimeException("redissonClient is null ,please check redis instance !");
}
if (redissonClient.isShutdown()) {
log.error(" Redisson instance has been shut down !!!");
throw new RuntimeException("Redisson instance has been shut down !!!");
}
}
/**
* 解锁
* @param lockName
*/
public void unlock(String lockName){
checkRedissonClient();
try {
RLock lock = getLock(lockName);
if(lock.isLocked() && lock.isHeldByCurrentThread()){
lock.unlock();
log.debug("key：{}，unlock success",lockName);
}else{
log.debug("key：{}，没有加锁或者不是当前线程加的锁 ",lockName);
}
}catch (Exception e){
log.error("key：{}，unlock error,reason:{}",lockName,e.getMessage());
}
}
private RLock getLock(String lockName) {
String key = DEFAULT_LOCK_NAME + lockName;
return redissonClient.getLock(key);
}
/**
* 可中断锁
* @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;
}
}
/**
* 公平锁
* @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;
}
}
/**
* 获取读写锁
* @param lockName
* @return
*/
public RReadWriteLock getReadWriteLock(String lockName) {
return redissonClient.getReadWriteLock(lockName);
}
/**
* 信号量
* @param semaphoreName
* @return
*/
public RSemaphore getSemaphore(String semaphoreName) {
return redissonClient.getSemaphore(semaphoreName);
}
/**
* 可过期性信号量
* @param permitExpirableSemaphoreName
* @return
*/
public RPermitExpirableSemaphore getPermitExpirableSemaphore(String permitExpirableSemaphoreName) {
return redissonClient.getPermitExpirableSemaphore(permitExpirableSemaphoreName);
}
/**
* 闭锁
* @param countDownLatchName
* @return
*/
public RCountDownLatch getCountDownLatch(String countDownLatchName) {
return redissonClient.getCountDownLatch(countDownLatchName);
}
}
测试用例
@RunWith(SpringRunner.class)
@SpringBootTest
public class RedissonDistributedLockerTest {
private static final Logger log = LoggerFactory.getLogger(RedissonDistributedLocker.class);
@Resource
private DistributedLocker distributedLocker;
private static final ExecutorService executorServiceB = Executors.newSingleThreadExecutor();
private static final ExecutorService executorServiceC = Executors.newSingleThreadExecutor();
@Test
public void tryLockUnlockCost() throws Exception {
StopWatch stopWatch = new StopWatch("加锁解锁耗时统计");
stopWatch.start();
for (int i = 0; i < 10000; i++) {
String key = "mock-key:" + UUID.randomUUID().toString().replace("-", "");
Optional<LockResource> optLocked = distributedLocker.tryLock(key, 600000, 600000);
Assert.assertTrue(optLocked.isPresent());
optLocked.get().unlock();
}
stopWatch.stop();
log.info(stopWatch.prettyPrint());
}
@Test
public void tryLock() throws Exception {
String key = "mock-key:" + UUID.randomUUID().toString().replace("-", "");
Optional<LockResource> optLocked = distributedLocker.tryLock(key, 600000, 600000);
Assert.assertTrue(optLocked.isPresent());
Optional<LockResource> optLocked2 = distributedLocker.tryLock(key, 600000, 600000);
Assert.assertTrue(optLocked2.isPresent());
optLocked.get().unlock();
}
/**
* 模拟2个线程争抢锁：A先获取到锁，A释放锁后，B再获得锁
*/
@Test
public void tryLock2() throws Exception {
String key = "mock-key:" + UUID.randomUUID().toString().replace("-", "");
CountDownLatch countDownLatch = new CountDownLatch(1);
Future<Optional<LockResource>> submit = executorServiceB.submit(() -> {
countDownLatch.await();
log.info("B尝试获得锁：thread={}", currentThreadId());
return distributedLocker.tryLock(key, 600000, 600000);
}
);
log.info("A尝试获得锁：thread={}", currentThreadId());
Optional<LockResource> optLocked = distributedLocker.tryLock(key, 300000, 600000);
Assert.assertTrue(optLocked.isPresent());
log.info("A已获得锁：thread={}", currentThreadId());
countDownLatch.countDown();
optLocked.get().unlock();
log.info("A已释放锁：thread={}", currentThreadId());
Optional<LockResource> lockResource2 = submit.get();
Assert.assertTrue(lockResource2.isPresent());
executorServiceB.submit(() -> {
log.info("B已获得锁：thread={}", currentThreadId());
lockResource2.get().unlock();
log.info("B已释放锁：thread={}", currentThreadId());
});
}
/**
* 模拟3个线程争抢锁：A先获取到锁，A释放锁后，B和C同时争抢锁
*/
@Test
public void tryLock3() throws Exception {
String key = "mock-key:" + UUID.randomUUID().toString().replace("-", "");
log.info("A尝试获得锁：thread={}", currentThreadId());
Optional<LockResource> optLocked = distributedLocker.tryLock(key, 600000, 600000);
if (optLocked.isPresent()) {
log.info("A已获得锁：thread={}", currentThreadId());
}
Assert.assertTrue(optLocked.isPresent());
CyclicBarrier cyclicBarrier = new CyclicBarrier(2);
Future<Optional<LockResource>> submitB = executorServiceB.submit(() -> {
cyclicBarrier.await();
log.info("B尝试获得锁：thread={}", currentThreadId());
return distributedLocker.tryLock(key, 600000, 600000);
}
);
Future<Optional<LockResource>> submitC = executorServiceC.submit(() -> {
cyclicBarrier.await();
log.info("C尝试获得锁：thread={}", currentThreadId());
return distributedLocker.tryLock(key, 600000, 600000);
}
);
optLocked.get().unlock();
log.info("A已释放锁：thread={}", currentThreadId());
CountDownLatch countDownLatch = new CountDownLatch(2);
executorServiceB.submit(() -> {
log.info("B已获得锁：thread={}", currentThreadId());
try {
submitB.get().get().unlock();
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
log.info("B已释放锁：thread={}", currentThreadId());
countDownLatch.countDown();
});
executorServiceC.submit(() -> {
log.info("C已获得锁：thread={}", currentThreadId());
try {
submitC.get().get().unlock();
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
log.info("C已释放锁：thread={}", currentThreadId());
countDownLatch.countDown();
});
countDownLatch.await();
}
private static Long currentThreadId() {
return Thread.currentThread().getId();
}
@Test
public void tryLockWaitTimeout() throws Exception {
String key = "mock-key:" + UUID.randomUUID().toString();
Optional<LockResource> optLocked = distributedLocker.tryLock(key, 10, 2000);
Assert.assertTrue(optLocked.isPresent());
Optional<LockResource> optLockResource = CompletableFuture.supplyAsync(() -> {
long now = System.currentTimeMillis();
Optional<LockResource> optLockedAgain = distributedLocker.tryLock(key, 1000, 10);
long cost = System.currentTimeMillis() - now;
log.info("cost={}", cost);
return optLockedAgain;
}).exceptionally(th -> {
log.error("Exception: ", th);
return Optional.empty();
}).join();
Assert.assertTrue(!optLockResource.isPresent());
}
@Test
public void tryLockWithLeaseTime() throws Exception {
String key = "mock-key-with-leaseTime:" + UUID.randomUUID().toString();
Optional<LockResource> optLocked = distributedLocker.tryLock(key, 3000, 1000);
Assert.assertTrue(optLocked.isPresent());
// 可重入
Optional<LockResource> optLockedAgain = distributedLocker.tryLock(key, 3000, 1000);
Assert.assertTrue(optLockedAgain.isPresent());
}
/**
* 模拟1000个并发请求枪一把锁
*/
@Test
public void tryLockWithLeaseTimeOnMultiThread() throws Exception {
int totalThread = 1000;
String key = "mock-key-with-leaseTime:" + UUID.randomUUID().toString();
AtomicInteger tryAcquireLockTimes = new AtomicInteger(0);
AtomicInteger acquiredLockTimes = new AtomicInteger(0);
ExecutorService executor = Executors.newFixedThreadPool(totalThread);
for (int i = 0; i < totalThread; i++) {
executor.submit(new Runnable() {
@Override
public void run() {
tryAcquireLockTimes.getAndIncrement();
Optional<LockResource> optLocked = distributedLocker.tryLock(key, 10, 10000);
if (optLocked.isPresent()) {
acquiredLockTimes.getAndIncrement();
}
}
});
}
executor.awaitTermination(15, TimeUnit.SECONDS);
Assert.assertTrue(tryAcquireLockTimes.get() == totalThread);
Assert.assertTrue(acquiredLockTimes.get() == 1);
}
@Test
public void tryLockWithLeaseTimeOnMultiThread2() throws Exception {
int totalThread = 100;
String key = "mock-key-with-leaseTime:" + UUID.randomUUID().toString();
AtomicInteger tryAcquireLockTimes = new AtomicInteger(0);
AtomicInteger acquiredLockTimes = new AtomicInteger(0);
ExecutorService executor = Executors.newFixedThreadPool(totalThread);
for (int i = 0; i < totalThread; i++) {
executor.submit(new Runnable() {
@Override
public void run() {
long now = System.currentTimeMillis();
Optional<LockResource> optLocked = distributedLocker.tryLock(key, 10000, 5);
long cost = System.currentTimeMillis() - now;
log.info("tryAcquireLockTimes={}||wait={}", tryAcquireLockTimes.incrementAndGet(), cost);
if (optLocked.isPresent()) {
acquiredLockTimes.getAndIncrement();
// 主动释放锁
optLocked.get().unlock();
}
}
});
}
executor.awaitTermination(20, TimeUnit.SECONDS);
log.info("tryAcquireLockTimes={}, acquireLockTimes={}", tryAcquireLockTimes.get(), acquiredLockTimes.get());
Assert.assertTrue(tryAcquireLockTimes.get() == totalThread);
Assert.assertTrue(acquiredLockTimes.get() == totalThread);
}
}
public interface DistributedLocker {
Optional<LockResource> tryLock(String lockKey, int waitTime);
Optional<LockResource> tryLock(String lockKey, int waitTime, int leaseTime);
}
public interface LockResource {
void unlock();
}