SpringBoot+Redisson实现分布式锁
目录
- 项目结构
-
- pom.xml
- application.yml
- RedissonProperties
- RedissonAutoConfiguration
- DistributedLocker
- RedissonDistributedLocker
- RedissonLockUtil
- RedissonLockApplication
- TestController
- 测试结果
- Redisson分布式锁原理
源码见gitee
链接: https://gitee.com/qiu_yunzhao/distributed_lock.
项目结构
pom.xml
依赖
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.4.3</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.haoqian</groupId>
<artifactId>redission_lock</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>redission_lock</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson-spring-boot-starter</artifactId>
<version>3.13.6</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
application.yml
配置文件
redisson:
# 单机
address: 127.0.0.1:6931
password: aaaaaa
database: 10
# # 哨兵集群
# master-name: mymaster
# password: aaaaaa
# sentinel-addresses:
# - 10.47.91.83:26379
# - 10.47.91.83:26380
# - 10.47.91.83:26381
RedissonProperties
redisson配置文件的装配类
package com.haoqian.redission_lock.config;
import org.springframework.boot.context.properties.ConfigurationProperties;
@ConfigurationProperties(prefix = "redisson")
public class RedissonProperties {
private int timeout = 3000; // 连接超时时间
private String address; // 单机redis地址
private String password; // redis密码
private int database = 0; // 使用的redis库号
private int connectionPoolSize = 64; // 连接池大小
private int connectionMinimumIdleSize = 10; // 连接池中的最小空闲连接
private int slaveConnectionPoolSize = 250; // 从节点连接池大小
private int masterConnectionPoolSize = 250; // 主节点连接池大小
private String masterName; // 主节点名称
private String[] sentinelAddresses; // 集群地址
public int getTimeout() {
return timeout;
}
public void setTimeout(int timeout) {
this.timeout = timeout;
}
public int getSlaveConnectionPoolSize() {
return slaveConnectionPoolSize;
}
public void setSlaveConnectionPoolSize(int slaveConnectionPoolSize) {
this.slaveConnectionPoolSize = slaveConnectionPoolSize;
}
public int getMasterConnectionPoolSize() {
return masterConnectionPoolSize;
}
public void setMasterConnectionPoolSize(int masterConnectionPoolSize) {
this.masterConnectionPoolSize = masterConnectionPoolSize;
}
public String[] getSentinelAddresses() {
return sentinelAddresses;
}
public void setSentinelAddresses(String[] sentinelAddresses) {
this.sentinelAddresses = sentinelAddresses;
}
public String getMasterName() {
return masterName;
}
public void setMasterName(String masterName) {
this.masterName = masterName;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public int getDatabase() {
return this.database;
}
public void setDatabase(int database) {
this.database = database;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public int getConnectionPoolSize() {
return connectionPoolSize;
}
public void setConnectionPoolSize(int connectionPoolSize) {
this.connectionPoolSize = connectionPoolSize;
}
public int getConnectionMinimumIdleSize() {
return connectionMinimumIdleSize;
}
public void setConnectionMinimumIdleSize(int connectionMinimumIdleSize) {
this.connectionMinimumIdleSize = connectionMinimumIdleSize;
}
}
RedissonAutoConfiguration
启动springboot是 RedissonClient 注入到spring容器，并装配工具类RedissonLockUtil
package com.haoqian.redission_lock.config;
import com.haoqian.redission_lock.distributedLock.DistributedLocker;
import com.haoqian.redission_lock.distributedLock.RedissonDistributedLocker;
import com.haoqian.redission_lock.Utils.RedissonLockUtil;
import io.micrometer.core.instrument.util.StringUtils;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.redisson.config.SentinelServersConfig;
import org.redisson.config.SingleServerConfig;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
@ConditionalOnClass(Config.class) // org.redisson.config.Config
@EnableConfigurationProperties(RedissonProperties.class) // 自定义redisson配置类
public class RedissonAutoConfiguration {
@Autowired
private RedissonProperties redissonProperties;
/**
* 哨兵模式自动装配
*
* @return
*/
@Bean
@ConditionalOnProperty(name = "redisson.master-name")
RedissonClient redissonSentinelClient() {
Config config = new Config();
SentinelServersConfig serverConfig = config.useSentinelServers()
.addSentinelAddress(redissonProperties.getSentinelAddresses())
.setMasterName(redissonProperties.getMasterName())
.setTimeout(redissonProperties.getTimeout())
.setMasterConnectionPoolSize(redissonProperties.getMasterConnectionPoolSize())
.setSlaveConnectionPoolSize(redissonProperties.getSlaveConnectionPoolSize())
.setDatabase(redissonProperties.getDatabase());
if (StringUtils.isNotBlank(redissonProperties.getPassword())) {
serverConfig.setPassword(redissonProperties.getPassword());
}
return Redisson.create(config);
}
/**
* 单机模式自动装配
*
* @return
*/
@Bean
@ConditionalOnProperty(name = "redisson.address")
RedissonClient redissonSingleClient() {
Config config = new Config();
SingleServerConfig serverConfig = config.useSingleServer()
.setAddress("redis://" + redissonProperties.getAddress())
.setTimeout(redissonProperties.getTimeout())
.setConnectionPoolSize(redissonProperties.getConnectionPoolSize())
.setConnectionMinimumIdleSize(redissonProperties.getConnectionMinimumIdleSize())
.setDatabase(redissonProperties.getDatabase());
if (StringUtils.isNotBlank(redissonProperties.getPassword())) {
serverConfig.setPassword(redissonProperties.getPassword());
}
return Redisson.create(config);
}
/**
* 装配locker类，并将实例注入到 RedissLockUtil 中
*
* @return
*/
@Bean
DistributedLocker distributedLocker(RedissonClient redissonClient) {
RedissonDistributedLocker locker = new RedissonDistributedLocker(redissonClient);
RedissonLockUtil.setLocker(locker);
return locker;
}
}
DistributedLocker
自定义封装Redisson分布式锁的lock接口
package com.haoqian.redission_lock.distributedLock;
import java.util.concurrent.TimeUnit;
/**
* 分布式锁接口
*/
public interface DistributedLocker {
/**
* 获取锁，如果锁不可用，则当前线程处于休眠状态，直到获得锁为止。
*
* @param lockKey
*/
void lock(String lockKey);
/**
* 获取锁,如果锁不可用，则当前线程处于休眠状态，直到获得锁为止。
* 如果获取到锁后，执行结束后调用 unlock(String lockKey) 解锁或达到超时时间后会自动释放锁
* 默认时间单位是 TimeUnit.SECONDS
*
* @param lockKey
* @param leaseTime
*/
void lock(String lockKey, int leaseTime);
/**
* 获取锁,如果锁不可用，则当前线程处于休眠状态，直到获得锁为止。
* 如果获取到锁后，执行结束后调用 unlock(String lockKey) 解锁或达到超时时间后会自动释放锁
*
* @param lockKey // 锁唯一名称
* @param leaseTime // 持有锁的时间
* @param unit // 指定 leaseTime 的时间单位
*/
void lock(String lockKey, int leaseTime, TimeUnit unit);
/**
* 尝试获取锁，获取到立即返回true,未获取到立即返回false
*
* @param lockKey
* @return
*/
boolean tryLock(String lockKey);
/**
* 尝试获取锁，在等待时间内获取到锁则返回true,否则返回false,
* 如果获取到锁，执行完后程序调用 unlock(String lockKey) 释放锁或在给定的超时时间leaseTime后释放锁
*
* @param lockKey
* @param waitTime // 尝试获取锁的等待时间
* @param leaseTime // 持有锁的时间
* @param unit // 指定 leaseTime 的时间单位
* @return
*/
boolean tryLock(String lockKey, long waitTime, long leaseTime, TimeUnit unit) throws InterruptedException;
/**
* 锁是否被任意一个线程锁持有
*
* @param lockKey
* @return
*/
boolean isLocked(String lockKey);
/**
* 释放锁
*
* @param lockKey
*/
void unlock(String lockKey);
}
RedissonDistributedLocker
自定义封装Redisson分布式锁的lock接口实现类
package com.haoqian.redission_lock.distributedLock;
import com.haoqian.redission_lock.distributedLock.DistributedLocker;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import java.util.concurrent.TimeUnit;
public class RedissonDistributedLocker implements DistributedLocker {
private RedissonClient redissonClient;
public RedissonDistributedLocker() {
}
public RedissonDistributedLocker(RedissonClient redissonClient) {
this.redissonClient = redissonClient;
}
@Override
public void lock(String lockKey) {
RLock lock = redissonClient.getLock(lockKey);
lock.lock();
}
@Override
public void lock(String lockKey, int leaseTime) {
RLock lock = redissonClient.getLock(lockKey);
lock.lock(leaseTime, TimeUnit.SECONDS);
}
@Override
public void lock(String lockKey, int leaseTime, TimeUnit unit) {
RLock lock = redissonClient.getLock(lockKey);
lock.lock(leaseTime, unit);
}
@Override
public boolean tryLock(String lockKey) {
RLock lock = redissonClient.getLock(lockKey);
return lock.tryLock();
}
@Override
public boolean tryLock(String lockKey, long waitTime, long leaseTime, TimeUnit unit) throws InterruptedException {
RLock lock = redissonClient.getLock(lockKey);
return lock.tryLock(waitTime, leaseTime, unit);
}
@Override
public boolean isLocked(String lockKey) {
RLock lock = redissonClient.getLock(lockKey);
return lock.isLocked();
}
@Override
public void unlock(String lockKey) {
RLock lock = redissonClient.getLock(lockKey);
lock.unlock();
}
}
RedissonLockUtil
redis分布式锁工具类
package com.haoqian.redission_lock.Utils;
import com.haoqian.redission_lock.distributedLock.DistributedLocker;
import java.util.concurrent.TimeUnit;
/**
* redisson 分布式锁帮助类
*/
public class RedissonLockUtil {
private static DistributedLocker redissonLocker;
public static void setLocker(DistributedLocker locker) {
redissonLocker = locker;
}
/**
* 获取锁
*
* @param lockKey
*/
public static void lock(String lockKey) {
redissonLocker.lock(lockKey);
}
/**
* 获取锁，超时释放
*
* @param lockKey
* @param leaseTime 持有锁的时间(单位：秒)
*/
public static void lock(String lockKey, int leaseTime) {
redissonLocker.lock(lockKey, leaseTime);
}
/**
* 获取锁，超时释放，指定时间单位
*
* @param lockKey
* @param leaseTime 持有锁的时间
* @param unit leaseTime的单位
*/
public static void lock(String lockKey, int leaseTime, TimeUnit unit) {
redissonLocker.lock(lockKey, leaseTime, unit);
}
/**
* 尝试获取锁，获取到立即返回true,获取失败立即返回false
*
* @param lockKey
* @return
*/
public static boolean tryLock(String lockKey) {
return redissonLocker.tryLock(lockKey);
}
/**
* 尝试获取锁，在给定的waitTime时间内尝试，获取到返回true,获取失败返回false,获取到后再给定的leaseTime时间超时释放
*
* @param lockKey
* @param waitTime
* @param leaseTime
* @param unit
* @return
* @throws InterruptedException
*/
public static boolean tryLock(String lockKey, long waitTime, long leaseTime, TimeUnit unit) throws InterruptedException {
return redissonLocker.tryLock(lockKey, waitTime, leaseTime, unit);
}
/**
* 锁是否被任意一个线程锁持有
*
* @param lockKey
* @return
*/
public static boolean isLocked(String lockKey) {
return redissonLocker.isLocked(lockKey);
}
/**
* 解锁
*
* @param lockKey
*/
public static void unlock(String lockKey) {
redissonLocker.unlock(lockKey);
}
}
RedissonLockApplication
主启动类
package com.haoqian.redission_lock;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class RedissonLockApplication {
public static void main(String[] args) {
SpringApplication.run(RedissonLockApplication.class, args);
}
}
TestController
测试类
package com.haoqian.redission_lock.controller;
import com.haoqian.redission_lock.Utils.RedissonLockUtil;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.concurrent.TimeUnit;
@RestController
public class TestController {
/**
* lock 会阻塞知道获取到锁
*/
@GetMapping("/testLock1")
public void testLock1() {
for (int i = 0; i < 5; i++) {
new Thread(new Runnable() {
@Override
public void run() {
try {
RedissonLockUtil.lock("RedissonLock");
System.out.println(Thread.currentThread().getName() + "获取到锁");
} catch (Exception e) {
e.printStackTrace();
} finally {
RedissonLockUtil.unlock("RedissonLock");
System.out.println(Thread.currentThread().getName() + "释放锁");
}
}
}).start();
}
}
/**
* tryLock
* 1. 获取到锁后超过leaseTime会自动释放锁
* 2. 超过waitTime未获取到锁会返回false放弃获取锁
*/
@GetMapping("/testLock2")
public void testLock2() {
for (int i = 0; i < 5; i++) {
new Thread(new Runnable() {
@Override
public void run() {
try {
boolean result = RedissonLockUtil.tryLock("Lock:lock2", 3, 2, TimeUnit.SECONDS);
System.out.println(Thread.currentThread().getName() + "是否获取到锁" + result);
} catch (Exception e) {
e.printStackTrace();
} finally {
}
}
}).start();
}
}
/**
* 获取几次要释放几次，否则会阻塞
*/
@GetMapping("/testLock3")
public void testLock3() {
for (int i = 0; i < 5; i++) {
new Thread(new Runnable() {
@Override
public void run() {
try {
RedissonLockUtil.lock("RedissonLock");
RedissonLockUtil.lock("RedissonLock");
System.out.println(Thread.currentThread().getName() + "获取到锁");
} catch (Exception e) {
e.printStackTrace();
} finally {
RedissonLockUtil.unlock("RedissonLock");
// RedissonLockUtil.unlock("RedissonLock");
System.out.println(Thread.currentThread().getName() + "释放锁");
}
}
}).start();
}
}
}
测试结果
http://localhost:8080/testLock1 接口测试结果：
http://localhost:8080/testLock2 接口测试结果：
http://localhost:8080/testLock3 接口测试结果：
Redisson分布式锁原理
获取锁的过程就是向redis中插入指定的key；
释放锁的过程就是清除redis中已经插入的指定的key
如果获取锁的时候redis中已经存在相同的key说明有线程已经获取了锁，不能对资源进行操作；
如果获取锁的时候redis中不存在相同的key说明没有线程获取到锁，可以对资源进行操作；
如果对redisson的原理感兴趣，可以参考我写的另一篇文章
链接: https://blog.csdn.net/QiuHaoqian/article/details/114311189.