springboot整合redisson（二）实现超强的分布式锁

Thread-3 在 20:22:52.494 的时候尝试获取锁，20:22:52.527 的时候获取到了锁，并且进入到了休眠状态，Thread-4 在 20:22:52.494 的时候尝试获取锁，直到 20:22:54.513 也没有获取到，然后 Thread-4就放弃了等待，直接结束了线程，期间花费了两秒钟的时间，而我们设置的等待时间刚好就是两秒，所以单元测试通过。

3.公平锁（Fair Lock）

---

基于 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 正在释放了锁

4.联锁（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();

}

}

}

5.红锁（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();

}

}

}

6.读写锁（ReadWriteLock）

---

基于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);

}

7.信号量（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);

}

8.闭锁（CountDownLatch）

---

基于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) {

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

*/

public void unlock(String lockName){

checkRedissonClient();

try {

RLock lock = redissonClient.getFairLock(DEFAULT_LOCK_NAME + 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());

}

}

public RLock getLock(String lockName) {

String key = DEFAULT_LOCK_NAME + lockName;

return redissonClient.getLock(key);

}

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

• @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);

}

}

package com.nlx.redisson;

import com.nlx.redisson.core.RedissonTemplate;

import lombok.extern.slf4j.Slf4j;

import org.junit.jupiter.api.Test;

import org.redisson.RedissonMultiLock;

import org.redisson.RedissonRedLock;

import org.redisson.api.*;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.boot.test.context.SpringBootTest;

import java.util.concurrent.CountDownLatch;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

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-test”;

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 {

log.info(“线程：{} 正在释放了锁”,threadName);

redissonTemplate.unlock(lockName);

}

}else{

log.info(“线程：{}，没有获取到锁，过了等待时长，结束等待”,threadName);

}

count.countDown();

}

/**

• 公平锁

*/

@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();

}

/**

• 联锁

*/

@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();

}

}

}

/**

• 红锁

*/

@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();

}

}

}

/**

• 读写锁

*/

@Test

public void testReadWriteLock(){

RReadWriteLock rwlock = redissonTemplate.getReadWriteLock(“testRWLock”);

rwlock.readLock().lock();

rwlock.writeLock().lock();

}

/**

• 信号量

*/

@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();

}

/**

• 信号量

*/

@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);

}

@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(“子线程执行结束。。。。。。”);

}

}

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

最后

面试题文档来啦，内容很多，485页！

由于笔记的内容太多，没办法全部展示出来，下面只截取部分内容展示。

1111道Java工程师必问面试题

MyBatis 27题 + ZooKeeper 25题 + Dubbo 30题：

Elasticsearch 24 题 +Memcached + Redis 40题：

Spring 26 题+ 微服务 27题+ Linux 45题：

Java面试题合集：

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
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(“子线程执行结束。。。。。。”);

}

}

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。[外链图片转存中…(img-iKGOPjTp-1713411974854)]

[外链图片转存中…(img-x8ZLIrPv-1713411974855)]

[外链图片转存中…(img-zTgm2plL-1713411974855)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

最后

面试题文档来啦，内容很多，485页！

由于笔记的内容太多，没办法全部展示出来，下面只截取部分内容展示。

1111道Java工程师必问面试题

[外链图片转存中…(img-XqR5zYU0-1713411974856)]

MyBatis 27题 + ZooKeeper 25题 + Dubbo 30题：

[外链图片转存中…(img-rceL6Y8y-1713411974857)]

Elasticsearch 24 题 +Memcached + Redis 40题：

[外链图片转存中…(img-5CTED8wA-1713411974857)]

Spring 26 题+ 微服务 27题+ Linux 45题：

[外链图片转存中…(img-CEqPG9Rc-1713411974858)]

Java面试题合集：

[外链图片转存中…(img-zmHhbZPy-1713411974858)]

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！