Redis---------实现商品秒杀业务,包括唯一ID,超卖问题,分布式锁

本文主要是介绍Redis---------实现商品秒杀业务,包括唯一ID,超卖问题,分布式锁,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

 订单ID必须是唯一

59e1602b09834e0aadaa9602bbc8a20f.png

 唯一ID构成:

e0304f55e1f348838355b3126378a22d.png

代码生成唯一ID:


import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.time.format.DateTimeFormatter;//基于redis自增长的生成策略
@Component
public class RedisUUID {//起始时间时间秒数private static final long BEGIN_TIMESTAMP=1640995200L;//使用Redis自增策略private StringRedisTemplate stringRedisTemplate;public RedisUUID(StringRedisTemplate stringRedisTemplate) {this.stringRedisTemplate = stringRedisTemplate;}//参数是业务的类型public long nextid(String keyType){//1,生成时间戳LocalDateTime now = LocalDateTime.now();long nowsecend = now.toEpochSecond(ZoneOffset.UTC);//当前时间的秒数减去起始时间的秒数得到时间戳long nowtime_stamp = nowsecend - BEGIN_TIMESTAMP;//2,生成序列号String nowdate = now.format(DateTimeFormatter.ofPattern("yyyy:mm:dd"));//使得每天都会生成新的一轮IDlong count = stringRedisTemplate.opsForValue().increment("icr:" + keyType + ":" + nowdate);//3,拼接返回return nowtime_stamp << 32 | count;}
}

827128d84da44b4793c030401783ed74.png

 

商品下单操作

业务逻辑:

7700ca73332d48708595361f1ae99dc3.jpg

 思路:主要是要了解以及掌握整个业务的流程:①先看商品是不是在秒杀的时间范围内②然后还要去看库存中是否还有该商品③如果有的话就扣减库存④然后就会生成订单,订单ID为唯一ID⑤把订单写入数据库中,再返回数据给前端

代码实现:

@Service
public class VoucherOrderServiceImpl extends ServiceImpl<VoucherOrderMapper, VoucherOrder> implements IVoucherOrderService {@Autowiredprivate ISeckillVoucherService iSeckillVoucherService;@Autowiredprivate RedisUUID redisUUID;@Override@Transactionalpublic Result seckillVoucher(Long voucherId) {//1,查询商品的信息SeckillVoucher voucher = iSeckillVoucherService.getById(voucherId);//2,看是否在秒杀时间范围内if (voucher.getBeginTime().isAfter(LocalDateTime.now())) {return Result.fail("尚未开始!");}if (voucher.getEndTime().isBefore(LocalDateTime.now())) {return Result.fail("已经结束啦!");}//3,再看库存是否还有if (voucher.getStock()<1) {return Result.fail("库存不足!");}//4,如果有就减扣库存boolean sucess = iSeckillVoucherService.update().setSql("stock = stock - 1").eq("voucher_id", voucherId).update();if (!sucess) {return Result.fail("库存不足!");}//5,然后就创建订单信息VoucherOrder voucherOrder = new VoucherOrder();//5.1,订单id----id生成器long order = redisUUID.nextid("order");voucherOrder.setVoucherId(order);//5.2,用户idLong id = UserHolder.getUser().getId();voucherOrder.setUserId(id);//5.3,商品idvoucherOrder.setVoucherId(voucherId);//6,保存进数据库save(voucherOrder);//7,返回数据return Result.ok(order);}
}

 

库存超卖问题

先看看什么是库存超卖问题:

正常情况:

ec6c0f2b42804805a77a24f6e75ce430.jpg

 但是涉及到高并发的时候一定会出问题:

b46184b741a443fdbfa8f540833db7cf.jpg

所以我们要想办法去解决这个问题,锁!!!

ee298fbbb6684e16bc4411dcc7c90c40.jpg

 悲观锁认为一定发生并发问题,所以每一次操作都会加锁,是线程串行进行,不会出现并发问题,但是这样的话就导致性能降低,所以我们使用乐观锁,乐观锁是先让你操作,等你要修改数据库的时候再判断与你查到的数据是否是一样,如果是一样的才可以修改,否则不可以减库存。

乐观锁的两种实现判断法:

第一种:版本号法,就是通过查询两次版本号来判断是否被修改过库存

ac6f979be91d4cba9c36fff6f96e61a8.jpg

第二种:CAS法,是在版本号法上做的改进方法,既然要判断两次版本是否相同,为啥不判断库存量是否相同呢,所以CSA法就是去判断前后两次查询到的库存量是否一样,如果一样就可以改

c859dfee73f44fd9844699936966ab0c.jpg

用乐观锁CAS法来解决超卖问题:

//4,如果有就减扣库存boolean sucess = iSeckillVoucherService.update().setSql("stock = stock - 1").eq("voucher_id", voucherId).eq("stock",voucher.getStock()).update();if (!sucess) {return Result.fail("库存不足!");}

但是这样任然还不能解决超卖问题,因为如果两个线程同时来查到100,线程1做完修改还剩99,线程2查到不是100就会不执行修改,这样也会有问题,所以又要进行改进策略

 //4,如果有就减扣库存boolean sucess = iSeckillVoucherService.update().setSql("stock = stock - 1").eq("voucher_id", voucherId).gt("stock",0).update();if (!sucess) {return Result.fail("库存不足!");}

一人一单问题

 使用悲观锁处理单体服务下的多线程问题:

@Service
public class VoucherOrderServiceImpl extends ServiceImpl<VoucherOrderMapper, VoucherOrder> implements IVoucherOrderService {@Autowiredprivate ISeckillVoucherService iSeckillVoucherService;@Autowiredprivate RedisUUID redisUUID;@Overridepublic Result seckillVoucher(Long voucherId) {//1,查询商品的信息SeckillVoucher voucher = iSeckillVoucherService.getById(voucherId);//2,看是否在秒杀时间范围内if (voucher.getBeginTime().isAfter(LocalDateTime.now())) {return Result.fail("尚未开始!");}if (voucher.getEndTime().isBefore(LocalDateTime.now())) {return Result.fail("已经结束啦!");}//3,再看库存是否还有if (voucher.getStock()<1) {return Result.fail("库存不足!");}//实现单体服务下的一人一单的多线程安全问题Long id = UserHolder.getUser().getId();//先获取锁,再提交事务,保证线程安全synchronized (id.toString().intern()){//获得Spring的代理对象(事务)IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();return proxy.createVoucherOrder(voucherId);}}@Transactionalpublic Result createVoucherOrder(Long voucherId) {//一人一单问题Long id = UserHolder.getUser().getId();Integer count = query().eq("user_id", id).eq("voucher_id", voucherId).count();if(count > 0){return Result.fail("你已经购买过!");}//4,如果有就减扣库存boolean sucess = iSeckillVoucherService.update().setSql("stock = stock - 1").eq("voucher_id", voucherId).gt("stock",0).update();if (!sucess) {return Result.fail("库存不足!");}//5,然后就创建订单信息VoucherOrder voucherOrder = new VoucherOrder();//5.1,订单id----id生成器long order = redisUUID.nextid("order");voucherOrder.setVoucherId(order);//5.2,用户idvoucherOrder.setUserId(id);//5.3,商品idvoucherOrder.setVoucherId(voucherId);//6,保存进数据库save(voucherOrder);//7,返回数据return Result.ok(order);}
}

 添加依赖:

        <dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId></dependency>

 在启动类上添加:

@EnableAspectJAutoProxy(exposeProxy = true)

分布式集群模式下的多线程问题:

当我们是处理分布式集群模式下,两个JVM不是共用一把锁,导致每个JVM都有自己的锁导致我们之前的锁锁不住,每个JVM都有一个线程会获得锁。

 

 分布式锁:满足分布式系统或者集群模式下多进程可见并且互斥的锁

 

 

 基于Redis实现分布式锁:

创建锁对象:
import org.springframework.data.redis.core.StringRedisTemplate;
import java.util.concurrent.TimeUnit;public class SimpleRedisLock implements ILock{private String name;private StringRedisTemplate stringRedisTemplate;private static final  String KEY_PREFXY="lock:";public SimpleRedisLock(String name, StringRedisTemplate stringRedisTemplate) {this.name = name;this.stringRedisTemplate = stringRedisTemplate;}@Overridepublic boolean trylock(long timeoutSec) {//获取线程ID作为标识long ThreadId = Thread.currentThread().getId();//获取锁Boolean success = stringRedisTemplate.opsForValue().setIfAbsent(KEY_PREFXY + name, ThreadId + "", timeoutSec, TimeUnit.MINUTES);//避免空指针return Boolean.TRUE.equals(success);}@Overridepublic void unlock() {stringRedisTemplate.delete(KEY_PREFXY + name);}
}
代码实现Redis分布式锁的应用:

①先创建锁的对象,然后先是去获取锁②没有获取到锁就直接返回错误③获取到锁就可以进行对数据库的操作④操作完之后进行释放锁

Long id = UserHolder.getUser().getId();//创建锁对象SimpleRedisLock simpleRedisLock = new SimpleRedisLock("order" + id, stringRedisTemplate);//获取锁boolean trylock = simpleRedisLock.trylock(1200);//判断是否获得锁成功if (!trylock) {//获取锁失败return Result.fail("不允许重复下单!");}//获得Spring的代理对象(事务)try {IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();return proxy.createVoucherOrder(voucherId);} finally {//释放锁simpleRedisLock.unlock();}

 但是就上面的处理还不够严谨,因为如果一个线程发生阻塞的话,其他线程可能会获得锁并且释放锁,导致锁误删问题,

解决锁误删问题:
import cn.hutool.core.lang.UUID;
import org.springframework.data.redis.core.StringRedisTemplate;
import java.util.concurrent.TimeUnit;public class SimpleRedisLock implements ILock{private String name;private StringRedisTemplate stringRedisTemplate;private static final  String KEY_PREFXY="lock:";//得到一个唯一锁的标识private static final  String ID_PREFXY= UUID.randomUUID(true)+"-";public SimpleRedisLock(String name, StringRedisTemplate stringRedisTemplate) {this.name = name;this.stringRedisTemplate = stringRedisTemplate;}@Overridepublic boolean trylock(long timeoutSec) {//获取线程标识String ThreadId = ID_PREFXY+Thread.currentThread().getId();//获取锁Boolean success = stringRedisTemplate.opsForValue().setIfAbsent(KEY_PREFXY + name, ThreadId, timeoutSec, TimeUnit.MINUTES);//避免空指针return Boolean.TRUE.equals(success);}@Overridepublic void unlock() {//获取线程标识String ThreadId = ID_PREFXY+Thread.currentThread().getId();//判断要来修改的进程跟锁的标识是否一致String s = stringRedisTemplate.opsForValue().get(KEY_PREFXY + name);if(ThreadId.equals(s)){//释放锁stringRedisTemplate.delete(KEY_PREFXY + name);}}
}

这篇关于Redis---------实现商品秒杀业务,包括唯一ID,超卖问题,分布式锁的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/958956

相关文章

SpringBoot3实现Gzip压缩优化的技术指南

《SpringBoot3实现Gzip压缩优化的技术指南》随着Web应用的用户量和数据量增加,网络带宽和页面加载速度逐渐成为瓶颈,为了减少数据传输量,提高用户体验,我们可以使用Gzip压缩HTTP响应,... 目录1、简述2、配置2.1 添加依赖2.2 配置 Gzip 压缩3、服务端应用4、前端应用4.1 N

SpringBoot实现数据库读写分离的3种方法小结

《SpringBoot实现数据库读写分离的3种方法小结》为了提高系统的读写性能和可用性,读写分离是一种经典的数据库架构模式,在SpringBoot应用中,有多种方式可以实现数据库读写分离,本文将介绍三... 目录一、数据库读写分离概述二、方案一:基于AbstractRoutingDataSource实现动态

Python FastAPI+Celery+RabbitMQ实现分布式图片水印处理系统

《PythonFastAPI+Celery+RabbitMQ实现分布式图片水印处理系统》这篇文章主要为大家详细介绍了PythonFastAPI如何结合Celery以及RabbitMQ实现简单的分布式... 实现思路FastAPI 服务器Celery 任务队列RabbitMQ 作为消息代理定时任务处理完整

springboot循环依赖问题案例代码及解决办法

《springboot循环依赖问题案例代码及解决办法》在SpringBoot中,如果两个或多个Bean之间存在循环依赖(即BeanA依赖BeanB,而BeanB又依赖BeanA),会导致Spring的... 目录1. 什么是循环依赖?2. 循环依赖的场景案例3. 解决循环依赖的常见方法方法 1:使用 @La

Java枚举类实现Key-Value映射的多种实现方式

《Java枚举类实现Key-Value映射的多种实现方式》在Java开发中,枚举(Enum)是一种特殊的类,本文将详细介绍Java枚举类实现key-value映射的多种方式,有需要的小伙伴可以根据需要... 目录前言一、基础实现方式1.1 为枚举添加属性和构造方法二、http://www.cppcns.co

使用Python实现快速搭建本地HTTP服务器

《使用Python实现快速搭建本地HTTP服务器》:本文主要介绍如何使用Python快速搭建本地HTTP服务器,轻松实现一键HTTP文件共享,同时结合二维码技术,让访问更简单,感兴趣的小伙伴可以了... 目录1. 概述2. 快速搭建 HTTP 文件共享服务2.1 核心思路2.2 代码实现2.3 代码解读3.

MySQL双主搭建+keepalived高可用的实现

《MySQL双主搭建+keepalived高可用的实现》本文主要介绍了MySQL双主搭建+keepalived高可用的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,... 目录一、测试环境准备二、主从搭建1.创建复制用户2.创建复制关系3.开启复制,确认复制是否成功4.同

Java实现文件图片的预览和下载功能

《Java实现文件图片的预览和下载功能》这篇文章主要为大家详细介绍了如何使用Java实现文件图片的预览和下载功能,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... Java实现文件(图片)的预览和下载 @ApiOperation("访问文件") @GetMapping("

使用Sentinel自定义返回和实现区分来源方式

《使用Sentinel自定义返回和实现区分来源方式》:本文主要介绍使用Sentinel自定义返回和实现区分来源方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录Sentinel自定义返回和实现区分来源1. 自定义错误返回2. 实现区分来源总结Sentinel自定

Java实现时间与字符串互相转换详解

《Java实现时间与字符串互相转换详解》这篇文章主要为大家详细介绍了Java中实现时间与字符串互相转换的相关方法,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 目录一、日期格式化为字符串(一)使用预定义格式(二)自定义格式二、字符串解析为日期(一)解析ISO格式字符串(二)解析自定义