Spring Boot中使用Redisson
微服务项目中，很多资源需要互斥使用，比如一些分布式任务，比如下单的处理，退货的处理等等。这些都需要用到借助分布式锁来保证处理的唯一性。 一开始我们也手工实现了分布式锁，但是随着业务的发展，我们对锁的特性也要求越来越完善，最后选用了Redis官方推荐的Redisson。
一、Spring Boot中使用Redisson
Spring Boot使用Redisson特别简单，只要引入一个依赖就可以，redis的配置跟其他的redis客户端可以兼容，可以不用再额外配置
二、引入依赖
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson-spring-boot-starter</artifactId>
<version>3.13.2</version>
</dependency>
三、属性文件Redis配置
# Redis服务器地址
spring.redis.host=127.0.0.1
# Redis服务器连接端口
spring.redis.port=6379
四、快速入门
4.1 改造RedisDistributedLockApplication启动类
使用锁RedissonClient,并实现业务逻辑在ApplicationRunner#run()方法。
package com.erbadagang.springboot.redisdistributedlock;
import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import javax.annotation.Resource;
@Slf4j
@SpringBootApplication
public class RedisDistributedLockApplication implements ApplicationRunner {
public static void main(String[] args) {
SpringApplication.run(RedisDistributedLockApplication.class, args);
}
/**
* 直接注入RedissonClient就可以直接使用.
*/
@Resource
private RedissonClient redissonClient;
@Override
public void run(ApplicationArguments args) throws Exception {
log.info("spring boot run");
//创建锁
RLock helloLock = redissonClient.getLock("hello");
//加锁
helloLock.lock();
try {
log.info("locked");
Thread.sleep(1000 * 10);
} finally {
//释放锁
helloLock.unlock();
}
log.info("finished");
}
}
4.2 测试
启动Redis和RedisDistributedLockApplication，控制台输出：
2020-08-02 22:51:17.169 INFO 8876 --- [main] c.e.s.r.RedisDistributedLockApplication : spring boot run
2020-08-02 22:51:36.486 INFO 8876 --- [main] c.e.s.r.RedisDistributedLockApplication : locked
2020-08-02 22:51:46.493 INFO 8876 --- [main] c.e.s.r.RedisDistributedLockApplication : finished
4.3 Rlock 常用的方法
void lock();
void lock(long leaseTime, TimeUnit unit);
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
boolean tryLock(long waitTime, long leaseTime, TimeUnit unit) throws InterruptedException;
第一个方法void lock()：第一表示lock表示去加锁，加锁成功，没有返回值，继续执行下面代码；但是如果redis已经有这个锁了，它会一直阻塞，直到锁的时间失效（默认30秒），再继续往下执行。这个方法是要保证一定要抢到锁的，它的默认过期时间也是30秒，和tryLock()不同的是，它如果没抢占到锁，会一直自旋。
第二个方法void lock(long leaseTime, TimeUnit unit)：和第一无参数lock逻辑一样，只是可以直接设置锁失效时间。用法：helloLock.lock(5, TimeUnit.SECONDS);。
第三个方法两个参数的boolean tryLock(long time, TimeUnit unit)表示尝试去加锁（第一个参数表示the maximum time to wait for the lock），加锁成功,返回true，继续执行true下面代码；但是如果redis已经有这个锁了他会等待，还拿不到锁它会返回false，执行false的代码块。为了实现waitTime，使用了redis的订阅发布功能。也就是没有抢到锁的线程订阅消息，直至waitTime过期返回false或者被通知新一轮的开始抢占锁。当然，它如果抢占到锁，锁的过期时间也是30秒，同样也会存在一个定时任务续过期时间，保证业务执行时间不会超过过期时间，抢占失败即返回false。
String key ="product:001";
RLock lock = redisson.getLock(key);
try {
boolean res = lock.tryLock(10,TimeUnit.SECONDS);
if ( res){
System.out.println("这里是你的业务代码");
}else{
System.out.println("系统繁忙");
}
}catch (Exception e){
e.printStackTrace();
}finally {
lock.unlock();
}
如果把lock.unlock();注释，第一次执行正常加锁，可以跑到业务逻辑代码，快速第二次执行发现他等待10秒，如果拿不到锁就走else的系统繁忙逻辑。
三个参数的tryLock(long waitTime, long leaseTime, TimeUnit unit)表示尝试去加锁（第一个参数表示等待时间，第二个参数表示key的失效时间），加锁成功,返回true，继续执行true下面代码；如果返回false，它会等待第一个参数设置的时间，然后去执行false下面的代码。个方法的参数leaseTime如果不是-1的话，是不会有定时任务续过期时间的，也就存在业务处理时间可能超过过期时间的风险。其他的和tryLock(long waitTime, TimeUnit unit)一致。
boolean res = lock.tryLock(5,3, TimeUnit.SECONDS);
这种情况，锁3秒失效，我们配置的是等待5秒，在单机刷的情况下，肯定每次都能拿到锁。
4.4 异步执行分布式锁
/**
* 异步锁
*/
lock = redissonClient.getLock("erbadagang-lock");
Future<Boolean> res = null;
try {
// lock.lockAsync();
// lock.lockAsync(100, TimeUnit.SECONDS);
res = lock.tryLockAsync(3, 100, TimeUnit.SECONDS);
if (res.get()) {
System.out.println("这里是你的Async业务代码");
} else {
System.out.println("系统繁忙Async");
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if (res.get()) {
lock.unlock();
}
}
log.info("finished");
}
4.5 公平锁（Fair Lock）
Redisson分布式可重入公平锁也是实现了java.util.concurrent.locks.Lock接口的一种RLock对象。在提供了自动过期解锁功能的同时，保证了当多个Redisson客户端线程同时请求加锁时，优先分配给先发出请求的线程。
/**
* 公平锁测试。
*/
@Test
public void testFairLock() {
RLock fairLock = redissonClient.getFairLock("anyLock");
try {
// 最常见的使用方法
fairLock.lock();
// 支持过期解锁功能, 10秒钟以后自动解锁,无需调用unlock方法手动解锁
fairLock.lock(10, TimeUnit.SECONDS);
// 尝试加锁，最多等待100秒，上锁以后10秒自动解锁
boolean res = fairLock.tryLock(100, 10, TimeUnit.SECONDS);
if (res) {
System.out.println("这里是你的业务代码");
} else {
System.out.println("系统繁忙");
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
fairLock.unlock();
}
}
Redisson同时还为分布式可重入公平锁提供了异步执行的相关方法：
RLock fairLock = redisson.getFairLock("anyLock");
fairLock.lockAsync();
fairLock.lockAsync(10, TimeUnit.SECONDS);
Future<Boolean> res = fairLock.tryLockAsync(100, 10, TimeUnit.SECONDS);
五、扩展实现
Redis单节点配置:
server:
port: 8080
spring:
application:
name: redis-distributed-lock
################ Redis ##############
redis:
host: 127.0.0.1
port: 6379
#password:
timeout: 3000
lettuce:
pool:
max-active: 8
max-wait: -1
max-idle: 8
min-idle: 0
redisson:
config:
# 单节点配置
singleServerConfig:
# 连接空闲超时，单位：毫秒
idleConnectionTimeout: 10000
pingTimeout: 1000
# 连接超时，单位：毫秒
connectTimeout: 10000
# 命令等待超时，单位：毫秒
timeout: 3000
# 命令失败重试次数,如果尝试达到 retryAttempts（命令失败重试次数） 仍然不能将命令发送至某个指定的节点时，将抛出错误。
# 如果尝试在此限制之内发送成功，则开始启用 timeout（命令等待超时） 计时。
retryAttempts: 3
# 命令重试发送时间间隔，单位：毫秒
retryInterval: 1500
# 重新连接时间间隔，单位：毫秒
reconnectionTimeout: 3000
# 执行失败最大次数
failedAttempts: 3
# 密码
password: null
# 单个连接最大订阅数量
subscriptionsPerConnection: 5
# 客户端名称
clientName: null
# 节点地址
address: redis://127.0.0.1:6379
# 发布和订阅连接的最小空闲连接数
subscriptionConnectionMinimumIdleSize: 1
# 发布和订阅连接池大小
subscriptionConnectionPoolSize: 50
# 最小空闲连接数
connectionMinimumIdleSize: 32
# 连接池大小
connectionPoolSize: 64
# 数据库编号
database: 0
# DNS监测时间间隔，单位：毫秒
dnsMonitoringInterval: 5000
# 线程池数量,默认值: 当前处理核数量 * 2
threads: 0
# Netty线程池数量,默认值: 当前处理核数量 * 2
nettyThreads: 0
# 编码
#codec: !<org.redisson.codec.JsonJacksonCodec> {}
# 传输模式
transportMode: "NIO"
Redis集群配置:
spring:
redis:
redisson:
config:
clusterServersConfig:
idleConnectionTimeout: 10000
connectTimeout: 10000
timeout: 3000
retryAttempts: 3
retryInterval: 1500
failedSlaveReconnectionInterval: 3000
failedSlaveCheckInterval: 60000
password: null
subscriptionsPerConnection: 5
clientName: null
loadBalancer: ！<org.redisson.connection.balancer.RoundRobinLoadBalancer> {}
subscriptionConnectionMinimumIdleSize: 1
subscriptionConnectionPoolSize: 50
slaveConnectionMinimumIdleSize: 24
slaveConnectionPoolSize: 64
masterConnectionMinimumIdleSize: 24
masterConnectionPoolSize: 64
readMode: "SLAVE"
subscriptionMode: "SLAVE"
nodeAddresses:
- "redis://192.168.35.142:7002"
- "redis://192.168.35.142:7001"
- "redis://192.168.35.142:7000"
scanInterval: 1000
pingConnectionInterval: 0
keepAlive: false
tcpNoDelay: false
threads: 16
nettyThreads: 32
#codec: !<org.redisson.codec.FstCodec> {}
transportMode: "NIO"
多线程测试：
package com.erbadagang.springboot.redisdistributedlock;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.boot.test.context.SpringBootTest;
import javax.annotation.Resource;
import java.util.concurrent.CountDownLatch;
@SpringBootTest
@Slf4j
class RedisDistributedLockApplicationTests {
/**
* 有锁测试共享变量
*/
private Integer lockCount = 10;
/**
* 无锁测试共享变量
*/
private Integer count = 10;
/**
* 模拟线程数
*/
private static int threadNum = 10;
/**
* 直接注入RedissonClient就可以直接使用.
*/
@Resource
private RedissonClient redissonClient;
/**
* 模拟并发测试加锁和不加锁2个方法。
*
* @return
*/
@Test
public void lock() {
// 计数器
final CountDownLatch countDownLatch = new CountDownLatch(1);
for (int i = 0; i < threadNum; i++) {
MyRunnable myRunnable = new MyRunnable(countDownLatch);
Thread myThread = new Thread(myRunnable);
myThread.start();
}
// 释放所有线程
countDownLatch.countDown();
}
/**
* 加锁测试
*/
private void testLockCount() {
String lockKey = "lock-test";
//创建锁
RLock helloLock = redissonClient.getLock(lockKey);
try {
//加锁
helloLock.lock();
lockCount--;
log.info("lockCount值：" + lockCount);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
// 释放锁
helloLock.unlock();
}
}
/**
* 无锁测试
*/
private void testCount() {
count--;
log.info("count值：" + count);
}
public class MyRunnable implements Runnable {
/**
* 计数器
*/
final CountDownLatch countDownLatch;
public MyRunnable(CountDownLatch countDownLatch) {
this.countDownLatch = countDownLatch;
}
@Override
public void run() {
try {
// 阻塞当前线程，直到计时器的值为0
countDownLatch.await();
} catch (InterruptedException e) {
log.error(e.getMessage(), e);
}
// 无锁操作
testCount();
// 加锁操作
testLockCount();
}
}
}
控制台输出：
2020-08-02 23:55:39.832 INFO 4144 --- [ Thread-281] s.r.RedisDistributedLockApplicationTests : count值：3
2020-08-02 23:55:39.832 INFO 4144 --- [ Thread-283] s.r.RedisDistributedLockApplicationTests : count值：2
2020-08-02 23:55:39.832 INFO 4144 --- [ Thread-279] s.r.RedisDistributedLockApplicationTests : count值：5
2020-08-02 23:55:39.832 INFO 4144 --- [ Thread-282] s.r.RedisDistributedLockApplicationTests : count值：2
2020-08-02 23:55:39.832 INFO 4144 --- [ Thread-284] s.r.RedisDistributedLockApplicationTests : count值：2
2020-08-02 23:55:39.832 INFO 4144 --- [ Thread-278] s.r.RedisDistributedLockApplicationTests : count值：5
2020-08-02 23:55:39.832 INFO 4144 --- [ Thread-280] s.r.RedisDistributedLockApplicationTests : count值：4
2020-08-02 23:55:39.832 INFO 4144 --- [ Thread-275] s.r.RedisDistributedLockApplicationTests : count值：2
2020-08-02 23:55:39.832 INFO 4144 --- [ Thread-276] s.r.RedisDistributedLockApplicationTests : count值：2
2020-08-02 23:55:39.832 INFO 4144 --- [ Thread-277] s.r.RedisDistributedLockApplicationTests : count值：2
2020-08-02 23:55:39.848 INFO 4144 --- [ Thread-280] s.r.RedisDistributedLockApplicationTests : lockCount值：9
2020-08-02 23:55:39.848 INFO 4144 --- [ Thread-275] s.r.RedisDistributedLockApplicationTests : lockCount值：8
2020-08-02 23:55:39.883 INFO 4144 --- [ Thread-281] s.r.RedisDistributedLockApplicationTests : lockCount值：7
2020-08-02 23:55:39.885 INFO 4144 --- [extShutdownHook] o.s.s.concurrent.ThreadPoolTaskExecutor : Shutting down ExecutorService 'applicationTaskExecutor'
2020-08-02 23:55:39.885 INFO 4144 --- [ Thread-279] s.r.RedisDistributedLockApplicationTests : lockCount值：6
2020-08-02 23:55:39.885 INFO 4144 --- [ Thread-277] s.r.RedisDistributedLockApplicationTests : lockCount值：5
2020-08-02 23:55:39.885 INFO 4144 --- [ Thread-284] s.r.RedisDistributedLockApplicationTests : lockCount值：4
2020-08-02 23:55:39.903 INFO 4144 --- [ Thread-282] s.r.RedisDistributedLockApplicationTests : lockCount值：3
根据打印结果可以明显看到，未加锁的count--后值是乱序的，而加锁后的结果和我们预期的一样。由于条件问题没办法测试分布式的并发。只能模拟单服务的这种并发，但是原理是一样
一、Spring Boot中使用Redisson
Spring Boot使用Redisson特别简单，只要引入一个依赖就可以，redis的配置跟其他的redis客户端可以兼容，可以不用再额外配置
二、引入依赖
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson-spring-boot-starter</artifactId>
<version>3.13.2</version>
</dependency>
三、属性文件Redis配置
# Redis服务器地址
spring.redis.host=127.0.0.1
# Redis服务器连接端口
spring.redis.port=6379
四、快速入门
4.1 改造RedisDistributedLockApplication启动类
使用锁RedissonClient,并实现业务逻辑在ApplicationRunner#run()方法。
package com.erbadagang.springboot.redisdistributedlock;
import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import javax.annotation.Resource;
@Slf4j
@SpringBootApplication
public class RedisDistributedLockApplication implements ApplicationRunner {
public static void main(String[] args) {
SpringApplication.run(RedisDistributedLockApplication.class, args);
}
/**
* 直接注入RedissonClient就可以直接使用.
*/
@Resource
private RedissonClient redissonClient;
@Override
public void run(ApplicationArguments args) throws Exception {
log.info("spring boot run");
//创建锁
RLock helloLock = redissonClient.getLock("hello");
//加锁
helloLock.lock();
try {
log.info("locked");
Thread.sleep(1000 * 10);
} finally {
//释放锁
helloLock.unlock();
}
log.info("finished");
}
}
4.2 测试
启动Redis和RedisDistributedLockApplication，控制台输出：
2020-08-02 22:51:17.169 INFO 8876 --- [main] c.e.s.r.RedisDistributedLockApplication : spring boot run
2020-08-02 22:51:36.486 INFO 8876 --- [main] c.e.s.r.RedisDistributedLockApplication : locked
2020-08-02 22:51:46.493 INFO 8876 --- [main] c.e.s.r.RedisDistributedLockApplication : finished
4.3 Rlock 常用的方法
void lock();
void lock(long leaseTime, TimeUnit unit);
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
boolean tryLock(long waitTime, long leaseTime, TimeUnit unit) throws InterruptedException;
第一个方法void lock()：第一表示lock表示去加锁，加锁成功，没有返回值，继续执行下面代码；但是如果redis已经有这个锁了，它会一直阻塞，直到锁的时间失效（默认30秒），再继续往下执行。这个方法是要保证一定要抢到锁的，它的默认过期时间也是30秒，和tryLock()不同的是，它如果没抢占到锁，会一直自旋。
第二个方法void lock(long leaseTime, TimeUnit unit)：和第一无参数lock逻辑一样，只是可以直接设置锁失效时间。用法：helloLock.lock(5, TimeUnit.SECONDS);。
第三个方法两个参数的boolean tryLock(long time, TimeUnit unit)表示尝试去加锁（第一个参数表示the maximum time to wait for the lock），加锁成功,返回true，继续执行true下面代码；但是如果redis已经有这个锁了他会等待，还拿不到锁它会返回false，执行false的代码块。为了实现waitTime，使用了redis的订阅发布功能。也就是没有抢到锁的线程订阅消息，直至waitTime过期返回false或者被通知新一轮的开始抢占锁。当然，它如果抢占到锁，锁的过期时间也是30秒，同样也会存在一个定时任务续过期时间，保证业务执行时间不会超过过期时间，抢占失败即返回false。
String key ="product:001";
RLock lock = redisson.getLock(key);
try {
boolean res = lock.tryLock(10,TimeUnit.SECONDS);
if ( res){
System.out.println("这里是你的业务代码");
}else{
System.out.println("系统繁忙");
}
}catch (Exception e){
e.printStackTrace();
}finally {
lock.unlock();
}
如果把lock.unlock();注释，第一次执行正常加锁，可以跑到业务逻辑代码，快速第二次执行发现他等待10秒，如果拿不到锁就走else的系统繁忙逻辑。
三个参数的tryLock(long waitTime, long leaseTime, TimeUnit unit)表示尝试去加锁（第一个参数表示等待时间，第二个参数表示key的失效时间），加锁成功,返回true，继续执行true下面代码；如果返回false，它会等待第一个参数设置的时间，然后去执行false下面的代码。个方法的参数leaseTime如果不是-1的话，是不会有定时任务续过期时间的，也就存在业务处理时间可能超过过期时间的风险。其他的和tryLock(long waitTime, TimeUnit unit)一致。
boolean res = lock.tryLock(5,3, TimeUnit.SECONDS);
这种情况，锁3秒失效，我们配置的是等待5秒，在单机刷的情况下，肯定每次都能拿到锁。
4.4 异步执行分布式锁
/**
* 异步锁
*/
lock = redissonClient.getLock("erbadagang-lock");
Future<Boolean> res = null;
try {
// lock.lockAsync();
// lock.lockAsync(100, TimeUnit.SECONDS);
res = lock.tryLockAsync(3, 100, TimeUnit.SECONDS);
if (res.get()) {
System.out.println("这里是你的Async业务代码");
} else {
System.out.println("系统繁忙Async");
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if (res.get()) {
lock.unlock();
}
}
log.info("finished");
}
4.5 公平锁（Fair Lock）
Redisson分布式可重入公平锁也是实现了java.util.concurrent.locks.Lock接口的一种RLock对象。在提供了自动过期解锁功能的同时，保证了当多个Redisson客户端线程同时请求加锁时，优先分配给先发出请求的线程。
/**
* 公平锁测试。
*/
@Test
public void testFairLock() {
RLock fairLock = redissonClient.getFairLock("anyLock");
try {
// 最常见的使用方法
fairLock.lock();
// 支持过期解锁功能, 10秒钟以后自动解锁,无需调用unlock方法手动解锁
fairLock.lock(10, TimeUnit.SECONDS);
// 尝试加锁，最多等待100秒，上锁以后10秒自动解锁
boolean res = fairLock.tryLock(100, 10, TimeUnit.SECONDS);
if (res) {
System.out.println("这里是你的业务代码");
} else {
System.out.println("系统繁忙");
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
fairLock.unlock();
}
}
Redisson同时还为分布式可重入公平锁提供了异步执行的相关方法：
RLock fairLock = redisson.getFairLock("anyLock");
fairLock.lockAsync();
fairLock.lockAsync(10, TimeUnit.SECONDS);
Future<Boolean> res = fairLock.tryLockAsync(100, 10, TimeUnit.SECONDS);
五、扩展实现
Redis单节点配置:
server:
port: 8080
spring:
application:
name: redis-distributed-lock
################ Redis ##############
redis:
host: 127.0.0.1
port: 6379
#password:
timeout: 3000
lettuce:
pool:
max-active: 8
max-wait: -1
max-idle: 8
min-idle: 0
redisson:
config:
# 单节点配置
singleServerConfig:
# 连接空闲超时，单位：毫秒
idleConnectionTimeout: 10000
pingTimeout: 1000
# 连接超时，单位：毫秒
connectTimeout: 10000
# 命令等待超时，单位：毫秒
timeout: 3000
# 命令失败重试次数,如果尝试达到 retryAttempts（命令失败重试次数） 仍然不能将命令发送至某个指定的节点时，将抛出错误。
# 如果尝试在此限制之内发送成功，则开始启用 timeout（命令等待超时） 计时。
retryAttempts: 3
# 命令重试发送时间间隔，单位：毫秒
retryInterval: 1500
# 重新连接时间间隔，单位：毫秒
reconnectionTimeout: 3000
# 执行失败最大次数
failedAttempts: 3
# 密码
password: null
# 单个连接最大订阅数量
subscriptionsPerConnection: 5
# 客户端名称
clientName: null
# 节点地址
address: redis://127.0.0.1:6379
# 发布和订阅连接的最小空闲连接数
subscriptionConnectionMinimumIdleSize: 1
# 发布和订阅连接池大小
subscriptionConnectionPoolSize: 50
# 最小空闲连接数
connectionMinimumIdleSize: 32
# 连接池大小
connectionPoolSize: 64
# 数据库编号
database: 0
# DNS监测时间间隔，单位：毫秒
dnsMonitoringInterval: 5000
# 线程池数量,默认值: 当前处理核数量 * 2
threads: 0
# Netty线程池数量,默认值: 当前处理核数量 * 2
nettyThreads: 0
# 编码
#codec: !<org.redisson.codec.JsonJacksonCodec> {}
# 传输模式
transportMode: "NIO"
Redis集群配置:
spring:
redis:
redisson:
config:
clusterServersConfig:
idleConnectionTimeout: 10000
connectTimeout: 10000
timeout: 3000
retryAttempts: 3
retryInterval: 1500
failedSlaveReconnectionInterval: 3000
failedSlaveCheckInterval: 60000
password: null
subscriptionsPerConnection: 5
clientName: null
loadBalancer: ！<org.redisson.connection.balancer.RoundRobinLoadBalancer> {}
subscriptionConnectionMinimumIdleSize: 1
subscriptionConnectionPoolSize: 50
slaveConnectionMinimumIdleSize: 24
slaveConnectionPoolSize: 64
masterConnectionMinimumIdleSize: 24
masterConnectionPoolSize: 64
readMode: "SLAVE"
subscriptionMode: "SLAVE"
nodeAddresses:
- "redis://192.168.35.142:7002"
- "redis://192.168.35.142:7001"
- "redis://192.168.35.142:7000"
scanInterval: 1000
pingConnectionInterval: 0
keepAlive: false
tcpNoDelay: false
threads: 16
nettyThreads: 32
#codec: !<org.redisson.codec.FstCodec> {}
transportMode: "NIO"
多线程测试：
package com.erbadagang.springboot.redisdistributedlock;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.boot.test.context.SpringBootTest;
import javax.annotation.Resource;
import java.util.concurrent.CountDownLatch;
@SpringBootTest
@Slf4j
class RedisDistributedLockApplicationTests {
/**
* 有锁测试共享变量
*/
private Integer lockCount = 10;
/**
* 无锁测试共享变量
*/
private Integer count = 10;
/**
* 模拟线程数
*/
private static int threadNum = 10;
/**
* 直接注入RedissonClient就可以直接使用.
*/
@Resource
private RedissonClient redissonClient;
/**
* 模拟并发测试加锁和不加锁2个方法。
*
* @return
*/
@Test
public void lock() {
// 计数器
final CountDownLatch countDownLatch = new CountDownLatch(1);
for (int i = 0; i < threadNum; i++) {
MyRunnable myRunnable = new MyRunnable(countDownLatch);
Thread myThread = new Thread(myRunnable);
myThread.start();
}
// 释放所有线程
countDownLatch.countDown();
}
/**
* 加锁测试
*/
private void testLockCount() {
String lockKey = "lock-test";
//创建锁
RLock helloLock = redissonClient.getLock(lockKey);
try {
//加锁
helloLock.lock();
lockCount--;
log.info("lockCount值：" + lockCount);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
// 释放锁
helloLock.unlock();
}
}
/**
* 无锁测试
*/
private void testCount() {
count--;
log.info("count值：" + count);
}
public class MyRunnable implements Runnable {
/**
* 计数器
*/
final CountDownLatch countDownLatch;
public MyRunnable(CountDownLatch countDownLatch) {
this.countDownLatch = countDownLatch;
}
@Override
public void run() {
try {
// 阻塞当前线程，直到计时器的值为0
countDownLatch.await();
} catch (InterruptedException e) {
log.error(e.getMessage(), e);
}
// 无锁操作
testCount();
// 加锁操作
testLockCount();
}
}
}
控制台输出：
2020-08-02 23:55:39.832 INFO 4144 --- [ Thread-281] s.r.RedisDistributedLockApplicationTests : count值：3
2020-08-02 23:55:39.832 INFO 4144 --- [ Thread-283] s.r.RedisDistributedLockApplicationTests : count值：2
2020-08-02 23:55:39.832 INFO 4144 --- [ Thread-279] s.r.RedisDistributedLockApplicationTests : count值：5
2020-08-02 23:55:39.832 INFO 4144 --- [ Thread-282] s.r.RedisDistributedLockApplicationTests : count值：2
2020-08-02 23:55:39.832 INFO 4144 --- [ Thread-284] s.r.RedisDistributedLockApplicationTests : count值：2
2020-08-02 23:55:39.832 INFO 4144 --- [ Thread-278] s.r.RedisDistributedLockApplicationTests : count值：5
2020-08-02 23:55:39.832 INFO 4144 --- [ Thread-280] s.r.RedisDistributedLockApplicationTests : count值：4
2020-08-02 23:55:39.832 INFO 4144 --- [ Thread-275] s.r.RedisDistributedLockApplicationTests : count值：2
2020-08-02 23:55:39.832 INFO 4144 --- [ Thread-276] s.r.RedisDistributedLockApplicationTests : count值：2
2020-08-02 23:55:39.832 INFO 4144 --- [ Thread-277] s.r.RedisDistributedLockApplicationTests : count值：2
2020-08-02 23:55:39.848 INFO 4144 --- [ Thread-280] s.r.RedisDistributedLockApplicationTests : lockCount值：9
2020-08-02 23:55:39.848 INFO 4144 --- [ Thread-275] s.r.RedisDistributedLockApplicationTests : lockCount值：8
2020-08-02 23:55:39.883 INFO 4144 --- [ Thread-281] s.r.RedisDistributedLockApplicationTests : lockCount值：7
2020-08-02 23:55:39.885 INFO 4144 --- [extShutdownHook] o.s.s.concurrent.ThreadPoolTaskExecutor : Shutting down ExecutorService 'applicationTaskExecutor'
2020-08-02 23:55:39.885 INFO 4144 --- [ Thread-279] s.r.RedisDistributedLockApplicationTests : lockCount值：6
2020-08-02 23:55:39.885 INFO 4144 --- [ Thread-277] s.r.RedisDistributedLockApplicationTests : lockCount值：5
2020-08-02 23:55:39.885 INFO 4144 --- [ Thread-284] s.r.RedisDistributedLockApplicationTests : lockCount值：4
2020-08-02 23:55:39.903 INFO 4144 --- [ Thread-282] s.r.RedisDistributedLockApplicationTests : lockCount值：3
根据打印结果可以明显看到，未加锁的count--后值是乱序的，而加锁后的结果和我们预期的一样。由于条件问题没办法测试分布式的并发。只能模拟单服务的这种并发，但是原理是一样
