【Redis消息队列实现异步秒杀】--Redis学习笔记08
前言
秒杀业务的优化思路：
- 先利用Redis完成库存余量、一人一单判断，完成抢单业务
- 再将下单业务放入队列中（阻塞队列，消息队列），利用独立线程异步下单
基于阻塞队列的异步秒杀存在哪些问题？
- 内存限制问题
- 数据安全问题
一、基于阻塞队列实现异步秒杀
1.秒杀流程图
2.新增秒杀优惠券的同时，将优惠券信息保存到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);
stringRedisTemplate.opsForValue()
.set(RedisConstants.SECKILL_STOCK_KEY+voucher.getId(),voucher.getStock().toString());
}
3.基于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 判断库存是否充足
if (tonumber(redis.call('get',stockKey)) <=0) then
--- 3.2 库存不足
return 1
end
--- 3.2 判断用户是否已经下过单.如果存在就会返回1
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)
return 0
4.如果抢购成功，将优惠券id和用户id封装后存入阻塞队列
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
private IVoucherOrderService proxy;
//创建阻塞队列
private BlockingQueue<VoucherOrder> orderTask=new ArrayBlockingQueue<>(1024*1024);
public Result seckillVoucher(Long voucherId) {
// 1.获取用户
Long userId = UserHolder.getUser().getId();
// 2.执行Lua脚本
Long result = stringRedisTemplate.execute(SECKILL_SCRIPT,// 执行的Lua脚本
Collections.emptyList(),// 生成空集合
voucherId.toString(), userId.toString());// 脚本中需要获取的ARGV参数
// 3.判断结果不为0
if (result.intValue() !=0){
return Result.fail(1==result.intValue() ? "库存不足":"不能重复下单");
}
//4.为0，有购买资格，把下单信息保存到阻塞队列中
VoucherOrder voucherOrder = new VoucherOrder();
long orderId = redisIdworker.nextId("order");
voucherOrder.setId(orderId);
voucherOrder.setVoucherId(orderId);
voucherOrder.setUserId(userId);
voucherOrder.setVoucherId(voucherId);
orderTask.add(voucherOrder);
// 获取线程的代理对象
proxy=(IVoucherOrderService) AopContext.currentProxy();
return Result.ok(orderId);
}
5.开启线程任务，不断从阻塞队列中获取信息，实现异步下单功能
import java.util.concurrent.ExecutorService;
//创建线程池
private static final ExecutorService SECKILL_ORDER_EXECUTOR=Executors.newSingleThreadExecutor();
@PostConstruct // 当前类初始化完成开始执行
private void init(){
SECKILL_ORDER_EXECUTOR.submit(new VoucherOrderHandler());
}
private class VoucherOrderHandler implements Runnable{
@Override
public void run() {
while (true){
try {
// 获取队列中的订单信息orderTask.take()获取队列中的第一个元素，如果队列中没有元素，则一直等待。
VoucherOrder voucherOrder = orderTask.take();
//创建订单
handleVoucherOrder(voucherOrder);
} catch (Exception e) {
log.error("处理订单异常",e);
}
}
}
}
private void handleVoucherOrder(VoucherOrder voucherOrder) {
//1.获取用户
Long userId = voucherOrder.getUserId();
//2.创建锁对象
RLock lock = redissonClient.getLock("lock:order" + userId);
//3.获取锁
boolean isLock = lock.tryLock();
// 4.判断是否获取锁成功
if (!isLock){
log.error("不允许重复下单");
return;
}
try {
proxy.createVoucherOrder(voucherOrder);
} catch (Exception e) {
log.error("创建订单异常",e);
}
}
@Override
public void createVoucherOrder(VoucherOrder voucherOrder) {
// 1.查询用户
Long userId = voucherOrder.getUserId();
// 2 查询订单
int count = query().eq("user_id", userId).eq("voucher_id", voucherOrder.getVoucherId()).count();
// 3 判断订单是否存在
if (count > 0) {
log.error("用户已购买过一次!");
}
// 4.扣减库存
boolean success = seckillVoucherService.update()
.setSql("stock = stock - 1") // set stock=stock -1
.eq("voucher_id", voucherOrder.getVoucherId()).gt("stock", 0)//where id=? and stock > 0
.update();
if (!success){
log.error("库存不足");
return;
}
// 5.保存信息
save(voucherOrder);
}
二、基于Redis消息队列实现异步秒杀
1.基本概念
消息队列（Message Queue），字面意思就是存放消息的队列。最简单的消息队列模型包括3个角色：
消息队列：存储和管理消息，也被称为消息代理（Message Broker）
生产者：发送消息到消息队列
消费者：从消息队列获取消息并处理消息
Redis提供了三种不同的方式来实现消息队列：
list结构：基于List结构模拟消息队列
PubSub：基本的点对点消息模型
Stream：比较完善的消息队列模型
消息队列和阻塞队列的区别：
- 消息队列是在JVM以外的独立服务，不受JVM内存限制。
- 存进消息队列中的数据，会进行持久化，保证宕机时消息不会丢失，同时会有消费者确认机制，消费者未确认，则消息队列中数据依然存在，会继续让消费者消费，确保消息不会丢失。
因list结构和PubSub都无法解决消丢失的问题，本文主要使用Redis 5.0引入的Stream
2.修改之前的秒杀下单Lua脚本，在认定有抢购资格后，直接向stream.orders中添加消息，内容包含voucherId、userId、orderId
---1.参数列表
--- 1.1 优惠券id
local voucherId=ARGV[1];
--- 1.2 用户ID
local userId=ARGV[2];
--- 1.3 订单id
local orderId=ARGV[3];
--- 2数据key
--- 2.1库存key ..表示拼接
local stockKey ='seckill:stock:'.. voucherId
--- 2.2 订单key
local orderKey ='seckill:order:'.. voucherId
--- 3.业务脚本
--- 3.1 判断库存是否充足
if (tonumber(redis.call('get',stockKey)) <=0) then
--- 3.2 库存不足
return 1
end
--- 3.2 判断用户是否已经下过单.如果存在就会返回1
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)
--- 3.6发送消息到队列中 XADD stream.order * k1 v1 k2 v2 ...
redis.call('xadd','stream.orders','*','userId',userId,'voucherId',voucherId,'id',orderId)
return 0
3.项目启动时，开启一个线程任务，尝试获取stream.orders中的消息，完成下单
import cn.hutool.core.bean.BeanUtil;
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.UserHolder;
import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.aop.framework.AopContext;
import org.springframework.core.io.ClassPathResource;
import org.springframework.data.redis.connection.stream.*;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.time.Duration;
import java.time.LocalDateTime;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
@PostConstruct // 当前类初始化完成开始执行
private void init(){
SECKILL_ORDER_EXECUTOR.submit(new VoucherOrderHandler());
}
private class VoucherOrderHandler implements Runnable {
String queueName = "stream.orders";
@Override
public void run() {
while (true) {
try {
//1.从消息队列中获取订单信息 XREADGROUP GROUP g1 c1 COUNT 1 BLOCK 2000 STREAM STREAMS stream.order >
List<MapRecord<String, Object, Object>> list = stringRedisTemplate.opsForStream().read(
Consumer.from("g1", "c1"),
StreamReadOptions.empty().count(1).block(Duration.ofSeconds(2)),
StreamOffset.create(queueName, ReadOffset.lastConsumed())
);
// 2.判断消息获取是否成功
if (list == null || list.isEmpty()) {
//如果为空，则说明没有消息，则进行下一次循环
continue;
}
// 3.解析消息
MapRecord<String, Object, Object> entries = list.get(0);
Map<Object, Object> value = entries.getValue();
VoucherOrder voucherOrder = BeanUtil.fillBeanWithMap(value, new VoucherOrder(), true);
//创建订单
handleVoucherOrder(voucherOrder);
// ACK 确认
stringRedisTemplate.opsForStream().acknowledge(queueName, "g1", entries.getId());
} catch (Exception e) {
log.error("处理订单异常", e);
handlePendingList();
}
}
}
private void handlePendingList() {
while (true) {
try {
//1.从消息队列中获取订单信息 XREADGROUP GROUP g1 c1 COUNT 1 STREAM STREAMS stream.order 0
List<MapRecord<String, Object, Object>> list = stringRedisTemplate.opsForStream().read(
Consumer.from("g1", "c1"),
StreamReadOptions.empty().count(1),
StreamOffset.create(queueName, ReadOffset.from("0"))
);
// 2.判断消息获取是否成功
if (list == null || list.isEmpty()) {
//如果为空，则说明PendLing-list没有消息，则结束循环
break;
}
// 3.解析消息
MapRecord<String, Object, Object> entries = list.get(0);
Map<Object, Object> value = entries.getValue();
VoucherOrder voucherOrder = BeanUtil.fillBeanWithMap(value, new VoucherOrder(), true);
//创建订单
handleVoucherOrder(voucherOrder);
// ACK 确认
stringRedisTemplate.opsForStream().acknowledge(queueName, "g1", entries.getId());
} catch (Exception e) {
log.error("处理Pending-list订单异常", e);
try {
Thread.sleep(50);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
}
}
}
}