通过秒杀商品来模拟高并发的场景
1.引言
高并发场景在现场的日常工作中很常见，特别是在互联网公司中，这篇文章就来通过秒杀商品来模拟高并发的场景。文章末尾会附上文章的所有代码、脚本和测试用例。
本文环境： springboot 2.5.7 + mysql 8.0 x + mybatisplus + swagger2.9.2
模拟工具： jmeter
模拟场景： 减库存->创建订单->模拟支付
2.商品秒杀-超卖
在开发中，对于下面的代码，可能很熟悉：在service里面加上@transactional事务注解和lock锁
控制层：controller
@apioperation(value=秒杀实现方式——lock加锁)@postmapping(/start/lock)public result startlock(long skgid){ try { log.info(开始秒杀方式一...); final long userid = (int) (new random().nextdouble() * (99999 - 10000 + 1)) + 10000; result result = secondkillservice.startsecondkillbylock(skgid, userid); if(result != null){ log.info(用户:{}--{}, userid, result.get(msg)); }else{ log.info(用户:{}--{}, userid, 哎呦喂，人也太多了，请稍后！); } } catch (exception e) { e.printstacktrace(); } finally { } return result.ok();}
业务层：service
@override@transactional(rollbackfor = exception.class)public result startsecondkillbylock(long skgid, long userid) { lock.lock(); try { // 校验库存 secondkill secondkill = secondkillmapper.selectbyid(skgid); integer number = secondkill.getnumber(); if (number > 0) { // 扣库存 secondkill.setnumber(number - 1); secondkillmapper.updatebyid(secondkill); // 创建订单 successkilled killed = new successkilled(); killed.setseckillid(skgid); killed.setuserid(userid); killed.setstate((short) 0); killed.setcreatetime(new timestamp(system.currenttimemillis())); successkilledmapper.insert(killed); // 模拟支付 payment payment = new payment(); payment.setseckillid(skgid); payment.setseckillid(skgid); payment.setuserid(userid); payment.setmoney(40); payment.setstate((short) 1); payment.setcreatetime(new timestamp(system.currenttimemillis())); paymentmapper.insert(payment); } else { return result.error(secondkillstateenum.end); } } catch (exception e) { throw new scorpiosexception(异常了个乖乖); } finally { lock.unlock(); } return result.ok(secondkillstateenum.success);}
对于上面的代码应该没啥问题吧，业务方法上加事务，在处理业务的时候加锁。
但上面这样写法是有问题的，会出现超卖的情况，看下测试结果：模拟1000个并发，抢100商品
这里在业务方法开始加了锁，在业务方法结束后释放了锁。但这里的事务提交却不是这样的，有可能在事务提交之前，就已经把锁释放了，这样会导致商品超卖现象。所以加锁的时机很重要！
3. 解决商品超卖
对于上面超卖现象，主要问题出现在事务中锁释放的时机，事务未提交之前，锁已经释放。（事务提交是在整个方法执行完）。如何解决这个问题呢，就是把加锁步骤提前
可以在controller层进行加锁
可以使用aop在业务方法执行之前进行加锁
3.1 方式一（改进版加锁）
@apioperation(value=秒杀实现方式——lock加锁)@postmapping(/start/lock)public result startlock(long skgid){ // 在此处加锁 lock.lock(); try { log.info(开始秒杀方式一...); final long userid = (int) (new random().nextdouble() * (99999 - 10000 + 1)) + 10000; result result = secondkillservice.startsecondkillbylock(skgid, userid); if(result != null){ log.info(用户:{}--{}, userid, result.get(msg)); }else{ log.info(用户:{}--{}, userid, 哎呦喂，人也太多了，请稍后！); } } catch (exception e) { e.printstacktrace(); } finally { // 在此处释放锁 lock.unlock(); } return result.ok();}
上面这样的加锁就可以解决事务未提交之前，锁释放的问题，可以分三种情况进行压力测试：
并发数1000，商品100
并发数1000，商品1000
并发数2000，商品1000
对于并发量大于商品数的情况，商品秒杀一般不会出现少卖的请况，但对于并发数小于等于商品数的时候可能会出现商品少卖情况，这也很好理解。
对于没有问题的情况就不贴图了，因为有很多种方式，贴图会太多
3.2 方式二（aop版加锁）
对于上面在控制层进行加锁的方式，可能显得不优雅，那就还有另一种方式进行在事务之前加锁，那就是aop
自定义aop注解
@target({elementtype.parameter, elementtype.method})@retention(retentionpolicy.runtime)@documentedpublic @interface servicelock { string description() default ;}
定义切面类
@slf4j@component@scope@aspect@order(1) //order越小越是最先执行，但更重要的是最先执行的最后结束public class lockaspect { /** * 思考：为什么不用synchronized * service 默认是单例的，并发下lock只有一个实例 */ private static lock lock = new reentrantlock(true); // 互斥锁 参数默认false，不公平锁 // service层切点 用于记录错误日志 @pointcut(@annotation(com.scorpios.secondkill.aop.servicelock)) public void lockaspect() { } @around(lockaspect()) public object around(proceedingjoinpoint joinpoint) { lock.lock(); object obj = null; try { obj = joinpoint.proceed(); } catch (throwable e) { e.printstacktrace(); throw new runtimeexception(); } finally{ lock.unlock(); } return obj; }}
在业务方法上添加aop注解
@override@servicelock // 使用aop进行加锁@transactional(rollbackfor = exception.class)public result startsecondkillbyaop(long skgid, long userid) { try { // 校验库存 secondkill secondkill = secondkillmapper.selectbyid(skgid); integer number = secondkill.getnumber(); if (number > 0) { //扣库存 secondkill.setnumber(number - 1); secondkillmapper.updatebyid(secondkill); //创建订单 successkilled killed = new successkilled(); killed.setseckillid(skgid); killed.setuserid(userid); killed.setstate((short) 0); killed.setcreatetime(new timestamp(system.currenttimemillis())); successkilledmapper.insert(killed); //支付 payment payment = new payment(); payment.setseckillid(skgid); payment.setseckillid(skgid); payment.setuserid(userid); payment.setmoney(40); payment.setstate((short) 1); payment.setcreatetime(new timestamp(system.currenttimemillis())); paymentmapper.insert(payment); } else { return result.error(secondkillstateenum.end); } } catch (exception e) { throw new scorpiosexception(异常了个乖乖); } return result.ok(secondkillstateenum.success);}
控制层：
@apioperation(value=秒杀实现方式二——aop加锁)@postmapping(/start/aop)public result startaop(long skgid){ try { log.info(开始秒杀方式二...); final long userid = (int) (new random().nextdouble() * (99999 - 10000 + 1)) + 10000; result result = secondkillservice.startsecondkillbyaop(skgid, userid); if(result != null){ log.info(用户:{}--{}, userid, result.get(msg)); }else{ log.info(用户:{}--{}, userid, 哎呦喂，人也太多了，请稍后！); } } catch (exception e) { e.printstacktrace(); } return result.ok();}
这种方式在对锁的使用上，更高阶、更美观！
3.3 方式三（悲观锁一）
除了上面在业务代码层面加锁外，还可以使用数据库自带的锁进行并发控制。
悲观锁，什么是悲观锁呢？通俗的说，在做任何事情之前，都要进行加锁确认。这种数据库级加锁操作效率较低。
使用for update一定要加上事务，当事务处理完后，for update才会将行级锁解除
如果请求数和秒杀商品数量一致，会出现少卖
@apioperation(value=秒杀实现方式三——悲观锁)@postmapping(/start/pes/lock/one)public result startpeslockone(long skgid){ try { log.info(开始秒杀方式三...); final long userid = (int) (new random().nextdouble() * (99999 - 10000 + 1)) + 10000; result result = secondkillservice.startsecondkillbyupdate(skgid, userid); if(result != null){ log.info(用户:{}--{}, userid, result.get(msg)); }else{ log.info(用户:{}--{}, userid, 哎呦喂，人也太多了，请稍后！); } } catch (exception e) { e.printstacktrace(); } return result.ok();}
业务逻辑
@override@transactional(rollbackfor = exception.class)public result startsecondkillbyupdate(long skgid, long userid) { try { // 校验库存-悲观锁 secondkill secondkill = secondkillmapper.querysecondkillforupdate(skgid); integer number = secondkill.getnumber(); if (number > 0) { //扣库存 secondkill.setnumber(number - 1); secondkillmapper.updatebyid(secondkill); //创建订单 successkilled killed = new successkilled(); killed.setseckillid(skgid); killed.setuserid(userid); killed.setstate((short) 0); killed.setcreatetime(new timestamp(system.currenttimemillis())); successkilledmapper.insert(killed); //支付 payment payment = new payment(); payment.setseckillid(skgid); payment.setseckillid(skgid); payment.setuserid(userid); payment.setmoney(40); payment.setstate((short) 1); payment.setcreatetime(new timestamp(system.currenttimemillis())); paymentmapper.insert(payment); } else { return result.error(secondkillstateenum.end); } } catch (exception e) { throw new scorpiosexception(异常了个乖乖); } finally { } return result.ok(secondkillstateenum.success);}
dao层
@repositorypublic interface secondkillmapper extends basemapper { /** * 将此行数据进行加锁，当整个方法将事务提交后，才会解锁 * @param skgid * @return */ @select(value = select * from seckill where seckill_id=#{skgid} for update) secondkill querysecondkillforupdate(@param(skgid) long skgid);}
上面是利用for update进行对查询数据加锁，加的是行锁
3.4 方式四（悲观锁二）
悲观锁的第二种方式就是利用update更新命令来加表锁
/** * update锁表 * @param skgid 商品id * @param userid 用户id * @return */@override@transactional(rollbackfor = exception.class)public result startsecondkillbyupdatetwo(long skgid, long userid) { try { // 不校验，直接扣库存更新 int result = secondkillmapper.updatesecondkillbyid(skgid); if (result > 0) { //创建订单 successkilled killed = new successkilled(); killed.setseckillid(skgid); killed.setuserid(userid); killed.setstate((short) 0); killed.setcreatetime(new timestamp(system.currenttimemillis())); successkilledmapper.insert(killed); //支付 payment payment = new payment(); payment.setseckillid(skgid); payment.setseckillid(skgid); payment.setuserid(userid); payment.setmoney(40); payment.setstate((short) 1); payment.setcreatetime(new timestamp(system.currenttimemillis())); paymentmapper.insert(payment); } else { return result.error(secondkillstateenum.end); } } catch (exception e) { throw new scorpiosexception(异常了个乖乖); } finally { } return result.ok(secondkillstateenum.success);}
dao层
@repositorypublic interface secondkillmapper extends basemapper { /** * 将此行数据进行加锁，当整个方法将事务提交后，才会解锁 * @param skgid * @return */ @select(value = select * from seckill where seckill_id=#{skgid} for update) secondkill querysecondkillforupdate(@param(skgid) long skgid); @update(value = update seckill set number=number-1 where seckill_id=#{skgid} and number > 0) int updatesecondkillbyid(@param(skgid) long skgid);}
3.5 方式五（乐观锁）
乐观锁，顾名思义，就是对操作结果很乐观，通过利用version字段来判断数据是否被修改
乐观锁，不进行库存数量的校验，直接做库存扣减
这里使用的乐观锁会出现大量的数据更新异常（抛异常就会导致购买失败）、如果配置的抢购人数比较少、比如120:100(人数:商品) 会出现少买的情况，不推荐使用乐观锁。
@apioperation(value=秒杀实现方式五——乐观锁)@postmapping(/start/opt/lock)public result startoptlock(long skgid){ try { log.info(开始秒杀方式五...); final long userid = (int) (new random().nextdouble() * (99999 - 10000 + 1)) + 10000; // 参数添加了购买数量 result result = secondkillservice.startsecondkillbypeslock(skgid, userid,1); if(result != null){ log.info(用户:{}--{}, userid, result.get(msg)); }else{ log.info(用户:{}--{}, userid, 哎呦喂，人也太多了，请稍后！); } } catch (exception e) { e.printstacktrace(); } return result.ok();}@override@transactional(rollbackfor = exception.class)public result startsecondkillbypeslock(long skgid, long userid, int number) { // 乐观锁，不进行库存数量的校验，直接 try { secondkill kill = secondkillmapper.selectbyid(skgid); // 剩余的数量应该要大于等于秒杀的数量 if(kill.getnumber() >= number) { int result = secondkillmapper.updatesecondkillbyversion(number,skgid,kill.getversion()); if (result > 0) { //创建订单 successkilled killed = new successkilled(); killed.setseckillid(skgid); killed.setuserid(userid); killed.setstate((short) 0); killed.setcreatetime(new timestamp(system.currenttimemillis())); successkilledmapper.insert(killed); //支付 payment payment = new payment(); payment.setseckillid(skgid); payment.setseckillid(skgid); payment.setuserid(userid); payment.setmoney(40); payment.setstate((short) 1); payment.setcreatetime(new timestamp(system.currenttimemillis())); paymentmapper.insert(payment); } else { return result.error(secondkillstateenum.end); } } } catch (exception e) { throw new scorpiosexception(异常了个乖乖); } finally { } return result.ok(secondkillstateenum.success);}@repositorypublic interface secondkillmapper extends basemapper { /** * 将此行数据进行加锁，当整个方法将事务提交后，才会解锁 * @param skgid * @return */ @select(value = select * from seckill where seckill_id=#{skgid} for update) secondkill querysecondkillforupdate(@param(skgid) long skgid); @update(value = update seckill set number=number-1 where seckill_id=#{skgid} and number > 0) int updatesecondkillbyid(@param(skgid) long skgid); @update(value = update seckill set number=number-#{number},version=version+1 where seckill_id=#{skgid} and version = #{version}) int updatesecondkillbyversion(@param(number) int number, @param(skgid) long skgid, @param(version)int version);}
乐观锁会出现大量的数据更新异常（抛异常就会导致购买失败），会出现少买的情况，不推荐使用乐观锁
3.6 方式六（阻塞队列）
利用阻塞队类，也可以解决高并发问题。其思想就是把接收到的请求按顺序存放到队列中，消费者线程逐一从队列里取数据进行处理，看下具体代码。
阻塞队列：这里使用静态内部类的方式来实现单例模式，在并发条件下不会出现问题。
// 秒杀队列(固定长度为100)public class secondkillqueue { // 队列大小 static final int queue_max_size = 100; // 用于多线程间下单的队列 static blockingqueue blockingqueue = new linkedblockingqueue(queue_max_size); // 使用静态内部类，实现单例模式 private secondkillqueue(){}; private static class singletonholder{ // 静态初始化器，由jvm来保证线程安全 private static secondkillqueue queue = new secondkillqueue(); } /** * 单例队列 * @return */ public static secondkillqueue getskillqueue(){ return singletonholder.queue; } /** * 生产入队 * @param kill * @throws interruptedexception * add(e) 队列未满时，返回true；队列满则抛出illegalstateexception(“queue full”)异常——abstractqueue * put(e) 队列未满时，直接插入没有返回值；队列满时会阻塞等待，一直等到队列未满时再插入。 * offer(e) 队列未满时，返回true；队列满时返回false。非阻塞立即返回。 * offer(e, time, unit) 设定等待的时间，如果在指定时间内还不能往队列中插入数据则返回false，插入成功返回true。 */ public boolean produce(successkilled kill) { return blockingqueue.offer(kill); } /** * 消费出队 * poll() 获取并移除队首元素，在指定的时间内去轮询队列看有没有首元素有则返回，否者超时后返回null * take() 与带超时时间的poll类似不同在于take时候如果当前队列空了它会一直等待其他线程调用notempty.signal()才会被唤醒 */ public successkilled consume() throws interruptedexception { return blockingqueue.take(); } /** * 获取队列大小 * @return */ public int size() { return blockingqueue.size(); }}
消费秒杀队列：实现applicationrunner接口
// 消费秒杀队列@slf4j@componentpublic class taskrunner implements applicationrunner{ @autowired private secondkillservice seckillservice; @override public void run(applicationarguments var){ new thread(() -> { log.info(队列启动成功); while(true){ try { // 进程内队列 successkilled kill = secondkillqueue.getskillqueue().consume(); if(kill != null){ result result = seckillservice.startsecondkillbyaop(kill.getseckillid(), kill.getuserid()); if(result != null && result.equals(result.ok(secondkillstateenum.success))){ log.info(taskrunner,result:{},result); log.info(taskrunner从消息队列取出用户，用户:{}{},kill.getuserid(),秒杀成功); } } } catch (interruptedexception e) { e.printstacktrace(); } } }).start(); }}@apioperation(value=秒杀实现方式六——消息队列)@postmapping(/start/queue)public result startqueue(long skgid){ try { log.info(开始秒杀方式六...); final long userid = (int) (new random().nextdouble() * (99999 - 10000 + 1)) + 10000; successkilled kill = new successkilled(); kill.setseckillid(skgid); kill.setuserid(userid); boolean flag = secondkillqueue.getskillqueue().produce(kill); // 虽然进入了队列，但是不一定能秒杀成功 进队出队有时间间隙 if(flag){ log.info(用户:{}{},kill.getuserid(),秒杀成功); }else{ log.info(用户:{}{},userid,秒杀失败); } } catch (exception e) { e.printstacktrace(); } return result.ok();}
注意：在业务层和aop方法中，不能抛出任何异常， throw new runtimeexception()这些抛异常代码要注释掉。因为一旦程序抛出异常就会停止，导致消费秒杀队列进程终止！
使用阻塞队列来实现秒杀，有几点要注意：
消费秒杀队列中调用业务方法加锁与不加锁情况一样，也就是seckillservice.startsecondkillbyaop()、seckillservice.startsecondkillbylock()方法结果一样，这也很好理解
当队列长度与商品数量一致时，会出现少卖的现象，可以调大数值
下面是队列长度1000，商品数量1000，并发数2000情况下出现的少卖
3.7.方式七（disruptor队列）
disruptor是个高性能队列，研发的初衷是解决内存队列的延迟问题，在性能测试中发现竟然与i/o操作处于同样的数量级，基于disruptor开发的系统单线程能支撑每秒600万订单。
// 事件生成工厂（用来初始化预分配事件对象）public class secondkilleventfactory implements eventfactory { @override public secondkillevent newinstance() { return new secondkillevent(); }}// 事件对象（秒杀事件）public class secondkillevent implements serializable { private static final long serialversionuid = 1l; private long seckillid; private long userid; // set/get方法略}// 使用translator方式生产者public class secondkilleventproducer { private final static eventtranslatorvararg translator = (seckillevent, seq, objs) -> { seckillevent.setseckillid((long) objs[0]); seckillevent.setuserid((long) objs[1]); }; private final ringbuffer ringbuffer; public secondkilleventproducer(ringbuffer ringbuffer){ this.ringbuffer = ringbuffer; } public void secondkill(long seckillid, long userid){ this.ringbuffer.publishevent(translator, seckillid, userid); }}// 消费者(秒杀处理器)@slf4jpublic class secondkilleventconsumer implements eventhandler { private secondkillservice secondkillservice = (secondkillservice) springutil.getbean(secondkillservice); @override public void onevent(secondkillevent seckillevent, long seq, boolean bool) { result result = secondkillservice.startsecondkillbyaop(seckillevent.getseckillid(), seckillevent.getuserid()); if(result.equals(result.ok(secondkillstateenum.success))){ log.info(用户:{}{},seckillevent.getuserid(),秒杀成功); } }}public class disruptorutil { static disruptor disruptor; static{ secondkilleventfactory factory = new secondkilleventfactory(); int ringbuffersize = 1024; threadfactory threadfactory = runnable -> new thread(runnable); disruptor = new disruptor(factory, ringbuffersize, threadfactory); disruptor.handleeventswith(new secondkilleventconsumer()); disruptor.start(); } public static void producer(secondkillevent kill){ ringbuffer ringbuffer = disruptor.getringbuffer(); secondkilleventproducer producer = new secondkilleventproducer(ringbuffer); producer.secondkill(kill.getseckillid(),kill.getuserid()); }}@apioperation(value=秒杀实现方式七——disruptor队列)@postmapping(/start/disruptor)public result startdisruptor(long skgid){ try { log.info(开始秒杀方式七...); final long userid = (int) (new random().nextdouble() * (99999 - 10000 + 1)) + 10000; secondkillevent kill = new secondkillevent(); kill.setseckillid(skgid); kill.setuserid(userid); disruptorutil.producer(kill); } catch (exception e) { e.printstacktrace(); } return result.ok();}
经过测试，发现使用disruptor队列队列，与自定义队列有着同样的问题，也会出现超卖的情况，但效率有所提高。
4. 小结
对于上面七种实现并发的方式，做一下总结：
一、二方式是在代码中利用锁和事务的方式解决了并发问题，主要解决的是锁要加载事务之前
三、四、五方式主要是数据库的锁来解决并发问题，方式三是利用for upate对表加行锁，方式四是利用update来对表加锁，方式五是通过增加version字段来控制数据库的更新操作，方式五的效果最差
六、七方式是通过队列来解决并发问题，这里需要特别注意的是，在代码中不能通过throw抛异常，否则消费线程会终止，而且由于进队和出队存在时间间隙，会导致商品少卖
上面所有的情况都经过代码测试，测试分一下三种情况：
并发数1000，商品数100
并发数1000，商品数1000
并发数2000，商品数1000
思考：分布式情况下如何解决并发问题呢？下次继续试验。
钢管切割设备 相贯线切割机
温湿度试验箱的操作方法-贝尔试验箱
采用MAX22191的工业数字输入
首发新品Viva机器人洗地机，享受自由生活，拥抱美好未来今日
Diodes推出专为IGBT设计的ZXGD3006E6闸极驱动器
通过秒杀商品来模拟高并发的场景
励磁涌流是怎么产生的?与哪些因素有关
iPhone SE 2曝光将采用类似iPhone 8的设计非刘海全面屏没有双摄
半导体制造工艺中的主要设备及材料【三】
双电源转换开关怎么用_双电源转换开关用途
【CES Asia 2018】汉能推出一款发电包包，论时尚论实用都秒杀LV？
以科技为支撑，赋能邢台银行战略转型
法国NGO组织以无人机试探核电站安保底线，为了表明法国的核设施缺乏安全保障措施
低压无功补偿控制电路图
见证LG产电超高压事业迈向新台阶
一文看懂ARM里的RAM和SDRAM有什么区别
AMD与微软合作研发采用AMD锐龙移动技术新一代Surface Laptop
西门子S7-1500系列PLC控制的6轴机器人系统解析
健康监测超过200万例，这款脉诊仪有何不同？
探地雷达 — 将是自动驾驶车辆传感领域的下一个创新点吗？
高并发场景在现场的日常工作中很常见，特别是在互联网公司中，这篇文章就来通过秒杀商品来模拟高并发的场景。文章末尾会附上文章的所有代码、脚本和测试用例。
本文环境： springboot 2.5.7 + mysql 8.0 x + mybatisplus + swagger2.9.2
模拟工具： jmeter
模拟场景： 减库存->创建订单->模拟支付
2.商品秒杀-超卖
在开发中，对于下面的代码，可能很熟悉：在service里面加上@transactional事务注解和lock锁
控制层：controller
@apioperation(value=秒杀实现方式——lock加锁)@postmapping(/start/lock)public result startlock(long skgid){ try { log.info(开始秒杀方式一...); final long userid = (int) (new random().nextdouble() * (99999 - 10000 + 1)) + 10000; result result = secondkillservice.startsecondkillbylock(skgid, userid); if(result != null){ log.info(用户:{}--{}, userid, result.get(msg)); }else{ log.info(用户:{}--{}, userid, 哎呦喂，人也太多了，请稍后！); } } catch (exception e) { e.printstacktrace(); } finally { } return result.ok();}
业务层：service
@override@transactional(rollbackfor = exception.class)public result startsecondkillbylock(long skgid, long userid) { lock.lock(); try { // 校验库存 secondkill secondkill = secondkillmapper.selectbyid(skgid); integer number = secondkill.getnumber(); if (number > 0) { // 扣库存 secondkill.setnumber(number - 1); secondkillmapper.updatebyid(secondkill); // 创建订单 successkilled killed = new successkilled(); killed.setseckillid(skgid); killed.setuserid(userid); killed.setstate((short) 0); killed.setcreatetime(new timestamp(system.currenttimemillis())); successkilledmapper.insert(killed); // 模拟支付 payment payment = new payment(); payment.setseckillid(skgid); payment.setseckillid(skgid); payment.setuserid(userid); payment.setmoney(40); payment.setstate((short) 1); payment.setcreatetime(new timestamp(system.currenttimemillis())); paymentmapper.insert(payment); } else { return result.error(secondkillstateenum.end); } } catch (exception e) { throw new scorpiosexception(异常了个乖乖); } finally { lock.unlock(); } return result.ok(secondkillstateenum.success);}
对于上面的代码应该没啥问题吧，业务方法上加事务，在处理业务的时候加锁。
但上面这样写法是有问题的，会出现超卖的情况，看下测试结果：模拟1000个并发，抢100商品
这里在业务方法开始加了锁，在业务方法结束后释放了锁。但这里的事务提交却不是这样的，有可能在事务提交之前，就已经把锁释放了，这样会导致商品超卖现象。所以加锁的时机很重要！
3. 解决商品超卖
对于上面超卖现象，主要问题出现在事务中锁释放的时机，事务未提交之前，锁已经释放。（事务提交是在整个方法执行完）。如何解决这个问题呢，就是把加锁步骤提前
可以在controller层进行加锁
可以使用aop在业务方法执行之前进行加锁
3.1 方式一（改进版加锁）
@apioperation(value=秒杀实现方式——lock加锁)@postmapping(/start/lock)public result startlock(long skgid){ // 在此处加锁 lock.lock(); try { log.info(开始秒杀方式一...); final long userid = (int) (new random().nextdouble() * (99999 - 10000 + 1)) + 10000; result result = secondkillservice.startsecondkillbylock(skgid, userid); if(result != null){ log.info(用户:{}--{}, userid, result.get(msg)); }else{ log.info(用户:{}--{}, userid, 哎呦喂，人也太多了，请稍后！); } } catch (exception e) { e.printstacktrace(); } finally { // 在此处释放锁 lock.unlock(); } return result.ok();}
上面这样的加锁就可以解决事务未提交之前，锁释放的问题，可以分三种情况进行压力测试：
并发数1000，商品100
并发数1000，商品1000
并发数2000，商品1000
对于并发量大于商品数的情况，商品秒杀一般不会出现少卖的请况，但对于并发数小于等于商品数的时候可能会出现商品少卖情况，这也很好理解。
对于没有问题的情况就不贴图了，因为有很多种方式，贴图会太多
3.2 方式二（aop版加锁）
对于上面在控制层进行加锁的方式，可能显得不优雅，那就还有另一种方式进行在事务之前加锁，那就是aop
自定义aop注解
@target({elementtype.parameter, elementtype.method})@retention(retentionpolicy.runtime)@documentedpublic @interface servicelock { string description() default ;}
定义切面类
@slf4j@component@scope@aspect@order(1) //order越小越是最先执行，但更重要的是最先执行的最后结束public class lockaspect { /** * 思考：为什么不用synchronized * service 默认是单例的，并发下lock只有一个实例 */ private static lock lock = new reentrantlock(true); // 互斥锁 参数默认false，不公平锁 // service层切点 用于记录错误日志 @pointcut(@annotation(com.scorpios.secondkill.aop.servicelock)) public void lockaspect() { } @around(lockaspect()) public object around(proceedingjoinpoint joinpoint) { lock.lock(); object obj = null; try { obj = joinpoint.proceed(); } catch (throwable e) { e.printstacktrace(); throw new runtimeexception(); } finally{ lock.unlock(); } return obj; }}
在业务方法上添加aop注解
@override@servicelock // 使用aop进行加锁@transactional(rollbackfor = exception.class)public result startsecondkillbyaop(long skgid, long userid) { try { // 校验库存 secondkill secondkill = secondkillmapper.selectbyid(skgid); integer number = secondkill.getnumber(); if (number > 0) { //扣库存 secondkill.setnumber(number - 1); secondkillmapper.updatebyid(secondkill); //创建订单 successkilled killed = new successkilled(); killed.setseckillid(skgid); killed.setuserid(userid); killed.setstate((short) 0); killed.setcreatetime(new timestamp(system.currenttimemillis())); successkilledmapper.insert(killed); //支付 payment payment = new payment(); payment.setseckillid(skgid); payment.setseckillid(skgid); payment.setuserid(userid); payment.setmoney(40); payment.setstate((short) 1); payment.setcreatetime(new timestamp(system.currenttimemillis())); paymentmapper.insert(payment); } else { return result.error(secondkillstateenum.end); } } catch (exception e) { throw new scorpiosexception(异常了个乖乖); } return result.ok(secondkillstateenum.success);}
控制层：
@apioperation(value=秒杀实现方式二——aop加锁)@postmapping(/start/aop)public result startaop(long skgid){ try { log.info(开始秒杀方式二...); final long userid = (int) (new random().nextdouble() * (99999 - 10000 + 1)) + 10000; result result = secondkillservice.startsecondkillbyaop(skgid, userid); if(result != null){ log.info(用户:{}--{}, userid, result.get(msg)); }else{ log.info(用户:{}--{}, userid, 哎呦喂，人也太多了，请稍后！); } } catch (exception e) { e.printstacktrace(); } return result.ok();}
这种方式在对锁的使用上，更高阶、更美观！
3.3 方式三（悲观锁一）
除了上面在业务代码层面加锁外，还可以使用数据库自带的锁进行并发控制。
悲观锁，什么是悲观锁呢？通俗的说，在做任何事情之前，都要进行加锁确认。这种数据库级加锁操作效率较低。
使用for update一定要加上事务，当事务处理完后，for update才会将行级锁解除
如果请求数和秒杀商品数量一致，会出现少卖
@apioperation(value=秒杀实现方式三——悲观锁)@postmapping(/start/pes/lock/one)public result startpeslockone(long skgid){ try { log.info(开始秒杀方式三...); final long userid = (int) (new random().nextdouble() * (99999 - 10000 + 1)) + 10000; result result = secondkillservice.startsecondkillbyupdate(skgid, userid); if(result != null){ log.info(用户:{}--{}, userid, result.get(msg)); }else{ log.info(用户:{}--{}, userid, 哎呦喂，人也太多了，请稍后！); } } catch (exception e) { e.printstacktrace(); } return result.ok();}
业务逻辑
@override@transactional(rollbackfor = exception.class)public result startsecondkillbyupdate(long skgid, long userid) { try { // 校验库存-悲观锁 secondkill secondkill = secondkillmapper.querysecondkillforupdate(skgid); integer number = secondkill.getnumber(); if (number > 0) { //扣库存 secondkill.setnumber(number - 1); secondkillmapper.updatebyid(secondkill); //创建订单 successkilled killed = new successkilled(); killed.setseckillid(skgid); killed.setuserid(userid); killed.setstate((short) 0); killed.setcreatetime(new timestamp(system.currenttimemillis())); successkilledmapper.insert(killed); //支付 payment payment = new payment(); payment.setseckillid(skgid); payment.setseckillid(skgid); payment.setuserid(userid); payment.setmoney(40); payment.setstate((short) 1); payment.setcreatetime(new timestamp(system.currenttimemillis())); paymentmapper.insert(payment); } else { return result.error(secondkillstateenum.end); } } catch (exception e) { throw new scorpiosexception(异常了个乖乖); } finally { } return result.ok(secondkillstateenum.success);}
dao层
@repositorypublic interface secondkillmapper extends basemapper { /** * 将此行数据进行加锁，当整个方法将事务提交后，才会解锁 * @param skgid * @return */ @select(value = select * from seckill where seckill_id=#{skgid} for update) secondkill querysecondkillforupdate(@param(skgid) long skgid);}
上面是利用for update进行对查询数据加锁，加的是行锁
3.4 方式四（悲观锁二）
悲观锁的第二种方式就是利用update更新命令来加表锁
/** * update锁表 * @param skgid 商品id * @param userid 用户id * @return */@override@transactional(rollbackfor = exception.class)public result startsecondkillbyupdatetwo(long skgid, long userid) { try { // 不校验，直接扣库存更新 int result = secondkillmapper.updatesecondkillbyid(skgid); if (result > 0) { //创建订单 successkilled killed = new successkilled(); killed.setseckillid(skgid); killed.setuserid(userid); killed.setstate((short) 0); killed.setcreatetime(new timestamp(system.currenttimemillis())); successkilledmapper.insert(killed); //支付 payment payment = new payment(); payment.setseckillid(skgid); payment.setseckillid(skgid); payment.setuserid(userid); payment.setmoney(40); payment.setstate((short) 1); payment.setcreatetime(new timestamp(system.currenttimemillis())); paymentmapper.insert(payment); } else { return result.error(secondkillstateenum.end); } } catch (exception e) { throw new scorpiosexception(异常了个乖乖); } finally { } return result.ok(secondkillstateenum.success);}
dao层
@repositorypublic interface secondkillmapper extends basemapper { /** * 将此行数据进行加锁，当整个方法将事务提交后，才会解锁 * @param skgid * @return */ @select(value = select * from seckill where seckill_id=#{skgid} for update) secondkill querysecondkillforupdate(@param(skgid) long skgid); @update(value = update seckill set number=number-1 where seckill_id=#{skgid} and number > 0) int updatesecondkillbyid(@param(skgid) long skgid);}
3.5 方式五（乐观锁）
乐观锁，顾名思义，就是对操作结果很乐观，通过利用version字段来判断数据是否被修改
乐观锁，不进行库存数量的校验，直接做库存扣减
这里使用的乐观锁会出现大量的数据更新异常（抛异常就会导致购买失败）、如果配置的抢购人数比较少、比如120:100(人数:商品) 会出现少买的情况，不推荐使用乐观锁。
@apioperation(value=秒杀实现方式五——乐观锁)@postmapping(/start/opt/lock)public result startoptlock(long skgid){ try { log.info(开始秒杀方式五...); final long userid = (int) (new random().nextdouble() * (99999 - 10000 + 1)) + 10000; // 参数添加了购买数量 result result = secondkillservice.startsecondkillbypeslock(skgid, userid,1); if(result != null){ log.info(用户:{}--{}, userid, result.get(msg)); }else{ log.info(用户:{}--{}, userid, 哎呦喂，人也太多了，请稍后！); } } catch (exception e) { e.printstacktrace(); } return result.ok();}@override@transactional(rollbackfor = exception.class)public result startsecondkillbypeslock(long skgid, long userid, int number) { // 乐观锁，不进行库存数量的校验，直接 try { secondkill kill = secondkillmapper.selectbyid(skgid); // 剩余的数量应该要大于等于秒杀的数量 if(kill.getnumber() >= number) { int result = secondkillmapper.updatesecondkillbyversion(number,skgid,kill.getversion()); if (result > 0) { //创建订单 successkilled killed = new successkilled(); killed.setseckillid(skgid); killed.setuserid(userid); killed.setstate((short) 0); killed.setcreatetime(new timestamp(system.currenttimemillis())); successkilledmapper.insert(killed); //支付 payment payment = new payment(); payment.setseckillid(skgid); payment.setseckillid(skgid); payment.setuserid(userid); payment.setmoney(40); payment.setstate((short) 1); payment.setcreatetime(new timestamp(system.currenttimemillis())); paymentmapper.insert(payment); } else { return result.error(secondkillstateenum.end); } } } catch (exception e) { throw new scorpiosexception(异常了个乖乖); } finally { } return result.ok(secondkillstateenum.success);}@repositorypublic interface secondkillmapper extends basemapper { /** * 将此行数据进行加锁，当整个方法将事务提交后，才会解锁 * @param skgid * @return */ @select(value = select * from seckill where seckill_id=#{skgid} for update) secondkill querysecondkillforupdate(@param(skgid) long skgid); @update(value = update seckill set number=number-1 where seckill_id=#{skgid} and number > 0) int updatesecondkillbyid(@param(skgid) long skgid); @update(value = update seckill set number=number-#{number},version=version+1 where seckill_id=#{skgid} and version = #{version}) int updatesecondkillbyversion(@param(number) int number, @param(skgid) long skgid, @param(version)int version);}
乐观锁会出现大量的数据更新异常（抛异常就会导致购买失败），会出现少买的情况，不推荐使用乐观锁
3.6 方式六（阻塞队列）
利用阻塞队类，也可以解决高并发问题。其思想就是把接收到的请求按顺序存放到队列中，消费者线程逐一从队列里取数据进行处理，看下具体代码。
阻塞队列：这里使用静态内部类的方式来实现单例模式，在并发条件下不会出现问题。
// 秒杀队列(固定长度为100)public class secondkillqueue { // 队列大小 static final int queue_max_size = 100; // 用于多线程间下单的队列 static blockingqueue blockingqueue = new linkedblockingqueue(queue_max_size); // 使用静态内部类，实现单例模式 private secondkillqueue(){}; private static class singletonholder{ // 静态初始化器，由jvm来保证线程安全 private static secondkillqueue queue = new secondkillqueue(); } /** * 单例队列 * @return */ public static secondkillqueue getskillqueue(){ return singletonholder.queue; } /** * 生产入队 * @param kill * @throws interruptedexception * add(e) 队列未满时，返回true；队列满则抛出illegalstateexception(“queue full”)异常——abstractqueue * put(e) 队列未满时，直接插入没有返回值；队列满时会阻塞等待，一直等到队列未满时再插入。 * offer(e) 队列未满时，返回true；队列满时返回false。非阻塞立即返回。 * offer(e, time, unit) 设定等待的时间，如果在指定时间内还不能往队列中插入数据则返回false，插入成功返回true。 */ public boolean produce(successkilled kill) { return blockingqueue.offer(kill); } /** * 消费出队 * poll() 获取并移除队首元素，在指定的时间内去轮询队列看有没有首元素有则返回，否者超时后返回null * take() 与带超时时间的poll类似不同在于take时候如果当前队列空了它会一直等待其他线程调用notempty.signal()才会被唤醒 */ public successkilled consume() throws interruptedexception { return blockingqueue.take(); } /** * 获取队列大小 * @return */ public int size() { return blockingqueue.size(); }}
消费秒杀队列：实现applicationrunner接口
// 消费秒杀队列@slf4j@componentpublic class taskrunner implements applicationrunner{ @autowired private secondkillservice seckillservice; @override public void run(applicationarguments var){ new thread(() -> { log.info(队列启动成功); while(true){ try { // 进程内队列 successkilled kill = secondkillqueue.getskillqueue().consume(); if(kill != null){ result result = seckillservice.startsecondkillbyaop(kill.getseckillid(), kill.getuserid()); if(result != null && result.equals(result.ok(secondkillstateenum.success))){ log.info(taskrunner,result:{},result); log.info(taskrunner从消息队列取出用户，用户:{}{},kill.getuserid(),秒杀成功); } } } catch (interruptedexception e) { e.printstacktrace(); } } }).start(); }}@apioperation(value=秒杀实现方式六——消息队列)@postmapping(/start/queue)public result startqueue(long skgid){ try { log.info(开始秒杀方式六...); final long userid = (int) (new random().nextdouble() * (99999 - 10000 + 1)) + 10000; successkilled kill = new successkilled(); kill.setseckillid(skgid); kill.setuserid(userid); boolean flag = secondkillqueue.getskillqueue().produce(kill); // 虽然进入了队列，但是不一定能秒杀成功 进队出队有时间间隙 if(flag){ log.info(用户:{}{},kill.getuserid(),秒杀成功); }else{ log.info(用户:{}{},userid,秒杀失败); } } catch (exception e) { e.printstacktrace(); } return result.ok();}
注意：在业务层和aop方法中，不能抛出任何异常， throw new runtimeexception()这些抛异常代码要注释掉。因为一旦程序抛出异常就会停止，导致消费秒杀队列进程终止！
使用阻塞队列来实现秒杀，有几点要注意：
消费秒杀队列中调用业务方法加锁与不加锁情况一样，也就是seckillservice.startsecondkillbyaop()、seckillservice.startsecondkillbylock()方法结果一样，这也很好理解
当队列长度与商品数量一致时，会出现少卖的现象，可以调大数值
下面是队列长度1000，商品数量1000，并发数2000情况下出现的少卖
3.7.方式七（disruptor队列）
disruptor是个高性能队列，研发的初衷是解决内存队列的延迟问题，在性能测试中发现竟然与i/o操作处于同样的数量级，基于disruptor开发的系统单线程能支撑每秒600万订单。
// 事件生成工厂（用来初始化预分配事件对象）public class secondkilleventfactory implements eventfactory { @override public secondkillevent newinstance() { return new secondkillevent(); }}// 事件对象（秒杀事件）public class secondkillevent implements serializable { private static final long serialversionuid = 1l; private long seckillid; private long userid; // set/get方法略}// 使用translator方式生产者public class secondkilleventproducer { private final static eventtranslatorvararg translator = (seckillevent, seq, objs) -> { seckillevent.setseckillid((long) objs[0]); seckillevent.setuserid((long) objs[1]); }; private final ringbuffer ringbuffer; public secondkilleventproducer(ringbuffer ringbuffer){ this.ringbuffer = ringbuffer; } public void secondkill(long seckillid, long userid){ this.ringbuffer.publishevent(translator, seckillid, userid); }}// 消费者(秒杀处理器)@slf4jpublic class secondkilleventconsumer implements eventhandler { private secondkillservice secondkillservice = (secondkillservice) springutil.getbean(secondkillservice); @override public void onevent(secondkillevent seckillevent, long seq, boolean bool) { result result = secondkillservice.startsecondkillbyaop(seckillevent.getseckillid(), seckillevent.getuserid()); if(result.equals(result.ok(secondkillstateenum.success))){ log.info(用户:{}{},seckillevent.getuserid(),秒杀成功); } }}public class disruptorutil { static disruptor disruptor; static{ secondkilleventfactory factory = new secondkilleventfactory(); int ringbuffersize = 1024; threadfactory threadfactory = runnable -> new thread(runnable); disruptor = new disruptor(factory, ringbuffersize, threadfactory); disruptor.handleeventswith(new secondkilleventconsumer()); disruptor.start(); } public static void producer(secondkillevent kill){ ringbuffer ringbuffer = disruptor.getringbuffer(); secondkilleventproducer producer = new secondkilleventproducer(ringbuffer); producer.secondkill(kill.getseckillid(),kill.getuserid()); }}@apioperation(value=秒杀实现方式七——disruptor队列)@postmapping(/start/disruptor)public result startdisruptor(long skgid){ try { log.info(开始秒杀方式七...); final long userid = (int) (new random().nextdouble() * (99999 - 10000 + 1)) + 10000; secondkillevent kill = new secondkillevent(); kill.setseckillid(skgid); kill.setuserid(userid); disruptorutil.producer(kill); } catch (exception e) { e.printstacktrace(); } return result.ok();}
经过测试，发现使用disruptor队列队列，与自定义队列有着同样的问题，也会出现超卖的情况，但效率有所提高。
4. 小结
对于上面七种实现并发的方式，做一下总结：
一、二方式是在代码中利用锁和事务的方式解决了并发问题，主要解决的是锁要加载事务之前
三、四、五方式主要是数据库的锁来解决并发问题，方式三是利用for upate对表加行锁，方式四是利用update来对表加锁，方式五是通过增加version字段来控制数据库的更新操作，方式五的效果最差
六、七方式是通过队列来解决并发问题，这里需要特别注意的是，在代码中不能通过throw抛异常，否则消费线程会终止，而且由于进队和出队存在时间间隙，会导致商品少卖
上面所有的情况都经过代码测试，测试分一下三种情况：
并发数1000，商品数100
并发数1000，商品数1000
并发数2000，商品数1000
思考：分布式情况下如何解决并发问题呢？下次继续试验。
钢管切割设备 相贯线切割机
温湿度试验箱的操作方法-贝尔试验箱
采用MAX22191的工业数字输入
首发新品Viva机器人洗地机，享受自由生活，拥抱美好未来今日
Diodes推出专为IGBT设计的ZXGD3006E6闸极驱动器
通过秒杀商品来模拟高并发的场景
励磁涌流是怎么产生的?与哪些因素有关
iPhone SE 2曝光将采用类似iPhone 8的设计非刘海全面屏没有双摄
半导体制造工艺中的主要设备及材料【三】
双电源转换开关怎么用_双电源转换开关用途
【CES Asia 2018】汉能推出一款发电包包，论时尚论实用都秒杀LV？
以科技为支撑，赋能邢台银行战略转型
法国NGO组织以无人机试探核电站安保底线，为了表明法国的核设施缺乏安全保障措施
低压无功补偿控制电路图
见证LG产电超高压事业迈向新台阶
一文看懂ARM里的RAM和SDRAM有什么区别
AMD与微软合作研发采用AMD锐龙移动技术新一代Surface Laptop
西门子S7-1500系列PLC控制的6轴机器人系统解析
健康监测超过200万例，这款脉诊仪有何不同？
探地雷达 — 将是自动驾驶车辆传感领域的下一个创新点吗？