1000部毛片A片免费视频,奇米影视一区二区,成人视频网站在线播放,国产国产国产,美女黄网站,gogo大胆大尺寸大尺度,女女性爱视频,大香蕉亚洲成人

    
    
     
    
    
胖虎和朋友原創(chuàng)的視頻教程有興趣的可以看看：

（文末附課程大綱）

??2023 最新，Java成神之路，架構(gòu)視頻（點(diǎn)擊查看）

??超全技術(shù)棧的Java入門+進(jìn)階+實(shí)戰(zhàn)！（點(diǎn)擊查看）

高并發(fā)場景在現(xiàn)場的日常工作中很常見，特別是在互聯(lián)網(wǎng)公司中，這篇文章就來通過秒殺商品來模擬高并發(fā)的場景。

本文環(huán)境： SpringBoot 2.5.7 + MySQL 8.0 X + MybatisPlus + Swagger2.9.2
模擬工具： Jmeter
模擬場景：減庫存->創(chuàng)建訂單->模擬支付

2.商品秒殺-超賣

在開發(fā)中，對于下面的代碼，可能很熟悉：在Service里面加上@Transactional事務(wù)注解和Lock鎖。

控制層：Controller

@ApiOperation(value="秒殺實(shí)現(xiàn)方式——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();
}

業(yè)務(wù)層：Service

@Override
@Transactional(rollbackFor = Exception.class)
public Result startSecondKillByLock(long skgId, long userId) {
    lock.lock();
    try {
        // 校驗(yàn)庫存
        SecondKill secondKill = secondKillMapper.selectById(skgId);
        Integer number = secondKill.getNumber();
        if (number > 0) {
            // 扣庫存
            secondKill.setNumber(number - 1);
            secondKillMapper.updateById(secondKill);
            // 創(chuàng)建訂單
            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("異常了個(gè)乖乖");
    } finally {
        lock.unlock();
    }
    return Result.ok(SecondKillStateEnum.SUCCESS);
}

對于上面的代碼應(yīng)該沒啥問題吧，業(yè)務(wù)方法上加事務(wù)，在處理業(yè)務(wù)的時(shí)候加鎖。

但上面這樣寫法是有問題的，會(huì)出現(xiàn)超賣的情況，看下測試結(jié)果：模擬1000個(gè)并發(fā)，搶100商品。

這里在業(yè)務(wù)方法開始加了鎖，在業(yè)務(wù)方法結(jié)束后釋放了鎖。但這里的事務(wù)提交卻不是這樣的，有可能在事務(wù)提交之前，就已經(jīng)把鎖釋放了，這樣會(huì)導(dǎo)致商品超賣現(xiàn)象。所以加鎖的時(shí)機(jī)很重要！

3. 解決商品超賣

對于上面超賣現(xiàn)象，主要問題出現(xiàn)在事務(wù)中鎖釋放的時(shí)機(jī)，事務(wù)未提交之前，鎖已經(jīng)釋放。（事務(wù)提交是在整個(gè)方法執(zhí)行完）。如何解決這個(gè)問題呢，就是把加鎖步驟提前

可以在controller層進(jìn)行加鎖
可以使用Aop在業(yè)務(wù)方法執(zhí)行之前進(jìn)行加鎖

3.1 方式一（改進(jìn)版加鎖）

@ApiOperation(value="秒殺實(shí)現(xiàn)方式——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();
}

上面這樣的加鎖就可以解決事務(wù)未提交之前，鎖釋放的問題，可以分三種情況進(jìn)行壓力測試：

并發(fā)數(shù)1000，商品100
并發(fā)數(shù)1000，商品1000
并發(fā)數(shù)2000，商品1000

對于并發(fā)量大于商品數(shù)的情況，商品秒殺一般不會(huì)出現(xiàn)少賣的請況，但對于并發(fā)數(shù)小于等于商品數(shù)的時(shí)候可能會(huì)出現(xiàn)商品少賣情況，這也很好理解。

對于沒有問題的情況就不貼圖了，因?yàn)橛泻芏喾N方式，貼圖會(huì)太多

3.2 方式二（AOP版加鎖）

對于上面在控制層進(jìn)行加鎖的方式，可能顯得不優(yōu)雅，那就還有另一種方式進(jìn)行在事務(wù)之前加鎖，那就是AOP

自定義AOP注解

@Target({ElementType.PARAMETER, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public  @interface ServiceLock {
    String description()  default "";
}

定義切面類

@Slf4j
@Component
@Scope
@Aspect
@Order(1) //order越小越是最先執(zhí)行，但更重要的是最先執(zhí)行的最后結(jié)束
public class LockAspect {
    /**
     * 思考：為什么不用synchronized
     * service 默認(rèn)是單例的，并發(fā)下lock只有一個(gè)實(shí)例
     */
    private static  Lock lock = new ReentrantLock(true); // 互斥鎖 參數(shù)默認(rèn)false，不公平鎖

    // Service層切點(diǎn)     用于記錄錯(cuò)誤日志
    @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;
    }
}

在業(yè)務(wù)方法上添加AOP注解

@Override
@ServiceLock // 使用Aop進(jìn)行加鎖
@Transactional(rollbackFor = Exception.class)
public Result startSecondKillByAop(long skgId, long userId) {

    try {
        // 校驗(yàn)庫存
        SecondKill secondKill = secondKillMapper.selectById(skgId);
        Integer number = secondKill.getNumber();
        if (number > 0) {
            //扣庫存
            secondKill.setNumber(number - 1);
            secondKillMapper.updateById(secondKill);
            //創(chuàng)建訂單
            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("異常了個(gè)乖乖");
    }
    return Result.ok(SecondKillStateEnum.SUCCESS);
}

控制層：

@ApiOperation(value="秒殺實(shí)現(xiàn)方式二——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 方式三（悲觀鎖一）

除了上面在業(yè)務(wù)代碼層面加鎖外，還可以使用數(shù)據(jù)庫自帶的鎖進(jìn)行并發(fā)控制。

悲觀鎖，什么是悲觀鎖呢？通俗的說，在做任何事情之前，都要進(jìn)行加鎖確認(rèn)。這種數(shù)據(jù)庫級(jí)加鎖操作效率較低。

使用for update一定要加上事務(wù)，當(dāng)事務(wù)處理完后，for update才會(huì)將行級(jí)鎖解除

如果請求數(shù)和秒殺商品數(shù)量一致，會(huì)出現(xiàn)少賣

@ApiOperation(value="秒殺實(shí)現(xiàn)方式三——悲觀鎖")
@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();
}

業(yè)務(wù)邏輯

@Override
@Transactional(rollbackFor = Exception.class)
public Result startSecondKillByUpdate(long skgId, long userId) {
    try {
        // 校驗(yàn)庫存-悲觀鎖
        SecondKill secondKill = secondKillMapper.querySecondKillForUpdate(skgId);
        Integer number = secondKill.getNumber();
        if (number > 0) {
            //扣庫存
            secondKill.setNumber(number - 1);
            secondKillMapper.updateById(secondKill);
            //創(chuàng)建訂單
            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("異常了個(gè)乖乖");
    } finally {
    }
    return Result.ok(SecondKillStateEnum.SUCCESS);
}

Dao層

@Repository
public interface SecondKillMapper extends BaseMapper<SecondKill> {

    /**
     * 將此行數(shù)據(jù)進(jìn)行加鎖，當(dāng)整個(gè)方法將事務(wù)提交后，才會(huì)解鎖
     * @param skgId
     * @return
     */
    @Select(value = "SELECT * FROM seckill WHERE seckill_id=#{skgId} FOR UPDATE")
    SecondKill querySecondKillForUpdate(@Param("skgId") Long skgId);

}

上面是利用for update進(jìn)行對查詢數(shù)據(jù)加鎖，加的是行鎖。

3.4 方式四（悲觀鎖二）

悲觀鎖的第二種方式就是利用update更新命令來加表鎖

/**
 * UPDATE鎖表
 * @param skgId  商品id
 * @param userId    用戶id
 * @return
 */
@Override
@Transactional(rollbackFor = Exception.class)
public Result startSecondKillByUpdateTwo(long skgId, long userId) {
    try {

        // 不校驗(yàn)，直接扣庫存更新
        int result = secondKillMapper.updateSecondKillById(skgId);
        if (result > 0) {
            //創(chuàng)建訂單
            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("異常了個(gè)乖乖");
    } finally {
    }
    return Result.ok(SecondKillStateEnum.SUCCESS);
}

Dao層

@Repository
public interface SecondKillMapper extends BaseMapper<SecondKill> {

    /**
     * 將此行數(shù)據(jù)進(jìn)行加鎖，當(dāng)整個(gè)方法將事務(wù)提交后，才會(huì)解鎖
     * @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 方式五（樂觀鎖）

樂觀鎖，顧名思義，就是對操作結(jié)果很樂觀，通過利用version字段來判斷數(shù)據(jù)是否被修改。

樂觀鎖，不進(jìn)行庫存數(shù)量的校驗(yàn)，直接做庫存扣減。

這里使用的樂觀鎖會(huì)出現(xiàn)大量的數(shù)據(jù)更新異常（拋異常就會(huì)導(dǎo)致購買失敗）、如果配置的搶購人數(shù)比較少、比如120:100(人數(shù):商品) 會(huì)出現(xiàn)少買的情況，不推薦使用樂觀鎖。

@ApiOperation(value="秒殺實(shí)現(xiàn)方式五——樂觀鎖")
@PostMapping("/start/opt/lock")
public Result startOptLock(long skgId){
    try {
        log.info("開始秒殺方式五...");
        final long userId = (int) (new Random().nextDouble() * (99999 - 10000 + 1)) + 10000;
        // 參數(shù)添加了購買數(shù)量
        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) {

    // 樂觀鎖，不進(jìn)行庫存數(shù)量的校驗(yàn)，直接
    try {
        SecondKill kill = secondKillMapper.selectById(skgId);
        // 剩余的數(shù)量應(yīng)該要大于等于秒殺的數(shù)量
        if(kill.getNumber() >= number) {
            int result = secondKillMapper.updateSecondKillByVersion(number,skgId,kill.getVersion());
            if (result > 0) {
                //創(chuàng)建訂單
                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("異常了個(gè)乖乖");
    } finally {
    }
    return Result.ok(SecondKillStateEnum.SUCCESS);
}
@Repository
public interface SecondKillMapper extends BaseMapper<SecondKill> {

    /**
     * 將此行數(shù)據(jù)進(jìn)行加鎖，當(dāng)整個(gè)方法將事務(wù)提交后，才會(huì)解鎖
     * @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);
}

樂觀鎖會(huì)出現(xiàn)大量的數(shù)據(jù)更新異常（拋異常就會(huì)導(dǎo)致購買失?。瑫?huì)出現(xiàn)少買的情況，不推薦使用樂觀鎖。

3.6 方式六（阻塞隊(duì)列）

利用阻塞隊(duì)類，也可以解決高并發(fā)問題。其思想就是把接收到的請求按順序存放到隊(duì)列中，消費(fèi)者線程逐一從隊(duì)列里取數(shù)據(jù)進(jìn)行處理，看下具體代碼。

阻塞隊(duì)列：這里使用靜態(tài)內(nèi)部類的方式來實(shí)現(xiàn)單例模式，在并發(fā)條件下不會(huì)出現(xiàn)問題。

// 秒殺隊(duì)列(固定長度為100)
public class SecondKillQueue {

    // 隊(duì)列大小
    static final int QUEUE_MAX_SIZE = 100;

    // 用于多線程間下單的隊(duì)列
    static BlockingQueue<SuccessKilled> blockingQueue = new LinkedBlockingQueue<SuccessKilled>(QUEUE_MAX_SIZE);

    // 使用靜態(tài)內(nèi)部類，實(shí)現(xiàn)單例模式
    private SecondKillQueue(){};

    private static class SingletonHolder{
        // 靜態(tài)初始化器，由JVM來保證線程安全
        private  static SecondKillQueue queue = new SecondKillQueue();
    }

    /**
     * 單例隊(duì)列
     * @return
     */
    public static SecondKillQueue getSkillQueue(){
        return SingletonHolder.queue;
    }

    /**
     * 生產(chǎn)入隊(duì)
     * @param kill
     * @throws InterruptedException
     * add(e) 隊(duì)列未滿時(shí)，返回true；隊(duì)列滿則拋出IllegalStateException(“Queue full”)異常——AbstractQueue
     * put(e) 隊(duì)列未滿時(shí)，直接插入沒有返回值；隊(duì)列滿時(shí)會(huì)阻塞等待，一直等到隊(duì)列未滿時(shí)再插入。
     * offer(e) 隊(duì)列未滿時(shí)，返回true；隊(duì)列滿時(shí)返回false。非阻塞立即返回。
     * offer(e, time, unit) 設(shè)定等待的時(shí)間，如果在指定時(shí)間內(nèi)還不能往隊(duì)列中插入數(shù)據(jù)則返回false，插入成功返回true。
     */
    public  Boolean  produce(SuccessKilled kill) {
        return blockingQueue.offer(kill);
    }
    /**
     * 消費(fèi)出隊(duì)
     * poll() 獲取并移除隊(duì)首元素，在指定的時(shí)間內(nèi)去輪詢隊(duì)列看有沒有首元素有則返回，否者超時(shí)后返回null
     * take() 與帶超時(shí)時(shí)間的poll類似不同在于take時(shí)候如果當(dāng)前隊(duì)列空了它會(huì)一直等待其他線程調(diào)用notEmpty.signal()才會(huì)被喚醒
     */
    public  SuccessKilled consume() throws InterruptedException {
        return blockingQueue.take();
    }

    /**
     * 獲取隊(duì)列大小
     * @return
     */
    public int size() {
        return blockingQueue.size();
    }
}

消費(fèi)秒殺隊(duì)列：實(shí)現(xiàn)ApplicationRunner接口

// 消費(fèi)秒殺隊(duì)列
@Slf4j
@Component
public class TaskRunner implements ApplicationRunner{

    @Autowired
    private SecondKillService seckillService;

    @Override
    public void run(ApplicationArguments var){
        new Thread(() -> {
            log.info("隊(duì)列啟動(dòng)成功");
            while(true){
                try {
                    // 進(jìn)程內(nèi)隊(duì)列
                    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從消息隊(duì)列取出用戶，用戶:{}{}",kill.getUserId(),"秒殺成功");
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}
@ApiOperation(value="秒殺實(shí)現(xiàn)方式六——消息隊(duì)列")
@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);
        // 雖然進(jìn)入了隊(duì)列，但是不一定能秒殺成功 進(jìn)隊(duì)出隊(duì)有時(shí)間間隙
        if(flag){
            log.info("用戶:{}{}",kill.getUserId(),"秒殺成功");
        }else{
            log.info("用戶:{}{}",userId,"秒殺失敗");
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    return Result.ok();
}

注意：在業(yè)務(wù)層和AOP方法中，不能拋出任何異常， throw new RuntimeException()這些拋異常代碼要注釋掉。因?yàn)橐坏┏绦驋伋霎惓＞蜁?huì)停止，導(dǎo)致消費(fèi)秒殺隊(duì)列進(jìn)程終止！

使用阻塞隊(duì)列來實(shí)現(xiàn)秒殺，有幾點(diǎn)要注意：

消費(fèi)秒殺隊(duì)列中調(diào)用業(yè)務(wù)方法加鎖與不加鎖情況一樣，也就是seckillService.startSecondKillByAop()、seckillService.startSecondKillByLock()方法結(jié)果一樣，這也很好理解
當(dāng)隊(duì)列長度與商品數(shù)量一致時(shí)，會(huì)出現(xiàn)少賣的現(xiàn)象，可以調(diào)大數(shù)值
下面是隊(duì)列長度1000，商品數(shù)量1000，并發(fā)數(shù)2000情況下出現(xiàn)的少賣

3.7.方式七（Disruptor隊(duì)列）

Disruptor是個(gè)高性能隊(duì)列，研發(fā)的初衷是解決內(nèi)存隊(duì)列的延遲問題，在性能測試中發(fā)現(xiàn)竟然與I/O操作處于同樣的數(shù)量級(jí)，基于Disruptor開發(fā)的系統(tǒng)單線程能支撐每秒600萬訂單。

// 事件生成工廠（用來初始化預(yù)分配事件對象）
public class SecondKillEventFactory implements EventFactory<SecondKillEvent> {

    @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方式生產(chǎn)者
public class SecondKillEventProducer {

    private final static EventTranslatorVararg<SecondKillEvent> translator = (seckillEvent, seq, objs) -> {
        seckillEvent.setSeckillId((Long) objs[0]);
        seckillEvent.setUserId((Long) objs[1]);
    };

    private final RingBuffer<SecondKillEvent> ringBuffer;

    public SecondKillEventProducer(RingBuffer<SecondKillEvent> ringBuffer){
        this.ringBuffer = ringBuffer;
    }

    public void secondKill(long seckillId, long userId){
        this.ringBuffer.publishEvent(translator, seckillId, userId);
    }
}
// 消費(fèi)者(秒殺處理器)
@Slf4j
public class SecondKillEventConsumer implements EventHandler<SecondKillEvent> {

    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<SecondKillEvent> 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<SecondKillEvent> ringBuffer = disruptor.getRingBuffer();
        SecondKillEventProducer producer = new SecondKillEventProducer(ringBuffer);
        producer.secondKill(kill.getSeckillId(),kill.getUserId());
    }
}
@ApiOperation(value="秒殺實(shí)現(xiàn)方式七——Disruptor隊(duì)列")
@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();
}

經(jīng)過測試，發(fā)現(xiàn)使用Disruptor隊(duì)列隊(duì)列，與自定義隊(duì)列有著同樣的問題，也會(huì)出現(xiàn)超賣的情況，但效率有所提高。

4. 小結(jié)

對于上面七種實(shí)現(xiàn)并發(fā)的方式，做一下總結(jié)：

一、二方式是在代碼中利用鎖和事務(wù)的方式解決了并發(fā)問題，主要解決的是鎖要加載事務(wù)之前
三、四、五方式主要是數(shù)據(jù)庫的鎖來解決并發(fā)問題，方式三是利用for upate對表加行鎖，方式四是利用update來對表加鎖，方式五是通過增加version字段來控制數(shù)據(jù)庫的更新操作，方式五的效果最差
六、七方式是通過隊(duì)列來解決并發(fā)問題，這里需要特別注意的是，在代碼中不能通過throw拋異常，否則消費(fèi)線程會(huì)終止，而且由于進(jìn)隊(duì)和出隊(duì)存在時(shí)間間隙，會(huì)導(dǎo)致商品少賣

原文：https://blog.csdn.net/zxd1435513775/article/details/122643285

      
      
       
       
        
        
         
         
          
          
         
         
        
        
       
       
      
      
     
     
      
      
       
       胖虎聯(lián)合兩位大佬朋友，一位是知名培訓(xùn)機(jī)構(gòu)講師和科大訊飛架構(gòu)，聯(lián)合打造了《Java架構(gòu)師成長之路》的視頻教程。完全對標(biāo)外面2萬左右的培訓(xùn)課程。
       
       除了基本的視頻教程之外，還提供了超詳細(xì)的課堂筆記，以及源碼等資料包..
       
       

       
       課程階段：
       
       
        
        
         
         
          
          Java核心 提升閱讀源碼的內(nèi)功心法
         
         
        
        
         
         
          
          深入講解企業(yè)開發(fā)必備技術(shù)棧，夯實(shí)基礎(chǔ)，為跳槽加薪增加籌碼
          
          

         
         
        
        
         
         
          
          分布式架構(gòu)設(shè)計(jì)方法論。為學(xué)習(xí)分布式微服務(wù)做鋪墊
         
         
        
        
         
         
          
          學(xué)習(xí)NetFilx公司產(chǎn)品，如Eureka、Hystrix、Zuul、Feign、Ribbon等，以及學(xué)習(xí)Spring Cloud Alibabba體系
         
         
        
        
         
         
          
          微服務(wù)架構(gòu)下的性能優(yōu)化
         
         
        
        
         
         
          
          中間件源碼剖析
         
         
        
        
         
         
          
          元原生以及虛擬化技術(shù)
         
         
        
        
         
         
          
          從0開始，項(xiàng)目實(shí)戰(zhàn) SpringCloud Alibaba電商項(xiàng)目
          
          

         
         
       
       
       
       
        
        
         
         
          
          點(diǎn)擊下方超鏈接查看詳情（或者點(diǎn)擊文末閱讀原文）：
          
          (點(diǎn)擊查看)  2023年，最新Java架構(gòu)師成長之路 視頻教程！
          
          以下是課程大綱，大家可以雙擊打開原圖查看

大廠防止超賣的7種實(shí)現(xiàn)，很受用！