黑马Redis实战项目——黑马点评笔记04 | 优惠券秒杀
1、redis应用场景一：全局唯一ID
问题：
1.1 生成策略
1.2 实践
@Component
public class RedisIdWorker {
/**
* 开始时间戳
*/
private static final long BEGIN_TIMESTAMP = 1672531200;
/**
* 序列号位数
*/
private static final int COUNT_BITS = 32;
@Resource
private StringRedisTemplate stringRedisTemplate;
/**
* ID自动生成器并返回
*
* @param keyPrefix 业务前缀
* @return
*/
public long nextId(String keyPrefix) {
//1 生成时间戳
LocalDateTime now = LocalDateTime.now();
long nowSecond = now.toEpochSecond(ZoneOffset.UTC);
long timeStamp = nowSecond - BEGIN_TIMESTAMP;
//2 生成序列号
//2.1 获取当前日期精确到天
String date = now.format(DateTimeFormatter.ofPattern("yyyy:MM:dd"));
//2.2 自增长
long count = stringRedisTemplate.opsForValue().increment("icr" + keyPrefix + ":" + date);
//3 拼接并返回
return timeStamp << COUNT_BITS | count;
}
public static void main(String[] args) {
LocalDateTime time = LocalDateTime.of(2023, 1, 1, 0, 0, 0);
long second = time.toEpochSecond(ZoneOffset.UTC);
System.out.println("second:" + second);
}
}
1.3 总结
2、优惠券秒杀下单
2.1 流程分析
使用postman添加秒杀券
//秒杀券信息
{
"shopId": 1,
"title": "100元代金券",
"subTitle": "周一到周日均可使用",
"rules": "全场通用\\n无需预约\\n可无限叠加\\不兑现、不找零\\n仅限堂食",
"payValue": 8000,
"actualValue": 10000,
"type": 1,
"stock": 100,
"beginTime":"2023-04-18T15:40:00",
"endTime":"2023-04-18T23:40:00"
}
2.2 代码实现
//VoucherOrderController类中
@PostMapping("seckill/{id}")
public Result seckillVoucher(@PathVariable("id") Long voucherId) {
return voucherOrderService.seckillVoucher(voucherId);
}
//IVoucherOrderService接口中声明方法
Result seckillVoucher(Long voucherId);
@Service
public class VoucherOrderServiceImpl extends ServiceImpl<VoucherOrderMapper, VoucherOrder> implements IVoucherOrderService {
@Resource
private ISeckillVoucherService seckillVoucherService;
@Resource
private RedisIdWorker redisIdWorker;
@Override
@Transactional
public Result seckillVoucher(Long voucherId) {
//1 查询优惠券
SeckillVoucher voucher = seckillVoucherService.getById(voucherId);
//2 判断秒杀是否开始
if (voucher.getBeginTime().isAfter(LocalDateTime.now())) {
//未开始
return Result.fail("秒杀尚未开始！");
}
//3 判断秒杀是否结束
if (voucher.getEndTime().isBefore(LocalDateTime.now())) {
//已结束
return Result.fail("秒杀已结束");
}
//4 判断库存是否充足
if(voucher.getStock()<1){
//库存不足
return Result.fail("库存不足!");
}
//5 扣减库存
boolean success = seckillVoucherService.update()
.setSql("stock = stock - 1")
.eq("voucher_id",voucherId).update();
if(!success){
//扣减失败
return Result.fail("库存不足!");
}
//6 创建订单
VoucherOrder voucherOrder = new VoucherOrder();
//6.1 订单id
long orderId = redisIdWorker.nextId("order");
voucherOrder.setId(orderId);
//6.2 用户id
voucherOrder.setUserId(UserHolder.getUser().getId());
//6.3 代金券id
voucherOrder.setVoucherId(voucherId);
save(voucherOrder);
//7 返回订单id
return Result.ok(orderId);
}
}
3、超卖问题
3.1 原因分析
3.2 解决方案选择：悲观锁or乐观锁
3.3 乐观锁实现
方案一：版本号法
方案二：CAS法
CAS法代码实现
在VoucherOrderServiceImpl类的seckillVoucher方法中修改操作数据库条件
//5 扣减库存
boolean success = seckillVoucherService.update()
.setSql("stock = stock - 1") //set stock=stock-1
.eq("voucher_id",voucherId).eq("stock",voucher.getStock()) //where id=? and stock=?
.update();
改进，提高成功率
//5 扣减库存
boolean success = seckillVoucherService.update()
.setSql("stock = stock - 1") //set stock=stock-1
.eq("voucher_id",voucherId).gt("stock",0) //where id=? and stock>0
.update();
3.4 线程安全总结
4、一人一单
4.1 实现流程
4.2 代码实现
这个实现过程比较复杂，包含spring事务失效、aop代理对象、synchronized锁等知识点，可以多看几遍。
@Service
public class VoucherOrderServiceImpl extends ServiceImpl<VoucherOrderMapper, VoucherOrder> implements IVoucherOrderService {
@Resource
private ISeckillVoucherService seckillVoucherService;
@Resource
private RedisIdWorker redisIdWorker;
@Override
public Result seckillVoucher(Long voucherId) {
//1 查询优惠券
SeckillVoucher voucher = seckillVoucherService.getById(voucherId);
//2 判断秒杀是否开始
if (voucher.getBeginTime().isAfter(LocalDateTime.now())) {
//未开始
return Result.fail("秒杀尚未开始！");
}
//3 判断秒杀是否结束
if (voucher.getEndTime().isBefore(LocalDateTime.now())) {
//已结束
return Result.fail("秒杀已结束");
}
//4 判断库存是否充足
if(voucher.getStock()<1){
//库存不足
return Result.fail("库存不足!");
}
//synchronized悲观锁,给用户加锁
//要在事务外层加锁，因为要在事务提交之后释放锁，才能确保线程安全
Long userId = UserHolder.getUser().getId();
synchronized(userId.toString().intern()){
//使用代理对象的createVouterOrder方法才能开启事务
//获取代理对象
IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
return proxy.createVouterOrder(voucherId);
}
}
@Transactional
public Result createVouterOrder(Long voucherId) {
//A 新增一人一单业务
Long userId = UserHolder.getUser().getId();
//A1 查询订单
int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
//A2 判断是否存在当前id订单
if(count>0){
//用户已购买过
return Result.fail("用户已购买过一次!");
}
//5 扣减库存
boolean success = seckillVoucherService.update()
.setSql("stock = stock - 1") //set stock=stock-1
.eq("voucher_id", voucherId).gt("stock",0) //where id=? and stock=?
.update();
if(!success){
//扣减失败
return Result.fail("库存不足!");
}
//6 创建订单
VoucherOrder voucherOrder = new VoucherOrder();
//6.1 订单id
long orderId = redisIdWorker.nextId("order");
voucherOrder.setId(orderId);
//6.2 用户id
voucherOrder.setUserId(userId);
//6.3 代金券id
voucherOrder.setVoucherId(voucherId);
save(voucherOrder);
//7 返回订单id
return Result.ok(orderId);
}
}
在接口中声明createVouterOrder方法
Result createVouterOrder(Long voucherId);
在获取代理对象防止事务失效时，要在pom文件中增加一个依赖
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
</dependency>
并在启动类HmDianPingApplication增加注解
@EnableAspectJAutoProxy(exposeProxy = true)
5、分布式锁
5.1 集群模式下的并发安全问题
集群中，有多个JVM存在，每个JVM内部都维护着各自的锁，因此仍然有若干个线程能获取到不同JVM中的锁，这就是集群导致的线程安全问题。因此需要让多个JVM共用一把锁。
5.2 分布式锁的工作原理
5.3 分布式锁方案对比
5.4 基于Redis的分布式锁（初级版本，不可重入）
5.4.1 流程
**Redis分布式锁原理：**基于setnx命令–>key存在的情况下，不更新value，而是返回nil
利用key是唯一的特性来加锁，比如一人一单业务，key名称精确到userId，那么同一个用户无论发多少次请求，能成功创建键值的只有一个，因为setnx命令，后面的请求在获取锁创建键值就会失败。
5.4.2 代码实现
锁接口
public interface ILock {
/**
* 尝试获取锁
* @param timeoutSec 锁持有的超时时间，过期后自动释放
* @return true表示获取锁成功 false表示获取失败
*/
boolean tryLock(long timeoutSec);
/**
* 释放锁
*/
void unLock();
}
锁实现：
public class SimpleRedisLock implements ILock {
private StringRedisTemplate stringRedisTemplate;
//锁名称（业务名）
private String name;
//锁前缀
private static final String KEY_PREFIX = "locks:";
public SimpleRedisLock(StringRedisTemplate stringRedisTemplate, String name) {
this.stringRedisTemplate = stringRedisTemplate;
this.name = name;
}
@Override
public boolean tryLock(long timeoutSec) {
// 获取线程标识
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() {
//释放锁
stringRedisTemplate.delete(KEY_PREFIX + name);
}
}
在抢券业务中使用锁实现一人一单：
VoucherOrderServiceImpl类的seckillVoucher方法修改：
@Override
public Result seckillVoucher(Long voucherId) {
//1 查询优惠券
SeckillVoucher voucher = seckillVoucherService.getById(voucherId);
//2 判断秒杀是否开始
if (voucher.getBeginTime().isAfter(LocalDateTime.now())) {
//未开始
return Result.fail("秒杀尚未开始！");
}
//3 判断秒杀是否结束
if (voucher.getEndTime().isBefore(LocalDateTime.now())) {
//已结束
return Result.fail("秒杀已结束");
}
//4 判断库存是否充足
if(voucher.getStock()<1){
//库存不足
return Result.fail("库存不足!");
}
//synchronized悲观锁,给用户加锁
//要在事务外层加锁，因为要在事务提交之后释放锁，才能确保线程安全
Long userId = UserHolder.getUser().getId();
// synchronized(userId.toString().intern()){
//创建所对象
SimpleRedisLock lock = new SimpleRedisLock(stringRedisTemplate, "order:" + userId);
//获取锁
boolean isLock = lock.tryLock(5);
//判断是否获取锁成功
if(!isLock){
//失败,返回错误信息
return Result.fail("不允许重复下单");
}
try {
//使用代理对象的createVouterOrder方法才能开启事务
//获取代理对象
IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
return proxy.createVouterOrder(voucherId);
} finally {
//释放锁
lock.unLock();
}
// }
}
5.4.3中 可能存在的问题
1、误删问题
把别的线程的锁删了。
解决方案： 获取锁时生成线程标识，在释放锁时判断线程标识是否是自己的，不一致可能是别人的锁，不释放。
修正：
public class SimpleRedisLock implements ILock {
private StringRedisTemplate stringRedisTemplate;
//锁名称（业务名）
private String name;
//锁前缀
private static final String KEY_PREFIX = "locks:";
private static final String ID_PREFIX = UUID.randomUUID().toString(true) + "-";
public SimpleRedisLock(StringRedisTemplate stringRedisTemplate, String name) {
this.stringRedisTemplate = stringRedisTemplate;
this.name = name;
}
@Override
public boolean tryLock(long timeoutSec) {
// 获取线程标识
String threadId = ID_PREFIX + Thread.currentThread().getId();
// 获取锁
Boolean success = stringRedisTemplate.opsForValue().setIfAbsent(KEY_PREFIX + name, threadId, timeoutSec, TimeUnit.SECONDS);
//自动拆箱会有空指针风险
return Boolean.TRUE.equals(success);
}
@Override
public void unLock() {
//获取线程标识
String threadId = ID_PREFIX + Thread.currentThread().getId();
//获取锁中的标识
String id = stringRedisTemplate.opsForValue().get(KEY_PREFIX + name);
//判断标识是否一致
if(threadId.equals(id)){
//释放锁
stringRedisTemplate.delete(KEY_PREFIX + name);
}
}
}
2、原子性问题
判断锁和释放锁之间产生阻塞导致问题，因此这两个操作要变成原子性操作。
Redis事务是批处理，不能实现先判断锁一致再删除。并且Redis事务只能保证原子性，不能保证一致性。因此，使用Redis的Lua脚本来实现判断锁和释放锁操作的原子性。
修正：
利用lua的原子性特征，将判断和删除锁绑定为原子性操作。
Lua脚本：（放在resources目录下）
-- 这里的 KEY[1] 这就是锁的key，这里的ARGV[1] 就是当前线程标示
-- 比较线程标示和锁中标示是否一致
if(redis.call('get', KEYS[1]) == ARGV[1]) then
-- 释放锁 del key
return redis.call('del',KEYS[1])
end
return 0
SimpleRedisLock类中unlock方法调用lua脚本
public class SimpleRedisLock implements ILock {
private StringRedisTemplate stringRedisTemplate;
//锁名称（业务名）
private String name;
//锁前缀
private static final String KEY_PREFIX = "locks:";
private static final String ID_PREFIX = UUID.randomUUID().toString(true) + "-";
private static final DefaultRedisScript<Long> UNLOCK_SCRIPT;
static {
//提前加载lua脚本
UNLOCK_SCRIPT = new DefaultRedisScript<>();
UNLOCK_SCRIPT.setLocation(new ClassPathResource("unlock.lua"));
UNLOCK_SCRIPT.setResultType(Long.class);
}
public SimpleRedisLock(StringRedisTemplate stringRedisTemplate, String name) {
this.stringRedisTemplate = stringRedisTemplate;
this.name = name;
}
@Override
public boolean tryLock(long timeoutSec) {
// 获取线程标识
String threadId = ID_PREFIX + Thread.currentThread().getId();
// 获取锁
Boolean success = stringRedisTemplate.opsForValue().setIfAbsent(KEY_PREFIX + name, threadId, timeoutSec, TimeUnit.SECONDS);
//自动拆箱会有空指针风险
return Boolean.TRUE.equals(success);
}
@Override
public void unLock() {
//调用lua脚本
stringRedisTemplate.execute(
UNLOCK_SCRIPT,
Collections.singletonList(KEY_PREFIX + name),
ID_PREFIX + Thread.currentThread().getId());
}
}
基于Redis的分布式锁（5.4, 5.5）总结
5.5 基于Redis的分布式锁优化（可重入）
5.5.1 Redisson入门
1、配置POM依赖
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson</artifactId>
<version>3.13.6</version>
</dependency>
2、配置Redisson
@Configuration
public class RedissonConfig {
@Bean
public RedissonClient redissonClient(){// RedissonClient是工厂类
//配置
Config config = new Config();
//添加redis地址，这里添加的单点地址，集群要使用config.useClusterServers()添加地址
config.useSingleServer().setAddress("redis://【虚拟机ip】:6379").setPassword("【redis密码】");
//创建Redisson对象
return Redisson.create(config);
}
}
3、使用Redisson分布式锁
// VoucherOrderServiceImpl类中注入RedissonClient对象
@Resource
private RedissonClient redissonClient;
// VoucherOrderServiceImpl类seckillVoucher方法中【创建锁，获取和释放锁语句修改】
// 创建锁对象
// SimpleRedisLock lock = new SimpleRedisLock(stringRedisTemplate, "order:" + userId);
// 获取锁
// boolean isLock = lock.tryLock(1200);
// 释放锁
// lock.unlock();
//创建锁对象（可重入）
RLock lock = redissonClient.getLock("lock:order:" + userId);
//尝试获取锁，参数是：获取锁的最大等待时间（默认不等待），锁自动释放时间，时间单位
boolean isLock = lock.tryLock();
//释放锁
lock.unlock();
5.5.2 Redisson分布式锁原理
1 Redisson可重入原理
利用 hash 结构，记录线程标示和重入次数。
原理
2 Redisson可重试原理
【利用信号量控制锁重试等待】：消息订阅+信号量机制，不是无休止重试，是有人释放锁之后再重试。
前14分钟
3 Redisson防止业务未完成时锁的超时释放
watchDog（看门狗）锁续约时间实现
14:00之后
5.6 Redisson解决主从一致原理
连锁策略：不再有主从节点，都获取成功才能获取锁成功，有一个节点获取锁不成功就获取锁失败。
如果多个主节点保证锁的话，一个主节点宕机了，其它线程只能获得一个新主节点的锁，获取不到其它两个锁，还会获取失败
这里主要是防止主节点宕机后，其它线程获得新主节点的锁，引起线程安全问题。
(5.4-5.6总结)
6、Redis优化秒杀（异步）
6.1 流程图
为避免所有操作都在数据库上执行，分离成两个线程：
- 一个线程判断用户的购买资格，发现用户有购买资格。（相当于收银台下单给小票）
- 再开启一个独立的线程来处理耗时较久的减库存、写订单的操作。（相当于后厨拿订单做菜）
可以将耗时较短的第一个线程操作放到 Redis 中，在 Redis 中处理对应的秒杀资格的判断。Redis 的性能是比 MySQL 要好的。此外，还需要引入【异步队列】记录相关的信息。
1、redis部分处理逻辑， Lua脚本封装操作保证原子性， redis这里选择的存储类型为set，因为key不能重复，而set恰好是无序不重复的
6.2 代码实现(基于阻塞队列的异步下单)
1.新增优惠券的业务时，把秒杀优惠券的库存信息保存到redis
// VoucherServiceImpl类中
//保存秒杀库存到redis
stringRedisTemplate.opsForValue().set(SECKILL_STOCK_KEY+voucher.getId(),voucher.getStock().toString());
2、编写lua脚本，按照下面的业务流程逻辑，在脚本中完成业务实现
-- 1.参数列表
-- 1.1 优惠券id
local voucherId = ARGV[1]
-- 1.2 用户id
local userId = ARGV[2]
-- 2.数据key
-- 2.1 库存key key 是优惠的业务名称加优惠券id value 是优惠券的库存数
local stockKey = 'seckill:stock:' .. voucherId
-- 2.2 订单key key 也是拼接的业务名称加优惠权id 而value是用户id， 这是一个set集合，凡购买该优惠券的用户都会将其id存入集合中
local orderKey = 'seckill:order:' .. voucherId
-- 3.脚本业务
-- 3.1 判断库存是否充足 get stockKey
if (tonumber(redis.call('get', stockKey)) <= 0) then --将get的value先转为数字类型才能判断比较
-- 3.2 库存不足，返回1
return 1
end
-- 3.3 判断用户是否下单 sismember orderKey userId命令，判断当前key集合中，是否存在该value；返回1存在，0不存在
if (redis.call('sismember', orderKey, userId) == 1) then
--3.4 存在说明是重复下单，返回2
return 2
end
-- 3.5 扣库存
redis.call('incrby', stockKey, -1)
-- 3.6 下单（保存用户）
redis.call('sadd', orderKey, userId)
return 0
3、VoucherOrderServiceImpl类中执行lua脚本，并判断，抢购成功的生成订单并存入阻塞队列
//注入脚本
private static final DefaultRedisScript<Long> SECKILL_SCRIPT;
static {
//提前加载lua脚本
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
if(result.intValue() != 0){
//2.1 不为0，没有购买资格
return Result.fail(result.intValue()==1?"库存不足":"不能重复下单");
}
//2.2 为0，有购买资格；把下单信息保存到阻塞队列
long orderId = redisIdWorker.nextId("order:");
//TODO: 保存阻塞队列
//3 返回订单id
return Result.ok(orderId);
}
4、如果抢购成功，将优惠券 id 和用户 id 封装后存入阻塞队列
4.1、创建BlockingQueue阻塞队列
BlockingQueue阻塞队列特点：当一个线程尝试从队列获取元素的时候，如果没有元素该线程阻塞，直到队列中有元素才会被唤醒并获取元素。
//阻塞队列
private BlockingQueue<VoucherOrder> orderTasks = new ArrayBlockingQueue<>(1024*1024);
4.2、将满足条件的请求，生成订单，并把订单对象add到阻塞队列中
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
if (result.intValue() != 0) {
//2.1 不为0，没有购买资格
return Result.fail(result.intValue() == 1 ? "库存不足" : "不能重复下单");
}
//2.2 为0，有购买资格；把下单信息保存到阻塞队列
//2.2.1 封装订单id，用户id，代金券id
VoucherOrder voucherOrder = new VoucherOrder();
long orderId = redisIdWorker.nextId("order");
voucherOrder.setId(orderId);
voucherOrder.setUserId(userId);
voucherOrder.setVoucherId(voucherId);
//2.2.2 放入阻塞队列
orderTasks.add(voucherOrder);
// 提前获取代理对象
proxy = (IVoucherOrderService) AopContext.currentProxy();
//3 返回订单id给客户端
return Result.ok(orderId);
}
5、开启线程任务，实现异步下单功能
5.1、首先创建一个线程池，再定义一个线程任务
【注意】线程任务需要在用户秒杀订单之前开始，用户一但开始秒杀，队列就会有新的订单，线程任务就应该立即取出订单信息，这里利用spring提供的注解，在类初始化完毕后立即执行线程任务。
//线程池
private static final ExecutorService SECKILL_ORDER_EXECUTOR = Executors.newSingleThreadExecutor();
@PostConstruct
private void init(){
SECKILL_ORDER_EXECUTOR.submit(new VoucherOrderHandler());
}
5.2、线程任务代码
//线程任务，内部类方式
private class VoucherOrderHandler implements Runnable{
@Override
public void run() {
while(true){
//1 获取队列中订单信息
try {
VoucherOrder voucherOrder = orderTasks.take();
//2 创建订单
handleVoucherOrder(voucherOrder);
} catch (Exception e) {
log.error("处理订单异常"+e);
}
}
}
}
private void handleVoucherOrder(VoucherOrder voucherOrder) {
//1 获取用户id
Long userId = voucherOrder.getUserId();
//2 创建锁对象
RLock lock = redissonClient.getLock("lock:order:" + userId);
//3 尝试获取锁，参数是：获取锁的最大等待时间（默认不等待），锁自动释放时间，时间单位
boolean isLock = lock.tryLock();
//判断是否获取锁成功
if(!isLock){
//失败,返回错误信息
log.error("不允许重复下单");
return;
}
try {
proxy.createVoucherOrder(voucherOrder);
} finally {
//释放锁
lock.unlock();
}
}
@Transactional
public void createVoucherOrder(VoucherOrder voucherOrder) {
//A 新增一人一单业务
Long userId = voucherOrder.getUserId();
//A1 查询订单
int count = query().eq("user_id", userId).eq("voucher_id", voucherOrder.getVoucherId()).count();
//A2 判断是否存在当前id订单
if(count>0){
//用户已购买过
log.error("用户已经购买一次！");
return;
}
//5 扣减库存
boolean success = seckillVoucherService.update()
.setSql("stock = stock - 1") //set stock=stock-1
.eq("voucher_id", voucherOrder.getVoucherId()).gt("stock",0) //where id=? and stock=?
.update();
if(!success){
//扣减失败
log.error("库存不足!");
return;
}
//创建订单
save(voucherOrder);
}
6.3优化思路总结
7、Redis消息队列实现异步秒杀
由于前面的阻塞队列是基于JVM的内存实现，那么不可避免的两个大问题
①高并发海量访问，创建订单，队列很快就超出上限，造成内存溢出；
②JVM内存没有持久化机制，若服务出现重启或宕机，阻塞队列中的所有任务都会丢失。
MQ（消息队列）优点： MQ是JVM以外的服务，不受JVM内存限制，且MQ中的所有消息会做持久化，这样即使重启或宕机，数据不会丢失。消息投递给消费者后需要消费者确认，未确认消息会一直存在下一次继续投递，确保消息至少被消费一次。
P69使用测试类创建Jmeter压力测试用的tokens.txt文件，并将所有用户存到redis。
package com.hmdp;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.bean.copier.CopyOptions;
import cn.hutool.core.lang.UUID;
import com.hmdp.dto.UserDTO;
import com.hmdp.entity.User;
import com.hmdp.service.IUserService;
import lombok.SneakyThrows;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.StringRedisTemplate;
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static com.hmdp.utils.RedisConstants.LOGIN_USER_KEY;
/**
* @author xsy
* @version 1.0
*/
// P69创建 tokens.txt文件
@SpringBootTest
@AutoConfigureMockMvc
public class VoucherOrderControllerTest {
@Autowired
private IUserService userService;
@Autowired
private StringRedisTemplate stringRedisTemplate;
@SneakyThrows
@Test
void getTokens(){
FileOutputStream outputStream = new FileOutputStream(new File("D:\\JavaCode\\redis\\hm-dianping\\tokens.txt"));//tokens.txt文件存储路径
List<User> userList = userService.query().list();
userList.forEach(user -> {
String token = UUID.randomUUID().toString(true);
UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class);
Map<String, Object> userMap = BeanUtil.beanToMap(userDTO, new HashMap<>(),
new CopyOptions().
ignoreNullValue().
setFieldValueEditor((keyType, valueType) -> valueType.toString()));
String key = LOGIN_USER_KEY + token;
stringRedisTemplate.opsForHash().putAll(key, userMap);
try {
outputStream.write(token.getBytes(StandardCharsets.UTF_8));
outputStream.write("\n".getBytes(StandardCharsets.UTF_8));
outputStream.flush();
} catch (IOException e) {
throw new RuntimeException(e);
}
});
}
}
7.1 基于List结构模拟消息队列
7.2 PubSub（发布订阅）基本的点对点消息模型
7.3 Stream 比较完善的消息队列模型
7.3.1 单消费者模式
7.3.2 消费者组模式
7.4三种Redis消息队列总结
7.5 代码实现基于stream消息队列的异步秒杀
7.5.1、redis客户端创建消息队列
XGROUP CREATE stream.orders g1 0 MKSTREAM
7.5.2、修改Lua脚本
-- 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 key 是优惠的业务名称加优惠券id value 是优惠券的库存数
local stockKey = 'seckill:stock:' .. voucherId
-- 2.2 订单key key 也是拼接的业务名称加优惠权id 而value是用户id， 这是一个set集合，凡购买该优惠券的用户都会将其id存入集合中
local orderKey = 'seckill:order:' .. voucherId
-- 3.脚本业务
-- 3.1 判断库存是否充足 get stockKey
if (tonumber(redis.call('get', stockKey)) <= 0) then --将get的value先转为数字类型才能判断比较
-- 3.2 库存不足，返回1
return 1
end
-- 3.3 判断用户是否下单 sismember orderKey userId命令，判断当前key集合中，是否存在该value；返回1存在，0不存在
if (redis.call('sismember', orderKey, userId) == 1) then
--3.4 存在说明是重复下单，返回2
return 2
end
-- 3.5 扣库存
redis.call('incrby', stockKey, -1)
-- 3.6 下单（保存用户）
redis.call('sadd', orderKey, userId)
-- 3.7 发送消息到队列中：XADD stream.orders * k1 v1 k2 v2 ...
redis.call('xadd', 'stream.orders', '*', 'userId', userId, 'voucherId', voucherId, 'id', orderId)
return 0
7.5.3、修改对应java脚本
public Result seckillVoucher(Long voucherId) {
//获取用户
Long userId = UserHolder.getUser().getId();
//获取订单ID
long orderId = redisIdWorker.nextId("order");
//1 执行lua脚本
Long result = stringRedisTemplate.execute(
SECKILL_SCRIPT,
Collections.emptyList(),
voucherId.toString(), userId.toString(),String.valueOf(orderId)
);
//2 判断结果是否为0
if (result.intValue() != 0) {
//2.1 不为0，没有购买资格
return Result.fail(result.intValue() == 1 ? "库存不足" : "不能重复下单");
}
// 提前获取代理对象
proxy = (IVoucherOrderService) AopContext.currentProxy();
//3 返回订单id给客户端
return Result.ok(orderId);
}
7.5.4、修改线程对象
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 streams.orders >
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()){
//2.1 如果获取失败，说明没有消息，继续下一次循环
continue;
}
// 解析消息中的订单信息
MapRecord<String, Object, Object> record = list.get(0);
Map<Object, Object> value = record.getValue();
VoucherOrder voucherOrder = BeanUtil.fillBeanWithMap(value, new VoucherOrder(), true);
//2.2 如果获取成功，可以下单创建订单
System.out.println("2-handleVoucherOrder(voucherOrder)");
handleVoucherOrder(voucherOrder);
//3 ACK确认 SACK stream.orders g1 id
stringRedisTemplate.opsForStream().acknowledge(queueName,"g1",record.getId());
} catch (Exception e) {
handlePendingList();
log.error("处理订单异常"+e);
}
}
}
private void handlePendingList(){
while(true){
try {
//1 获取消息队列中订单信息 XREADGROUP GROUP g1 c1 COUNT 1 streams.orders 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()){
//2.1 如果获取失败，说明pending-list没有消息，结束循环
break;
}
// 解析消息中的订单信息
MapRecord<String, Object, Object> record = list.get(0);
Map<Object, Object> value = record.getValue();
VoucherOrder voucherOrder = BeanUtil.fillBeanWithMap(value, new VoucherOrder(), true);
//2.2 如果获取成功，可以下单创建订单
System.out.println("1-handleVoucherOrder(voucherOrder)");
handleVoucherOrder(voucherOrder);
//3 ACK确认 SACK stream.orders g1 id
stringRedisTemplate.opsForStream().acknowledge(queueName,"g1",record.getId());
} catch (Exception e) {
log.error("处理pending-list订单异常"+e);
try {
Thread.sleep(20);
} catch (InterruptedException ex) {
throw new RuntimeException(ex);
}
}
}
}
}
8、【总结】Redis在秒杀业务中的应用
- 缓存
- 分布式锁
- 超卖问题
- Lua脚本
- Redis消息队列
1106
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
