【進階之路】執行緒池擴充與CompletionService操作非同步任務

南橘ryc發表於2020-12-22
執行緒非同步

大家好，我是練習java兩年半時間的南橘，小夥伴可以一起互相交流經驗哦。

一、擴充套件ThreadPoolExecutor

1、擴充套件方法介紹

ThreadPoolExecutor是可以擴充套件的，它內部提供了幾個可以在子類中改寫的方法（紅框內）。JDK內的註解上說，這些方法可以用以新增日誌，計時、監視或進行統計資訊的收集。是不是感覺很熟悉？有沒有一種spring aop中 @Around @Before @After三個註解的既視感？

我們來對比一下

ThreadPoolExecutor spring aop
beforeExecute()（執行緒執行之前呼叫） @Before（在所攔截的方法執行之前執行 ）
afterExecute() （執行緒執行之後呼叫） @After （在所攔截的方法執行之後執行）
terminated() （執行緒池退出時候呼叫）
@Around（可以同時在所攔截的方法前後執行）

其實他們的效果是一樣的，只是一個線上程池裡，一個在攔截器中。

對於ThreadPoolExecutor中的這些方法，有這樣的一些特點：

  • 1、無論任務時從run中正常返回，還是丟擲一個異常而返回，afterExecute都會被呼叫（但是如果任務在完成後帶有一個Error，那麼就不會呼叫afterExecute)

  • 2、同時，如果beforeExecute丟擲一個RuntimeExecption，那麼任務將不會被執行，連帶afterExecute也不會被呼叫了。

  • 3、線上程池完成關閉操作時會呼叫terminated，類似於try-catch中的finally操作一樣。terminated可以用來釋放Executor在其生命週期裡分配的各種資源，此外也可以用來執行傳送通知、記錄日誌亦或是收集finalize統計資訊等操作。

2、擴充套件方法實現

我們先構建一個自定義的執行緒池，它通過擴充套件方法來新增日誌記錄和統計資訊的收集。為了測量任務的執行時間，beforeExecute必須記錄開始時間並把它儲存到一個afterExecute可以訪問的地方，於是用ThreadLocal來儲存變數，用afterExecute來讀取，並通過terminated來輸出平均任務和日誌訊息。

public class WeedThreadPool extends ThreadPoolExecutor {
    private final ThreadLocal<Long> startTime =new ThreadLocal<>();
    private final Logger log =Logger.getLogger("WeedThreadPool");
    //統計執行次數
    private final AtomicLong numTasks =new AtomicLong();
    //統計總執行時間
    private final AtomicLong totalTime =new AtomicLong();
    /**
     * 這裡是實現執行緒池的構造方法，我隨便選了一個，大家可以根據自己的需求找到合適的構造方法
     */
    public WeedThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
    }
    //執行緒執行之前呼叫
    protected void  beforeExecute(Thread t,Runnable r){
        super.beforeExecute(t,r);
        System.out.println(String.format("Thread %s:start %s",t,r));
        //因為currentTimeMillis返回的是ms，而眾所周知ms是很難產生差異的，所以換成了nanoTime用ns來展示
        startTime.set(System.nanoTime());
    }
    //執行緒執行之後呼叫
    protected void afterExecute(Runnable r,Throwable t){
        try {
            Long endTime =System.nanoTime();
            Long taskTime =endTime-startTime.get();
            numTasks.incrementAndGet();
            totalTime.addAndGet(taskTime);
            System.out.println(String.format("Thread %s:end %s, time=%dns",Thread.currentThread(),r,taskTime));
        }finally {
            super.afterExecute(r,t);
        }
    }
    //執行緒池退出時候呼叫
   protected void terminated(){
        try{
            System.out.println(String.format("Terminated: avg time =%dns, ",totalTime.get()/numTasks.get()));
        }finally {
            super.terminated();
        }
   }

}

測試案例：

public class WeedThreadTest {
     BlockingQueue<Runnable> taskQueue;
   final static WeedThreadPool weedThreadPool =new WeedThreadPool(3,10,1, TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(100));
    public static void main(String[] args) throws InterruptedException {
        for(int i=0;i<3;i++) {
            weedThreadPool.execute(WeedThreadTest::run);
        }
        Thread.sleep(2000L);
        weedThreadPool.shutdown();
    }

    private static void run() {
        System.out.println("thread id is: " + Thread.currentThread().getId());
        try {
            Thread.sleep(1024L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

3、使用場景

用到這些方法的地方其實和用到Spring AOP中一些場景比較相似，主要在記錄跟蹤、優化等方面可以使用，如日誌記錄和統計資訊的收集、測量任務的執行時間，以及一些任務完成之後傳送通知、郵件、資訊之類的。

二、CompletionService操作非同步任務

1、非同步方法的原理

如果我們意外收穫了一大批待執行的任務（舉個例子，比如去呼叫各大旅遊軟體的出行機票資訊），為了提高任務的執行效率，我們可以使用執行緒池submit非同步計算任務,通過呼叫Future介面實現類的get方法獲取結果。

雖然使用了執行緒池會提高執行效率，但是呼叫Future介面實現類的get方法是阻塞的，也就是和當前這個Future關聯的任務全部執行完成的時候，get方法才返回結果，如果當前任務沒有執行完成，而有其它Future關聯的任務已經完成了，就會白白浪費很多等待的時間。

所以，有沒有這樣一個方法，遍歷的時候誰先執行完成就先獲取哪個結果？

沒錯，我們的ExecutorCompletionService就可以實現這樣的效果，它的內部有一個先進先出的阻塞佇列，用於儲存已經執行完成的Future，通過呼叫它的take方法或poll方法可以獲取到一個已經執行完成的Future，進而通過呼叫Future介面實現類的get方法獲取最終的結果。

邏輯圖如下：

ExecutorCompletionService實現了CompletionService介面，在CompletionService介面中定義瞭如下這些方法：

  • Future submit(Callable task):提交一個Callable型別任務，並返回該任務執行結果關聯的Future；

  • Future submit(Runnable task,V result):提交一個Runnable型別任務，並返回該任務執行結果關聯的Future；

  • Future take():從內部阻塞佇列中獲取並移除第一個執行完成的任務，阻塞，直到有任務完成；

  • Future poll():從內部阻塞佇列中獲取並移除第一個執行完成的任務，獲取不到則返回null，不阻塞；

  • Future poll(long timeout, TimeUnit unit):從內部阻塞佇列中獲取並移除第一個執行完成的任務，阻塞時間為timeout，獲取不到則返回null；

2、非同步方法的實現

public class WeedExecutorServiceDemo {
    /**
     * 繼續用之前建好的執行緒池，只是調整一下池大小
     */
    BlockingQueue<Runnable> taskQueue;
    final static WeedThreadPool weedThreadPool = new WeedThreadPool(1, 5, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(100));
    public static Random r = new Random();

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        CompletionService<Integer> cs = new ExecutorCompletionService<Integer>(weedThreadPool);
        for (int i = 0; i < 3; i++) {
            cs.submit(() -> {
                //獲取計算任務
                int init = 0;
                for (int j = 0; j < 100; j++) {
                    init += r.nextInt();
                }
                Thread.sleep(1000L);
                return Integer.valueOf(init);
            });
        }
        weedThreadPool.shutdown();
        /**
         * 通過take方法獲取，阻塞，直到有任務完成
         */
        for (int i = 0; i < 3; i++) {
            Future<Integer> future = cs.take();
            if (future != null) {
                System.out.println(future.get());
            }
        }
    }
}

呼叫結果如下

我們也可以通過poll方法來獲取。

 		 /**
         * 通過poll方法獲取
         */
        for (int i = 0; i < 3; i++) {
              System.out.println(cs.poll(1200L,TimeUnit.MILLISECONDS).get());

        }

結果自然是一樣的

如果把阻塞時間改小一些，目前的程式碼就會出問題

		/**
         * 通過poll方法獲取
         */
        for (int i = 0; i < 3; i++) {
            System.out.println(cs.poll(800L,TimeUnit.MILLISECONDS).get());

        }

同樣的，poll方法也可以用來打斷超時執行的業務，比如在poll超時的情況下，直接呼叫執行緒池的shutdownNow(),殘暴地關閉整個執行緒池。

	for (int i = 0; i < 3; i++) {
            Future<Integer> poll = cs.poll(800L, TimeUnit.MILLISECONDS);
            if (poll==null){
                System.out.println("執行結束");
                weedThreadPool.shutdownNow();
            }
        }

3、使用場景

選擇怎麼樣的方法來非同步執行任務，什麼樣的方式來接收任務，也是需要根據實際情況來考慮的。

  • 1.、需要批量提交非同步任務的時候建議你使用 CompletionService。CompletionService 將執行緒池 Executor 和阻塞佇列 BlockingQueue 的功能融合在了一起，能夠讓批量非同步任務的管理更簡單。

  • 2、讓非同步任務的執行結果有序化。先執行完的先進入阻塞佇列，利用這個特性，你可以輕鬆實現後續處理的有序性，避免無謂的等待。

  • 3、執行緒池隔離。CompletionService支援建立知己的執行緒池，這種隔離效能避免幾個特別耗時的任務拖垮整個應用的風險。

有需要的同學可以加我的公眾號，以後的最新的文章第一時間都在裡面，需要之前文章的思維導圖也可以給我留言

相關文章