springboot整合redisson实战（二）Redisson分布式锁的使用

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 {@Autowiredprivate 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+threadIdmylock.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实例

与联锁比较相似，都是对多个资源进行加锁，但是红锁与连锁不同的是，红锁只需要在大部分资源加锁成功即可，

 /*** 红锁*/@Testpublic 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 。

/*** 读写锁*/@Testpublic 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);}

 /*** 信号量*/@Testpublic 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);}

/*** 信号量*/@Testpublic 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相似的接口和用法。

 @Testpublic 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 {@Autowiredprivate 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+threadIdmylock.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);@Resourceprivate DistributedLocker distributedLocker;private static final ExecutorService executorServiceB = Executors.newSingleThreadExecutor();private static final ExecutorService executorServiceC = Executors.newSingleThreadExecutor();@Testpublic 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());}@Testpublic 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再获得锁*/@Testpublic 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同时争抢锁*/@Testpublic 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();}@Testpublic 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());}@Testpublic 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个并发请求枪一把锁*/@Testpublic 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() {@Overridepublic 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);}@Testpublic 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() {@Overridepublic 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();}