使用Redisson实现分布式锁
一、什么是分布式？
要想说什么是分布式，那么首先要知道分布式之前的系统是什么样的架构，之前的架构又存在什么样的问题？
单体架构
分布式之前就是单体架构，单体架构顾名思义就是将所有的业务功能打包在一个应用中，然后部署在服务器上。如果我们把单体架构比作一个汽车工厂，那么从汽车发动机到汽车上的一个螺丝钉都需要由它来负责完成，如果有一天这家工厂由于自然灾害的原因导致业务量急剧下滑，甚至停止生产，那么这个整个工厂无论是造发动机的，还是造螺丝钉的全部都得停工。落实到互联网就是单体架构开发成本高、出现故障影响的范围大，很难适应现在的互联网项目。
分布式
既然单体架构不足以解决现在存在的高并发、高性能、高可用的要求，那么分布式就来了，原来我们把一个汽车所有的零件都放在一家工厂进行生产，结果会出现上面停工的情况，那么分布式怎么解决的？所谓分布式就是把所有的零件分开生产，每个工厂根据自己的特长来生产相应的汽车配件，最后统一组装，即使因为一些其他原因，导致某个工厂停止了生产，但是依旧不影响其他工厂的生产进度，我们可以通过小的代价来寻找其他工厂来代替停工的工厂，确保我们的生产任务可以正常的运转。
二、为什么要有分布式锁？
如果没有分布式锁
解释这个问题之前，我们先来说下，如果没有分布式锁会存在什么问题，举个经典的例子，如果我们有一个购物网站，有一件商品只有10件可卖，此时用户A进来后还有1个库存，然后用户A下单付款，扣减库存，在用户A付款的这个过程中，恰好用户B进来了，也看到还有一个库存，用户B也开始下单付款，扣减库存，那么这个过程很明显已经出了问题，出现了超卖的问题。
分布式锁
如果有了分布式锁就不会出现超卖问题，举个简单的例子，分布式就像是银行的ATM，你去ATM取钱，如果你去了恰巧里面有人，那么你肯定是进不去的，必须等里面的人出来之后你才能进去，同样的，如果你正在取钱，如果外面还有人等着取钱，那么无论如何他都必须等你取完出来，他才能进去，要么他不取了回家去。
三、Redis实现的分布式锁
简单的介绍了分布式和分布式锁，之后我们现在来看看如何实现一个分布式锁，先看我之前使用Redis写个一个分布式锁，看看有什么问题？
public Boolean lock(String key, Long waitTime, Long expireTime) {
String value = UUID.randomUUID().toString().replaceAll("-", "").toLowerCase();
Boolean flag = setNx(key, value, expireTime, TimeUnit.SECONDS);
// 尝试获取锁 成功返回
if (flag) {
return flag;
} else {
// 获取失败
// 现在时间
long newTime = System.currentTimeMillis();
// 等待过期时间
long loseTime = newTime + waitTime;
// 不断尝试获取锁成功返回 11 < 11
while (System.currentTimeMillis() < loseTime) {
Boolean testFlag = setNx(key, value, expireTime, TimeUnit.MILLISECONDS);
if (testFlag) {
return testFlag;
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
}
}
}
return false;
}
四、Redisson分布式锁
1、首先引入maven
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson-spring-boot-starter</artifactId>
<version>3.10.6</version>
</dependency>
2、构建Redisson实例（基于SpringBoot）
配置redis信息
spring:
application:
name: spring-cloud-product
redis:
port: 6379
host: 127.0.0.1
password:
database: 0
timeout: 2000
配置redisson
新建一个redisson-single.yml的配置文件 下面是单机配置
singleServerConfig:
idleConnectionTimeout: 10000
pingTimeout: 1000
connectTimeout: 10000
timeout: 3000
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的检查操作会直接报错 所以我直接注释掉了
#dnsMonitoring: false
dnsMonitoringInterval: 5000
threads: 0
nettyThreads: 0
codec: !<org.redisson.codec.JsonJacksonCodec> {
}
transportMode : "NIO"
RedissonConfig配置类 来配置你的redisson
@Configuration
public class RedssonConfig {
@Bean(destroyMethod="shutdown")
public RedissonClient redisson() throws IOException {
RedissonClient redisson = Redisson.create(Config.fromYAML(new ClassPathResource("redisson-single.yml").getInputStream()));
return redisson;
}
}
3、使用
其实单从使用来说是非常简单的，这里需要跟大家说一点，就是lock()这个方法，我们先看源码，这个方法是可以设置过期时间的，但是它并不会去进行检查任务是否执行结束，如果任务没有执行结束，然后锁的过期时间到了，线程中断，就会出现异常。
public void lock(long leaseTime, TimeUnit unit) {
try {
this.lock(leaseTime, unit, false);
} catch (InterruptedException var5) {
throw new IllegalStateException();
}
}
异常信息
4、较为完善的方法，lock()
这个方法不需要传递任何参数，它的底层方法会通过我们刚才说的原理，去校验当前任务是否执行结束，如果没有执行结束，那么相应的就会延长锁的过期时间。
底层实现
private void lock(long leaseTime, TimeUnit unit, boolean interruptibly) throws InterruptedException {
long threadId = Thread.currentThread().getId();
Long ttl = this.tryAcquire(leaseTime, unit, threadId);
if (ttl != null) {
RFuture<RedissonLockEntry> future = this.subscribe(threadId);
this.commandExecutor.syncSubscription(future);
try {
// 校验任务是否执行结束
while(true) {
ttl = this.tryAcquire(leaseTime, unit, threadId);
if (ttl == null) {
return;
}
if (ttl >= 0L) {
try {
this.getEntry(threadId).getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS);
} catch (InterruptedException var13) {
if (interruptibly) {
throw var13;
}
this.getEntry(threadId).getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS);
}
} else if (interruptibly) {
this.getEntry(threadId).getLatch().acquire();
} else {
this.getEntry(threadId).getLatch().acquireUninterruptibly();
}
}
} finally {
this.unsubscribe(future, threadId);
}
}
}
五、秒杀案例
编写一个秒杀接口
@Autowired
private RedissonClient redissonClient;
@Override
public boolean decrementProductStore(Long productId, Integer productQuantity) {
String key = "dec_store_lock_" + productId;
RLock lock = redissonClient.getLock(key);
try {
//加锁 操作很类似Java的ReentrantLock机制
lock.lock();
ProductInfo productInfo = productInfoMapper.selectByPrimaryKey(productId);
//如果库存为空
if (productInfo.getProductStock() == 0) {
return false;
}
//简单减库存操作 没有重新写其他接口了
productInfo.setProductStock(productInfo.getProductStock() - 1);
productInfoMapper.updateByPrimaryKey(productInfo);
} catch (Exception e) {
System.out.println(e.getMessage());
} finally {
//解锁
lock.unlock();
}
return true;
}
写一个简单的测试请求
@GetMapping("test")
public String createOrderTest() {
if (!productInfoService.decrementProductStore(1L, 1)) {
return "库存不足";
}
OrderMaster orderMaster = new OrderMaster();
//未支付
orderMaster.setOrderStatus(0);
//未支付
orderMaster.setPayStatus(0);
orderMaster.setBuyerName(name);
orderMaster.setBuyerAddress("湖南长沙");
orderMaster.setBuyerPhone("18692794847");
orderMaster.setOrderAmount(BigDecimal.ZERO);
orderMaster.setCreateTime(DateUtils.getCurrentDate());
orderMaster.setOrderId(UUID.randomUUID().toString().replaceAll("-", ""));
orderMasterService.insert(orderMaster);
return "创建订单成功";
}
RedissonLocker的具体实现类
public class RedissonLockerImpl implements RedissonLocker {
@Autowired
private RedissonClient redissonClient;
/**************************可重入锁**************************/
/**
* 拿不到lock就不罢休，不然线程就一直block
* 没有超时时间,默认30s
*
* @param lockKey
* @return
*/
@Override
public RLock lock(String lockKey) {
RLock lock = redissonClient.getLock(lockKey);
lock.lock();
return lock;
}
/**
* 自己设置超时时间
*
* @param lockKey 锁的key
* @param timeout 秒 如果是-1，直到自己解锁，否则不会自动解锁
* @return
*/
@Override
public RLock lock(String lockKey, int timeout) {
RLock lock = redissonClient.getLock(lockKey);
lock.lock(timeout, TimeUnit.SECONDS);
return lock;
}
/**
* 自己设置超时时间
*
* @param lockKey 锁的key
* @param unit 锁时间单位
* @param timeout 超时时间
*
*/
@Override
public RLock lock(String lockKey, TimeUnit unit, int timeout) {
RLock lock = redissonClient.getLock(lockKey);
lock.lock(timeout, unit);
return lock;
}
/**
* 尝试加锁，最多等待waitTime，上锁以后leaseTime自动解锁
* @param lockKey 锁key
* @param unit 锁时间单位
* @param waitTime 等到最大时间，强制获取锁
* @param leaseTime 锁失效时间
* @return 如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false
*/
@Override
public boolean tryLock(String lockKey, TimeUnit unit, int waitTime, int leaseTime) {
RLock lock = redissonClient.getLock(lockKey);
try {
return lock.tryLock(waitTime, leaseTime, unit);
} catch (InterruptedException e) {
e.printStackTrace();
}
return false;
}
/**************************公平锁**************************/
/**
* 尝试加锁，最多等待waitTime，上锁以后leaseTime自动解锁
* @param lockKey 锁key
* @param unit 锁时间单位
* @param waitTime 等到最大时间，强制获取锁
* @param leaseTime 锁失效时间
* @return 如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false
*/
public boolean fairLock(String lockKey, TimeUnit unit, int waitTime, int leaseTime) {
RLock fairLock = redissonClient.getFairLock(lockKey);
try {
return fairLock.tryLock(waitTime, leaseTime, unit);
} catch (InterruptedException e) {
e.printStackTrace();
}
return false;
}
/**
* 释放锁
* @param lockKey 锁key
*/
@Override
public void unlock(String lockKey) {
RLock lock = redissonClient.getLock(lockKey);
lock.unlock();
}
/**
* 释放锁
*/
@Override
public void unlock(RLock lock) {
lock.unlock();
}
}
业务代码中使用
String lockKey = userId;
// 公平加锁，60秒后锁自动释放
boolean isLocked = false;
try {
isLocked = redissonLocker.fairLock(lockKey , TimeUnit.SECONDS, 3, 60);
if (isLocked) {
// 如果成功获取到锁就继续执行
// 执行业务代码操作
return GlobalResponse.success();
} else {
// 未获取到锁
return GlobalResponse.fail(500, "请勿重复点击！！");
}
} catch (Exception e) {
return GlobalResponse.fail(500, e.getMessage());
} finally {
if (isLocked) {
// 如果锁还存在，在方法执行完成后，释放锁
redissonLocker.unlock(lockKey);
}
}