短影片直播系統，實現高併發秒殺的多種方式

方式一（改進版加鎖）

@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();
}

方式二（AOP版加鎖）

自定義AOP註解

@Target({ElementType.PARAMETER, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public  @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();
}

方式三（悲觀鎖一）

@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層

@Repository
public interface SecondKillMapper extends BaseMapper<SecondKill> {

    /**
     * 將此行資料進行加鎖，當整個方法將事務提交後，才會解鎖
     * @param skgId
     * @return
     */
    @Select(value = "SELECT * FROM seckill WHERE seckill_id=#{skgId} FOR UPDATE")
    SecondKill querySecondKillForUpdate(@Param("skgId") Long skgId);

}

方式四（悲觀鎖二）

/**
 * 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層

@Repository
public interface SecondKillMapper extends BaseMapper<SecondKill> {

    /**
     * 將此行資料進行加鎖，當整個方法將事務提交後，才會解鎖
     * @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);
}

方式五（樂觀鎖）

@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);
}
@Repository
public interface SecondKillMapper extends BaseMapper<SecondKill> {

    /**
     * 將此行資料進行加鎖，當整個方法將事務提交後，才會解鎖
     * @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);
}

方式六（阻塞佇列）

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

    // 佇列大小
    static final int QUEUE_MAX_SIZE = 100;

    // 用於多執行緒間下單的佇列
    static BlockingQueue<SuccessKilled> blockingQueue = new LinkedBlockingQueue<SuccessKilled>(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
@Component
public 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();
}

方式七（Disruptor佇列）

// 事件生成工廠（用來初始化預分配事件物件）
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方式生產者
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);
    }
}
// 消費者(秒殺處理器)
@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="秒殺實現方式七——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();
}

以上就是短影片直播系統，實現高併發秒殺的多種方式， 更多內容歡迎關注之後的文章