基于我们前面实现的优惠券的秒杀业务,我们接下来进行优化。
Redis优化秒杀
先回顾我们的业务流程
我们的秒杀过程中有很多个步骤都是去查询数据库,而我们知道,数据库的并发能力是比较弱的,我们该怎么做才能减少对数据库的并发压力呢?
我们可以把秒杀库存的判断、以及一人一单的校验放到redis中来做,这样可以快速的得到响应,并把得到的订单id返回给客户端,然后可以把扣减库存等操作放到阻塞队列里,使用异步线程等待阻塞队列的任务,这个异步线程可以慢慢处理。
那在redis中秒杀库存的判断、以及一人一单的校验怎么做呢?
基于Redis完成秒杀资格判断
新增秒杀优惠券的同时,将优惠券信息保存到Redis中
@Override
@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(RedisConstants.SECKILL_STOCK_KEY + 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.2 订单key
local orderKey = 'seckill:order:' .. voucherId
-- 3. 脚本业务
-- 3.1 判断库存是否充足 get stockKey
if(tonumber(redis.call('get', stockKey)) <= 0) then
-- 3.2 库存不足,返回1
return 1
end
-- 3.2 判断用户是否下单 SISMEMBER stockKey orderKey
if(redis.call('sismember', orderKey, userId) == 1) then
-- 3.3 存在,说明是重复下单,返回2
return 2
end
-- 3.4 扣库存 incrby stockKey -1
redis.call('incrby', stockKey, -1)
-- 3.5 下单(保存用户)sadd orderKey userId
redis.call('sadd', orderKey, userId)
return 0
@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);
}
@Override
public Result seckillVoucher(Long voucherId) {
// 获取用户
Long userId = UserHolder.getUser().getId();
// 1. 执行lua脚本
Long result = stringRedisTemplate.execute(
SECKILL_SCRIPT,
Collections.emptyList(),
voucherId.toString(),
userId.toString()
);
// 2. 判断结果是否为0
int r = result.intValue();
if(result != 0){
// 2.1 不为0, 代表没有购买资格
return Result.fail(r == 1 ? "库存不足": "不能重复下单");
}
// 2.2 为0, 有购买资格,把下单信息保存导阻塞队列
long orderId = redisIdWorker.nextId("order");
// TODo 保存阻塞队列
// 3.返回订单id
return Result.ok(orderId);
}
如果抢购成功,将优惠券id和用户id封装后存入阻塞队列
开启线程任务,不断从阻塞队列中获取信息,实现异步下单功能
@Slf4j
@Service
public class VoucherOrderServiceImpl extends ServiceImpl<VoucherOrderMapper, VoucherOrder> implements IVoucherOrderService {
@Autowired
private ISeckillVoucherService seckillVoucherService;
@Autowired
private RedisIdWorker redisIdWorker;
@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 BlockingQueue<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());
}
// 这个任务必须在这个类初始化之后就得执行,用spring提供的注解实现PostConstruct实现
private class VoucherOrderHandler implements Runnable{ // 线程任务,通过内部类来实现
@Override
public void run() { // 这里就不断的从阻塞队列里取,然后执行
while(true){
try{
// 1. 获取队列中的订单信息
VoucherOrder voucherOrder = orderTasks.take();
// 2. 创建订单
handlerVoucherOrder(voucherOrder);
}catch (Exception e){
log.error("处理订单异常",e);
}
}
}
}
private void handlerVoucherOrder(VoucherOrder voucherOrder) {
// 1.获取用户
Long userId = voucherOrder.getUserId();
// 2.创建锁对象
RLock lock = redissonClient.getLock("lock:oder:" + userId); // 使用Redisson获取锁
// 3.获取锁
boolean isLock = lock.tryLock();
// 4.判断是否获取锁成功
if(!isLock){
// 获取锁失败,返回错误信息或重试
log.error("不允许重复下单");
return;
}
try{
// 获取代理对象(事务)
proxy.createVoucherOrder(voucherOrder);
}finally{
// 释放锁
lock.unlock();
}
}
private IVoucherOrderService proxy;
@Override
public Result seckillVoucher(Long voucherId) {
// 获取用户
Long userId = UserHolder.getUser().getId();
// 1. 执行lua脚本
Long result = stringRedisTemplate.execute(
SECKILL_SCRIPT,
Collections.emptyList(),
voucherId.toString(),
userId.toString()
);
// 2. 判断结果是否为0
int r = result.intValue();
if(result != 0){
// 2.1 不为0, 代表没有购买资格
return Result.fail(r == 1 ? "库存不足": "不能重复下单");
}
// 2.2 为0, 有购买资格,把下单信息保存导阻塞队列
// 创建订单
VoucherOrder voucherOrder = new VoucherOrder();
// 2.3 订单id
long orderId = redisIdWorker.nextId("order");
voucherOrder.setId(orderId);
// 2.4 用户id
voucherOrder.setUserId(userId);
// 2.5 代金券id
voucherOrder.setVoucherId(voucherId);
// 2.6 放入阻塞队列
orderTasks.add(voucherOrder);
// 3. 获取代理对象
proxy = (IVoucherOrderService) AopContext.currentProxy();
// 3.返回订单id
return Result.ok(orderId);
}
/**
* 事务加在这,就失效了,为什么呢?
* 加载这是对createVoucherOrder函数加了事务,没有给seckillVoucher函数加事务,而seckillVoucher函数调用的时候
* createVoucherOrder(voucherId);
* 这样使用this调用的,这个this拿到的是当前的VoucherOrderServiceImpl对象
* 而不是VoucherOrderServiceImpl的代理对象
* 而事务要想生效,是spring对当前这个类做了动态代理,拿到代理对象做的事务处理
* 而我们当前的this是非代理对象,这就是事务失效的几种可能性之一
* 解决方法之一:
* AopContext.currentProxy()拿到代理对象来调用createVoucherOrder
*
* 当然这样解决还得做两件事:
* 1. 引入aspectj的依赖
* 2. 启动类添加注解@EnableAspectJAutoProxy(exposeProxy = true)暴露代理对象
*/
@Transactional
public void createVoucherOrder(VoucherOrder voucherOrder){
// 5. 一人一单
// Long userId = UserHolder.getUser().getId();
Long userId = voucherOrder.getUserId();
// 5.1 查询订单
Integer count = query().eq("user_id", userId).eq("voucher_id", voucherOrder.getVoucherId()).count();
// 5.2 判断是否存在
if(count > 0){
log.error("用户已经购买过一次!");
return;
}
// 6.扣减库存
boolean success = seckillVoucherService.update()
.setSql("stock = stock - 1")
.eq("voucher_id", voucherOrder.getVoucherId())
.gt("stock",0) // 把判断条件改成库存大于0就可以避免乐观锁的弊端
.update();
if(!success){
log.error("库存不足!");
return;
}
// 7.创建订单
save(voucherOrder);
}
}
至此,我们的秒杀优化的思路就初步实现了,其实就是把同步处理的业务,分两部分,然后异步执行
- 我们在jdk中搞了个阻塞队列,这个阻塞队列会不会引起Java虚拟机内存溢出呢?
- 我们基于内存保存这些订单信息,要是服务宕机了,订单信息丢了怎么办呢?
那且看下章