概述
Redisson入门
第一步：引入依赖
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson</artifactId>
<version>3.13.6</version>
</dependency>第二步：配置文件
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class RedissonConfig {
@Bean
public RedissonClient redissonClient(){
//配置
Config config = new Config();
config.useSingleServer().setAddress("redis://192.168.136.132:6379").setPassword("pz030812...");
//创建RedissonClient对象
return Redisson.create(config);
}
}
第三步：使用锁
Long id = UserHolder.getUser().getId();
//创建锁对象
RLock lock = redissonClient.getLock("lock:order" + id);
//获取锁
boolean trylock = lock.tryLock();
//判断是否获得锁成功
if (!trylock) {
//获取锁失败
return Result.fail("不允许重复下单！");
}
try {
//获得锁进行操作
//获得Spring的代理对象(事务)
IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
return proxy.createVoucherOrder(voucherId);
} finally {
//释放锁
lock.unlock();
}
Redisson锁可重入原理
就是在Lock中利用hash数据加一个标识字段，标识有几个自己线程中获得锁的数量，每次获取锁的流程：①判断锁是否存在，如果不存在则说明没人用锁，则获取到锁，并且设置好标识以及线程名②如果存在则判断是不是自己线程中的锁③如果不是，就说明是别人的锁，则获取失败返回错误④如果判断是自己线程的锁，则把标识字段+1，并且获得锁⑤之后只要是自己线程中的人来获取锁就直接更改标识。
而释放锁的流程：①先判断这个锁是不是自己线程的②如果不是就说明锁已经被释放了③如果是的话，就把标识减1④再去看标识是否已经等于0，即到了最外层⑤如果是的话就直接释放锁⑥不是的话就重置锁的有限期，继续执行业务
Redisson锁可重试，超时释放(看门狗)原理
Redisson锁主从一致性
multiLock原理：
异步实现秒杀商品
执行流程：将判断资格和写进数据库分离开来，使得并发能力大大增强
代码执行：
①在添加秒杀商品的同时，将数据写进Redis当中
@Transactional
public void addSeckillVoucher(Voucher voucher) {
// 保存优惠券
save(voucher);
// 保存秒杀信息
SeckillVoucher seckillVoucher = new SeckillVoucher();
seckillVoucher.setVoucherId(voucher.getId());
seckillVoucher.setStock(voucher.getStock());
seckillVoucher.setBeginTime(voucher.getBeginTime());
seckillVoucher.setEndTime(voucher.getEndTime());
seckillVoucherService.save(seckillVoucher);
//保存秒杀劵到Redis中
stringRedisTemplate.opsForValue().set("seckill:stock"+voucher.getId(),voucher.getStock().toString());
}②编写Lua脚本，实现资格判断
--1.参数列表
--1.1。优惠券id
local voucherId = ARGV[1]
--1.2.用户id
local userId = ARGV[2]
--2.数据key
--2.1 库存key
local stockKey = 'seckill:stock' .. voucherId
--2.1 订单id
local orderKey = 'seckill:order' .. voucherId
--3.脚本业务
--3.1,判断库存是否充足 get stockKey
if(tonumber(redis.call('get',stockKey)) <= 0) then
return 1
end
--3.2 判断用户是否下单 SISMEMBER orderKey userID
if(redis.call('sismember',orderKey,userId) == 1) then
--3.3 存在，说明是重复下单，返回2
return 2
end
--3.4 扣库存
redis.call('incrby',stockKey,-1)
--3.5 下单
redis.call('sadd',orderKey,userId)
③编码
@Service
public class VoucherOrderServiceImpl extends ServiceImpl<VoucherOrderMapper, VoucherOrder> implements IVoucherOrderService {
@Autowired
private ISeckillVoucherService iSeckillVoucherService;
@Autowired
private RedisUUID redisUUID;
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Autowired
private RedissonClient redissonClient;
private static final DefaultRedisScript<Long> SECKILL_SCRIPT;
static {
SECKILL_SCRIPT = new DefaultRedisScript<>();
SECKILL_SCRIPT.setLocation(new ClassPathResource("seckill.lua"));
SECKILL_SCRIPT.setResultType(Long.class);
}
//创建阻塞队列
private BlockingDeque<VoucherOrder> orderTasks = new ArrayBlockingQueue<>(1024 * 1024);
//创建线程池
private static final ExecutorService SECKILL_ORDER_EXECUTOR = Executors.newSingleThreadExecutor();
@PostConstruct
private void init(){
SECKILL_ORDER_EXECUTOR.submit(new VoucherOrderHandler());
}
private class VoucherOrderHandler implements Runnable{
public void run(){
while (true){
try {
//1,获取队列中的订单信息
VoucherOrder voucherOrder = orderTasks.take();
//2.创建订单
handleVoucherOrder(voucherOrder);
} catch (InterruptedException e) {
log.error("处理订单异常！",e);
}
}
}
}
private void handleVoucherOrder(VoucherOrder voucherOrder) {
Long userId = voucherOrder.getUserId();
//创建锁对象
RLock lock = redissonClient.getLock("lock:order" + userId);
//获取锁
boolean trylock = lock.tryLock();
//判断是否获得锁成功
if (!trylock) {
//获取锁失败
return;
}
try {
proxy.createVoucherOrder(voucherOrder);
} finally {
//释放锁
lock.unlock();
}
}
private IVoucherOrderService proxy;
@Override
public Result seckillVoucher(Long voucherId) {
Long id = UserHolder.getUser().getId();
//1.执行Lua脚本
Long result = stringRedisTemplate.execute(
SECKILL_SCRIPT,
Collections.emptyList(),
voucherId.toString(),
id.toString()
);
//2.判断结果为0
int r = result.intValue();
if (r != 0){
//2.1 不为0，代表没有购买资格
return Result.fail(r == 1 ? "库存不足" : "不能重复下单");
}
//2.2 为0，有购买资格，把下单信息保存到阻塞队列
VoucherOrder voucherOrder = new VoucherOrder();
//2.3，订单id----id生成器
long order = redisUUID.nextid("order");
voucherOrder.setVoucherId(order);
//2.4，用户id
voucherOrder.setUserId(id);
//2.5，商品id
voucherOrder.setVoucherId(voucherId);
//2.6，放入阻塞队列
orderTasks.add(voucherOrder);
//获取代理对象
proxy = (IVoucherOrderService) AopContext.currentProxy();
//3.返回订单id
return Result.ok(order);
}
@Transactional
public void createVoucherOrder(VoucherOrder voucherOrder) {
//一人一单问题
Long id = voucherOrder.getUserId();
Integer count = query().eq("user_id", id).eq("voucher_id", voucherOrder.getVoucherId()).count();
if(count > 0){
return;
}
//4，如果有就减扣库存
boolean sucess = iSeckillVoucherService.update()
.setSql("stock = stock - 1")
.eq("voucher_id", voucherOrder.getVoucherId())
.gt("stock",0)
.update();
if (!sucess) {
return;
}
//6，保存进数据库
save(voucherOrder);
}
}
