經過請求隊列的方式來緩解高併發搶購（初探）

經過請求隊列的方式來緩解高併發搶購（初探）

 

1、背景

       在移動互聯網高速發展的時代，各類電商平臺的搶購業務變得愈來愈火爆，搶購業務所帶來的高併發問題值得咱們去探索，主要涉及的方面包括處理和響應速度、數據的一致性等。搶購開放的一瞬間，可能有成千上萬的下訂單請求發送到服務器去處理，若是隻是簡單的請求處理響應方式，不作任何處理，致使的結果極可能是不少客戶很長時間得不到響應，根本不知道本身是否下訂單成功，或者下訂單的數量已經超過了商品的數量，這就致使了超發的問題。

2、設計思路

      一、用戶在下訂單以前固然是先查詢到這個商品，在這個查詢的時候，將數據庫中商品的剩餘數量存到redis中；

      二、服務器在一瞬間接到成千上萬的下訂單請求，在控制層沒有直接處理請求數據，而是先根據redis中商品的剩餘數量來判斷，若是>0,就將請求放到請求隊列中，不然直接響

           應客戶端「賣完了」；

      三、考慮到數據的一致性，隊列的容量就是商品的剩餘數量，隊列採用的是線程安全的隊列LinkedBlockingQueue(單臺服務器),而後經過新的線程異步處理這些請求，多臺服務器的話,能夠考慮使用消息隊列MQ,單獨用一臺服務器去處理消息隊列中的請求;

     四、客戶端發送訂單請求以後，會收到響應，要麼是剩餘數量不足（賣完了），要麼是請求已經被放到隊列中,爲下一步的輪詢訂單作準備;

     五、若是響應狀態是賣完了，直接提示客戶，若是請求已經放入隊列中，就能夠根據用戶id和商品id去輪詢訂單了；

3、實現步驟

      說明：用java語言，springmvc框架+redis實現

    一、準備工做，查詢商品信息，將剩餘數量同步到redis中

         Jedis jedis = jedisPool.getResource();
         BuyGood good=buyGoodService.getById(good_id);
        jedis.set("residue"+good_id, good.getResidue()+"");
        jedisPool.returnResource(jedis);

  二、下訂單的方法,下面直接展現代碼，包括請求對象，控制層方法，請求處理線程類的具體實現

     2.1 請求封裝對象

public class BuyRequest {
    private int good_id;//商品id
    private int user_id;//用戶ID
    private int order_id;//訂單id
    private BuyOrders buyOrders;//訂單信息
    private int response_status;//0:未處理;1:正常;2:異常
    
    public BuyOrders getBuyOrders() {
        return buyOrders;
    }

    public void setBuyOrders(BuyOrders buyOrders) {
        this.buyOrders = buyOrders;
    }


    public int getGood_id() {
        return good_id;
    }

    public void setGood_id(int good_id) {
        this.good_id = good_id;
    }

    public int getOrder_id() {
        return order_id;
    }

    public void setOrder_id(int order_id) {
        this.order_id = order_id;
    }

    public int getResponse_status() {
        return response_status;
    }

    public void setResponse_status(int response_status) {
        this.response_status = response_status;
    }

    public int getUser_id() {
        return user_id;
    }

    public void setUser_id(int user_id) {
        this.user_id = user_id;
    }
}

2.2 處理請求的controller

@Controller
@RequestMapping("/buy")
public class BuyController {
    
    private static BuyQueue<BuyRequest> buyqueue =null;//線程安全的請求隊列

@RequestMapping("/addOrders.do")
    @ResponseBody
    public Object addOrders(BuyRequest buyrequest){
        Map<String, Object> results = new HashMap<>();
        Jedis jedis = jedisPool.getResource();
        try {
            //下訂單以前，先獲取商品的剩餘數量
        int residue = Integer.valueOf(jedis.get("residue"+buyrequest.getGood_id()));
        if(residue<1){//若是剩餘數量不足，直接響應客戶端「賣完了」
            results.put("msg", "賣完了");
            results.put("done", false);
            BaseLog.info("addOrders results="+JSON.toJSONString(results));
            return results;
        }
        //若是還有剩餘商品,就準備將請求放到請求隊列中
        if(buyqueue==null){//第一次初始化請求隊列,隊列的容量爲當前的商品剩餘數量
            buyqueue=new BuyQueue<BuyRequest>(residue);
            }
        if(buyqueue.remainingCapacity()>0){//當隊列的可用容量大於0時,將請求放到請求隊列中
            buyqueue.put(buyrequest);
        }else{//當請求隊列已滿,本次請求不能處理,直接響應客戶端提示請求隊列已滿
            results.put("msg", "搶購隊列已滿，請稍候重試！");
            results.put("done", false);
            return results;
        }
            
        if(!DealQueueThread.excute){//若是線程類的當前執行標誌爲未執行,即空閒狀態,經過線程池啓動線程
        DealQueueThread dealQueue = new DealQueueThread(buyqueue);
        ThreadPoolUtil.pool.execute(dealQueue);
        BaseLog.info("Thread.activeCount()="+Thread.activeCount());
        }
       //請求放入到隊列中，即完成下單請求
            results.put("done", true);
            results.put("msg", "下訂單成功");
      
        } catch (Exception e) {
            results.put("done", false);
            results.put("msg", "下單失敗");
            BaseLog.info("addOrders results="+JSON.toJSONString(results));
            BaseLog.error("addOrders",e);
        }finally{
            jedisPool.returnResource(jedis);
        }
        return results;
    }

}

2.3 處理請求的線程類，線程類中涉及到的service代碼就沒必要寫出來了，你懂的

@Component
public class DealQueueThread implements Runnable {

    private static DealQueueThread dealQueueThread;
    @Autowired
    BuyGoodService buyGoodService;
    @Autowired
    BuyOrdersService buyOrdersService;
    @Autowired
    JedisPool jedisPool;

    private Jedis jedis;

    private BuyQueue<BuyRequest> buyqueue;

    public static boolean excute = false;//線程的默認執行標誌爲未執行,即空閒狀態

    public DealQueueThread() {

    }

    public DealQueueThread(BuyQueue<BuyRequest> buyqueue) {
        this.buyqueue = buyqueue;
        jedis = dealQueueThread.jedisPool.getResource();
    }

    @PostConstruct
    public void init() {
        dealQueueThread = this;
        dealQueueThread.buyGoodService = this.buyGoodService;
        dealQueueThread.buyOrdersService = this.buyOrdersService;
        dealQueueThread.jedisPool = this.jedisPool;
    }

    @Override
    public void run() {
        try {
            excute = true;//修改線程的默認執行標誌爲執行狀態
            //開始處理請求隊列中的請求,按照隊列的FIFO的規則,先處理先放入到隊列中的請求
            while (buyqueue != null && buyqueue.size() > 0) {
                BuyRequest buyreq = buyqueue.take();//取出隊列中的請求
                dealWithQueue(buyreq);//處理請求
            }
        } catch (InterruptedException e) {
            BaseLog.error("DealQueueThread:", e);
        } finally {
            excute = false;
        }
    }

    public synchronized void dealWithQueue(BuyRequest buyreq) {
        try {
            //爲了儘可能確保數據的一致性,處理以前先從redis中獲取當前搶購商品的剩餘數量
            int residue = Integer.valueOf(jedis.get("residue" + buyreq.getGood_id()));
            if (residue < 1) {//若是沒有剩餘商品,就直接返回
                buyreq.setResponse_status(3);
                return;
            }
            //若是有剩餘商品,先在redis中將剩餘數量減一,再開始下訂單
            jedis.decr("residue" + buyreq.getGood_id());
            //將數據庫中將剩餘數量減一,這一步處理能夠在隊列處理完成以後一次性更新剩餘數量
            dealQueueThread.buyGoodService.minusResidue(buyreq.getGood_id());

            //處理請求,下訂單
            BuyOrders bo = new BuyOrders();
            bo.setGood_id(buyreq.getGood_id());
            bo.setUser_id(buyreq.getUser_id());
            int order_id = dealQueueThread.buyOrdersService.insert(bo);
            BuyOrders orders = dealQueueThread.buyOrdersService.getById(order_id);
            buyreq.setOrder_id(order_id);//訂單id
            buyreq.setBuyOrders(orders);//訂單信息
            buyreq.setResponse_status(1);//處理完成狀態
        } catch (Exception e) {
            buyreq.setResponse_status(2);//異常狀態
            BaseLog.error("DealQueueThread dealWithQueue:", e);
        }
    }

}

三、輪詢訂單

思路：查詢訂單和剩餘數量，有如下三種狀況：

1）查到訂單，直接跳轉到確認訂單並支付的頁面完成支付；

2）尚未查詢到訂單，可是剩餘數量大於0，說明請求還在隊列中，繼續輪詢；

3）沒有查到訂單，剩餘數量等於或小於0，說明搶購失敗了，直接響應客戶搶購失敗；

通過測試在併發量超過五百的時候會出現超發現象，程序還有待完善，歡迎你們給出本身的看法，謝謝！