1、任何的高併發，請求總是會有一個順序的

2、java的佇列的資料結構是先進先出的取值順序

3、BlockingQueue類(執行緒安全)（使用方法可以百度）

一般使用LinkedBlockingQueue

利用以上幾點，我們可以把高併發時候的請求放入一個佇列，佇列的大小可以自己定義，比如佇列容量為1000個數據，那麼可以利用過濾器或者攔截器把當前的請求放入佇列，如果佇列的容量滿了，其餘的請求可以丟掉或者作出相應回覆

具體實施：

利用生產者、消費者模型：

將佇列的請求一一處理完。

上程式碼：

/**
 * @author fuguangli
 * @description 前沿消費者類
 * @Create date:    2017/3/7
 * @using   EXAMPLE
 */
public class Customer implements Runnable{


    /**
     *         丟擲異常    特殊值        阻塞         超時
     插入    add(e)    offer(e)    put(e)    offer(e, time, unit)
     移除    remove()    poll()    take()    poll(time, unit)
     檢查    element()    peek()    不可用    不可用

     */
    private BlockingQueue blockingQueue;
    private AtomicInteger count = new AtomicInteger();
    public Customer(BlockingQueue blockingQueue) {
        this.blockingQueue = blockingQueue;
    }

    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p/>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see Thread#run()
     */
    @Override
    public void run() {
        System.out.println("消費者執行緒啟動...");
        LockFlag.setCustomerRunningFlag(true);
        try {
            while (LockFlag.getProducerRunningFlag()){
                System.out.println(Thread.currentThread().getId()+"I'm Customer.Queue current size="+blockingQueue.size());
                String data = (String) blockingQueue.poll(10, TimeUnit.SECONDS);
                if(data!=null){
                    System.out.println(Thread.currentThread().getId()+"*************正在消費資料 data="+data);
                }else{
                    //表示超過取值時間，視為生產者不再生產資料
                    System.out.println(Thread.currentThread().getId()+"佇列為空無資料，請檢查生產者是否阻塞");
                }
                Thread.sleep(50);
            }
            System.err.println("消費者程式執行完畢");
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.err.println("消費者程式退出");
            LockFlag.setCustomerRunningFlag(false);//異常退出執行緒
            Thread.currentThread().interrupt();
        }
    }
}
 

package com.qysxy.framework.queue;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author fuguangli
 * @description 佇列生產者類
 * @Create date:    2017/3/7
 * @using       EXAMPLE
 */
public class Producer implements Runnable{


    /**
     *         丟擲異常    特殊值        阻塞         超時
     插入    add(e)    offer(e)    put(e)    offer(e, time, unit)
     移除    remove()    poll()    take()    poll(time, unit)
     檢查    element()    peek()    不可用    不可用

     */
    private BlockingQueue blockingQueue;
    private AtomicInteger count = new AtomicInteger();
    public Producer(BlockingQueue blockingQueue) {
        this.blockingQueue = blockingQueue;
    }

    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p/>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see Thread#run()
     */
    @Override
    public void run() {
        System.out.println("生產者執行緒啟動...");
        LockFlag.setProducerRunningFlag(true);
        try {
            while (LockFlag.getProducerRunningFlag()){
                String data = "data:"+count.incrementAndGet();
                if(blockingQueue.offer(data,10, TimeUnit.SECONDS)){
                    //返回true表示生產資料正確
                    System.out.println("^^^^^^^^^^^^^^正在生產資料 data="+data);
                }else {
                    //表示阻塞時間內還沒有生產者生產資料
                    System.out.println("生產者異常，無法生產資料");
                }
                Thread.sleep(50);

            }
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.err.println("生產者程式退出");
            LockFlag.setProducerRunningFlag(false);//異常退出執行緒
            Thread.currentThread().interrupt();
        }
    }
}
 

package com.qysxy.framework.queue;

/**
 * @author fuguangli
 * @description 前沿生產者消費者模型的鎖類
 * @Create date:    2017/3/7
 */
public class LockFlag {
    /**
     * 生產者互斥鎖
     */
    private static Boolean producerRunningFlag = false;
    /**
     * 消費者互斥鎖
     */
    private static Boolean customerRunningFlag = false;

    public static Boolean getProducerRunningFlag() {
        return producerRunningFlag;
    }

    public static void setProducerRunningFlag(Boolean producerRunningFlag) {
        LockFlag.producerRunningFlag = producerRunningFlag;
    }

    public static Boolean getCustomerRunningFlag() {
        return customerRunningFlag;
    }

    public static void setCustomerRunningFlag(Boolean customerRunningFlag) {
        LockFlag.customerRunningFlag = customerRunningFlag;
    }
}
 

package com.qysxy.framework.queue;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Queue;
import java.util.concurrent.*;

/**
 * @author fuguangli
 * @description 前沿佇列實用類，用於大量併發使用者
 * @Create date:    2017/3/7
 */
public class BlockingQueueHelper {


    private static final Integer maxQueueSize = 1000;
    private static BlockingQueue blockingQueue = new LinkedBlockingQueue(maxQueueSize);
    private static ExecutorService threadPool = Executors.newCachedThreadPool();


    public static BlockingQueue getBlockingQueue() {
        if (blockingQueue == null) {
            blockingQueue = new LinkedBlockingQueue(maxQueueSize);
        }
        return blockingQueue;
    }

    /**
     * @param o 佇列處理物件（包含request,response,data）
     */
    public static void requestQueue(Object o) {
        //檢測當前的佇列大小
        if (blockingQueue != null && blockingQueue.size() < maxQueueSize) {
            //可以正常進入佇列
            if (blockingQueue.offer(o)) {
                //新增成功，檢測資料處理執行緒是否正常
                if (LockFlag.getCustomerRunningFlag()) {
                    //說明處理執行緒類正常執行
                } else {
                    //說明處理執行緒類停止，此時，應重新啟動執行緒進行資料處理
                    LockFlag.setCustomerRunningFlag(true);

                    //example:run
                    Customer customer = new Customer(blockingQueue);
                    threadPool.execute(customer);

                }

            } else {
                //進入佇列失敗，做出相應的處理，或者嘗試重新進入佇列

            }
        } else {
            //佇列不正常，或佇列大小已達上限，做出相應處理

        }

    }
}

好了，這時候，利用過濾器或者攔截器將每個請求封裝成佇列元素進行處理就行。

當然了，對於多應用伺服器的部署架構來說，資料庫也需要加鎖，資料庫隔離級別另說。