內存隊列+線程池實現異步處理

ThreadPoolManagers接口

/**
 * 線程池管理
 * @ClassName ThreadPoolManagers
 * @Author dlh
 * @Date 2019/6/27 0027 下午 4:44
 * @Version 1.0
 **/
public interface ThreadPoolManagers<T> {

    /**
     * 任務提交執行
     * @param commonService
     * @param message
     */
    void execute(T commonService, String message);
    /**
     * 最大隊列容量
     */
    int getMaxThreadQueueSize();
    /**
     * 核心容量
     */
    int getCorePoolSize();
    /**
     * 最大容量
     */
    int getMaxPoolSize();
    /**
     * 存活時間
     */
    int getKeepAliveTime();
    /**
     * 最大緩存隊列容量
     */
    int getMaxCacheQueueSize();
    /**
     * 標識
     */
    boolean getOffline();
}

ThreadPoolManagersImpl實現類

/**
 * @ClassName ThreadPoolManagersImpl
 * @Author dlh
 * @Date 2019/6/26 0026 下午 6:00
 * @Version 1.0
 **/

public class ThreadPoolManagersImpl<T> implements ThreadPoolManagers<T> {

    private static final Logger logger = LoggerFactory.getLogger(ThreadPoolManagersImpl.class);

    /**
     * 緩存隊列
     */
    private volatile LinkedBlockingQueue<Runnable> cacheLinkedQueue;
    /**
     * 最大隊列容量
     */
    private final int MAX_THREAD_QUEUE_SIZE = 1000;
    /**
     * 核心容量
     */
    private final int CORE_POOL_SIZE = 20;
    /**
     * 最大容量
     */
    private final int MAX_POOL_SIZE = 40;
    /**
     * 存活時間
     */
    private final int KEEP_ALIVE_TIME = 0;
    /**
     * 最大緩存隊列容量
     */
    private final int MAX_CACHE_QUEUE_SIZE = 10000;
    /**
     * 線程池
     */
    private volatile ThreadPoolExecutor threadPoolExecutor;
    /**
     * 標識
     */
    private volatile static boolean offline = false;

    private static final ReentrantReadWriteLock REENTRANT_READ_WRITE_LOCK = new ReentrantReadWriteLock();
    private static final ReentrantReadWriteLock.ReadLock readLock = REENTRANT_READ_WRITE_LOCK.readLock();
    private static final ReentrantReadWriteLock.WriteLock writeLock = REENTRANT_READ_WRITE_LOCK.writeLock();

    public ThreadPoolManagersImpl() {
        getCacheQueue();
        getExecutorService();
    }

    @Override
    public void execute(T commonService, String message){
        int size = getExecutorService().getQueue().size();
        logger.info("線程池queue,隊列size :" + size);
        if (offline){
            addQueue((CommonService) commonService,message);
            logger.info("緩存,隊列開始緩存,size:{} " , cacheLinkedQueue.size());
            if(size == 0){
                logger.info("開始恢復");
                new OfflineResumeThread().start();
            }
            return;
        }
        if (size >= MAX_THREAD_QUEUE_SIZE){
            setOffline(true);
            return;
        }
        getExecutorService().submit(addTask((CommonService)commonService,message));
    }

    private void addQueue(CommonService commonService,String message){
        try {
            writeLock.lock();
            getCacheQueue().add(addTask(commonService,message));
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            writeLock.unlock();
        }
    }

    /**
     * 生成任務
     * @param commonService
     * @param message
     * @return
     */
    private Runnable addTask(CommonService commonService,String message){
        Runnable runnable = null;
        try {
            writeLock.lock();
            runnable = new Runnable(){
                @Override
                public void run() {
                    commonService.process(message);
                }
            };
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            writeLock.unlock();
            return runnable;
        }
    }


    private ThreadPoolExecutor getExecutorService(){
        if (threadPoolExecutor == null){
            synchronized (ThreadPoolManagersImpl.class){
                if (threadPoolExecutor == null){
                    threadPoolExecutor = new ThreadPoolExecutor(
                            CORE_POOL_SIZE
                            , MAX_POOL_SIZE
                            , KEEP_ALIVE_TIME
                            , TimeUnit.MILLISECONDS
                            , new LinkedBlockingQueue<>(MAX_THREAD_QUEUE_SIZE)
                            ,new RejectedExecutionHandler() {
                                @Override
                                public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                                    logger.info("線程被拒絕掉,核心線程隊列容量{}",executor.getQueue().size());
                                    // 可以做一些補償機制
                                }
                            }
                    );
                }
            }
        }
        return threadPoolExecutor;
    }

    private LinkedBlockingQueue getCacheQueue(){
        if (cacheLinkedQueue == null){
            synchronized (ThreadPoolManagersImpl.class){
                if (cacheLinkedQueue == null){
                    cacheLinkedQueue = new LinkedBlockingQueue<>(MAX_CACHE_QUEUE_SIZE);
                }
            }
        }
        return cacheLinkedQueue;
    }




    class OfflineResumeThread extends Thread{
        @Override
        public void run(){
            while (true){
                if (getExecutorService().getQueue().size() >= MAX_THREAD_QUEUE_SIZE){
                    continue;
                }
                Runnable runnable = null;
                try {
                    runnable = cacheLinkedQueue.take();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                logger.info("移除 queue,size :{}" , cacheLinkedQueue.size());
                if (runnable != null){
                    getExecutorService().submit(runnable);
                }
                if (cacheLinkedQueue.size() == 0){
                    setOffline(false);
                    logger.info("恢復完畢");
                    return;
                }
            }
        }
    }


    @Override
    public int getMaxThreadQueueSize() {
        return MAX_THREAD_QUEUE_SIZE;
    }

    @Override
    public int getCorePoolSize() {
        return CORE_POOL_SIZE;
    }

    @Override
    public int getMaxPoolSize() {
        return MAX_POOL_SIZE;
    }

    @Override
    public int getKeepAliveTime() {
        return KEEP_ALIVE_TIME;
    }

    @Override
    public int getMaxCacheQueueSize() {
        return MAX_CACHE_QUEUE_SIZE;
    }

    @Override
    public boolean getOffline() {
        return offline;
    }

    private void setOffline(boolean offline) {
        try {
            writeLock.lock();
            ThreadPoolManagersImpl.offline = offline;
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            writeLock.unlock();
        }
    }
}

CommonService 是我的一個業務處理的類,大家可以自己換成自己要用的

調用結果就不展示了，有興趣可以自己跑起來看看

緩存隊列藉助備忘錄模式思想,線程池的工作隊列滿了後,再來的請求會放入緩存隊列，等線程池的隊列空閒了，再恢復緩存隊列的請求