在分布式的情况下，我们没法使用本地的锁进行加锁从而实现并发同步，这个使用我们就需要使用到redis实现的分布式锁了
这里的话介绍的是redisson，也是官方推荐使用的
步骤
1、导入依赖
<!-- redisson-->
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson-spring-boot-starter</artifactId>
<version>3.15.5</version>
</dependency>
2、编写application.yml
spring:
redis:
host: 127.0.0.1
port: 6379
password:
# redisson配置文件路径
redisson:
file: classpath:redisson.yml
3、在resource下面创建redisson.yml
# 单节点配置
singleServerConfig:
# 连接空闲超时，单位：毫秒
idleConnectionTimeout: 10000
# 连接超时，单位：毫秒
connectTimeout: 10000
# 命令等待超时，单位：毫秒
timeout: 3000
# 命令失败重试次数,如果尝试达到 retryAttempts（命令失败重试次数） 仍然不能将命令发送至某个指定的节点时，将抛出错误。
# 如果尝试在此限制之内发送成功，则开始启用 timeout（命令等待超时） 计时。
retryAttempts: 3
# 命令重试发送时间间隔，单位：毫秒
retryInterval: 1500
# 密码
password:
# 单个连接最大订阅数量
subscriptionsPerConnection: 5
# 客户端名称
clientName: myredis
# 节点地址
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"
4、测试
方法一：test
1、编写测试类
package com.walker;
import org.apache.catalina.core.ApplicationContext;
import org.junit.jupiter.api.Test;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
public class RedissonTest {
//1、引入redisson客户端
@Autowired
private RedissonClient redissonClient;
private final static String LOCK="I_AM_LOCK";
@Test
public void test1() throws InterruptedException {
//获取锁
RLock lock = redissonClient.getLock(LOCK);
//执行多个线程去获取锁和释放锁
for (int i = 0; i < 5; i++) {
new Thread(()->{
lock.lock();
try {
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName()+"：\t 获得锁");
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
System.out.println(Thread.currentThread().getName()+"：\t 释放锁锁");
lock.unlock();
}
}).start();
}
Thread.sleep(100000);
}
}
2、测试
执行测试方法，之后发现每次只有一个线程可以获取锁和释放锁
方法二：controller
1、编写controller
编写两个方法，先执行get1方法 执行执行get2，尽量保证两个方法同时执行，会发现get1会先执行，然后由于get2获取不到锁，所以会等待一段时间之后才会执行
package com.walker.controller;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/redisson")
public class RedissonController {
//1、
@Autowired
private RedissonClient redissonClient;
private final static String LOCK="i_am_lock";
/**
*
*/
@GetMapping("/get1")
public String get1() throws InterruptedException {
//获取锁
RLock lock = redissonClient.getLock(LOCK);
//加锁
lock.lock();
System.out.println("get1 获取数据");
//让线程先休眠4s
Thread.sleep(4000);
//解锁
lock.unlock();
return "ok";
}
@GetMapping("/get2")
public String get2(){
long start = System.currentTimeMillis();
RLock lock = redissonClient.getLock(LOCK);
lock.lock();
long time = System.currentTimeMillis()-start;
//这里看看多久之后才能够获取锁，能够执行下面的语句
System.out.println("过了"+String.valueOf(time/1000)+"s获取锁");
System.out.println("get2 获取数据");
lock.unlock();
return "ok";
}
}
2、测试
这里get1获取锁之后输出数据，但是没有立即将锁释放
然后get2过了一段时间之后才能够拿到锁，这里的时间可能都不同，因为点击get2接口的时候有快有慢，就会导致时间不一致了，
但是都可能证明，必须要持有锁才能继续执行，否则就会进行等待
