之前一人一单的业务使用的悲观锁，在分布式系统下，是无法生效的。
在最理想的情况下，如果一个线程可以成功地获取互斥锁并对订单进行查询和创建，则其他线程将无法干扰。它的原理是会有一个锁监视器，来监听是谁获得了锁。
但是问题就出现在：
分布式系统下，有多个不同的JVM，不同的JVM的环境下，锁监听器是有多个的，就会出现有的线程在别的线程已经拿到锁的情况下，仍然可以获取的到锁。
这个时候，普通的JVM中的锁就已经不管用了，就需要我们利用分布式锁 。
就是可以满足分布式系统或集群模式下多进程可见并且互斥的锁。
它的实现原理就是，不同的JVM环境，都来共用一个锁监视器。这样就不会导致出现多个线程用多把锁的情况了。
特点：
主要有三种实现方法，我们可以都来进行一个对比。
如下图：
这里主要讲基于Redis的分布式锁的实现 。
实现Reids分布式锁的方法主要就下面两个步骤：
1. 获取锁
使用Redis中String类型的setnx方法（保证互斥性）已经是大家熟知的获取锁的方式。为了防止redis服务器崩溃，我们需要为锁设置超时时间，以避免出现死锁。（非阻塞）
所以，获取锁的方式可以使用如下代码
SET lock thread1 nx ex 10
lock是锁的key，thread1 是value，nx就是setnx方法，ex就是设置超时时间
2. 释放锁
释放锁就简单了，删除即可。
del lock
代码实现：
需求：定义一个接口，利用Redis实现分布式锁的功能。
代码如下：
接口代码：
package com.hmdp.utils;
public interface ILock {
/**
* 尝试获取锁
* @param timeoutSec 锁的持有时间，过期自动释放
* @return true代表获取锁成功，false代表获取锁失败。
*/
boolean tryLock(long timeoutSec);
/**
* 释放锁
*/
void unlock();
}接口实现类：
package com.hmdp.utils;
import org.springframework.data.redis.core.StringRedisTemplate;
import java.util.concurrent.TimeUnit;
/**
* @Version 1.0
*/
public class SimpleRedisLock implements ILock {
//Redis
private StringRedisTemplate stringRedisTemplate;
//业务名称，也就是锁的名称
private String name;
public SimpleRedisLock(StringRedisTemplate stringRedisTemplate, String name) {
this.stringRedisTemplate = stringRedisTemplate;
this.name = name;
}
//key的前缀
private static final String KEY_PREFIX = "lock:";
@Override
public boolean tryLock(long timeoutSec) {
//获取线程id，当作set的value
long threadId = Thread.currentThread().getId();
Boolean success = stringRedisTemplate.opsForValue()
.setIfAbsent(KEY_PREFIX + name, threadId+"", timeoutSec, TimeUnit.SECONDS);
return Boolean.TRUE.equals(success);
}
//释放锁
@Override
public void unlock() {
//删除key
stringRedisTemplate.delete(KEY_PREFIX+name);
}
}业务层获取锁和释放锁（优惠券秒杀业务修改）
package com.hmdp.service.impl;
import com.hmdp.dto.Result;
import com.hmdp.entity.SeckillVoucher;
import com.hmdp.entity.VoucherOrder;
import com.hmdp.mapper.VoucherOrderMapper;
import com.hmdp.service.ISeckillVoucherService;
import com.hmdp.service.IVoucherOrderService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hmdp.utils.RedisIdWorker;
import com.hmdp.utils.SimpleRedisLock;
import com.hmdp.utils.UserHolder;
import org.springframework.aop.framework.AopContext;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.time.LocalDateTime;
/**
* <p>
* 服务实现类
* </p>
*
*/
@Service
public class VoucherOrderServiceImpl extends ServiceImpl<VoucherOrderMapper, VoucherOrder> implements IVoucherOrderService {
@Resource
private ISeckillVoucherService iSeckillVoucherService;
@Resource
private RedisIdWorker redisIdWorker;
@Resource
private StringRedisTemplate stringRedisTemplate;
@Override
public Result seckillVoucher(Long voucherId) {
//1.获取优惠券信息
SeckillVoucher voucher = iSeckillVoucherService.getById(voucherId);
//2.判断是否已经开始
if (voucher.getBeginTime().isAfter(LocalDateTime.now())){
Result.fail("秒杀尚未开始!");
}
//3.判断是否已经结束
if (voucher.getEndTime().isBefore(LocalDateTime.now())){
Result.fail("秒杀已经结束了!");
}
//4.判断库存是否充足
if (voucher.getStock() < 1) {
Result.fail("库存不充足!");
}
//5.扣减库存
boolean success = iSeckillVoucherService.update()
.setSql("stock = stock-1").eq("voucher_id",voucherId).gt("stock",0)
.update();
if (!success){
Result.fail("库存不充足!");
}
Long userId = UserHolder.getUser().getId();
//1.创建锁对象
SimpleRedisLock lock = new SimpleRedisLock(stringRedisTemplate, "order:" + userId);
//2.尝试获取锁
boolean isLock = lock.tryLock(1200);
if (!isLock){
//获取锁失败
return Result.fail("一个用户只能下一单！");
}
try {
IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
return proxy.createVoucherOrder(voucherId);
} finally {
//释放锁
lock.unlock();
}
}
@Transactional
public Result createVoucherOrder(Long voucherId) {
Long userId = UserHolder.getUser().getId();
//6.根据优惠券id和用户id判断订单是否已经存在
//如果存在，则返回错误信息
int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
if (count > 0) {
return Result.fail("用户已经购买！");
}
//7. 创建订单
VoucherOrder voucherOrder = new VoucherOrder();
//7.1添加订单id
Long orderId = redisIdWorker.nextId("order");
voucherOrder.setId(orderId);
//7.2添加用户id
voucherOrder.setUserId(userId);
//7.3添加优惠券id
voucherOrder.setVoucherId(voucherId);
save(voucherOrder);
//8.返回订单id
return Result.ok(orderId);
}
}以上是Redis分布式锁的原理是什么和怎么实现的详细内容。更多信息请关注PHP中文网其他相关文章！
