線程池：第四章：ThreadPoolTaskExecutor和ThreadPoolExecutor有何區別?

• ThreadPoolTaskExecutor是spring core包中的，而ThreadPoolExecutor是JDK中的JUC。
• ThreadPoolTaskExecutor是對ThreadPoolExecutor進行了封裝處理。

看看ThreadPoolTaskExecutor源碼

看看ThreadPoolExecutor源碼

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

int corePoolSize:線程池維護線程的最小數量.  　　

int maximumPoolSize:線程池維護線程的最大數量.  　　

long keepAliveTime:空閑線程的存活時間.  　　

TimeUnit unit: 時間單位,現有納秒,微秒,毫秒,秒枚舉值.  　　

BlockingQueue<Runnable> workQueue:持有等待執行的任務隊列.

ThreadFactory:線程工廠

RejectedExecutionHandler handler:用來拒絕一個任務的執行

而拒絕策略有四種：

(1)ThreadPoolExecutor.AbortPolicy策略，是默認的策略,處理程序遭到拒絕將拋出運行時 RejectedExecutionException。 

(2)ThreadPoolExecutor.CallerRunsPolicy策略 ,調用者的線程會執行該任務,如果執行器已關閉,則丟棄. 

(3)ThreadPoolExecutor.DiscardPolicy策略，不能執行的任務將被丟棄. 

(4)ThreadPoolExecutor.DiscardOldestPolicy策略，如果執行程序尚未關閉，則位於工作隊列頭部的任務將被刪除，然后重試執行程序（如果再次失敗，則重復此過程）.

上一章有詳細講解

那我們現在來用一用ThreadPoolTaskExecutor

弄一個工具類

package utils;

import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.ui.ModelMap;

import java.lang.reflect.Method;
import java.util.concurrent.CountDownLatch;

public class ThreadTool {

    static ThreadPoolTaskExecutor threadPoolTaskExecutor;

    static {
        threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
        threadPoolTaskExecutor.setCorePoolSize(5);
        threadPoolTaskExecutor.setMaxPoolSize(10);
        threadPoolTaskExecutor.setQueueCapacity(100);
        threadPoolTaskExecutor.initialize();
    }

    /**
     * 使用線程池執行業務方法並加入視圖
     * @param tasks 計數器
     * @param modelMap 視圖
     * @param modelName 視圖名
     * @param service 要調用的service
     * @param method 被調用的方法
     * @param param 方法參數
     */
    public static void runMethod(CountDownLatch tasks, ModelMap modelMap, String modelName, Object service, Method method, Object... param){
        threadPoolTaskExecutor.submit(new RunInThreadPool(
                tasks,modelMap,modelName,service,method,param));
    }
    

}

RunInThreaddPool

package utils;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Map;
import java.util.concurrent.CountDownLatch;

public class RunInThreadPool implements Runnable {

    CountDownLatch countDownLatch;
    Map modelMap;
    String keyName;
    Object service;
    Method method;
    Object[] param;

    /**
     * @param countDownLatch 計數器
     * @param modelMap       視圖
     * @param keyName        參數名
     * @param service        要調用的service
     * @param method         被調用的方法
     * @param param          方法參數
     */
    public RunInThreadPool(CountDownLatch countDownLatch, Map modelMap, String keyName, Object service, Method method, Object... param) {
        this.countDownLatch = countDownLatch;
        this.modelMap = modelMap;
        this.keyName = keyName;
        this.service = service;
        this.method = method;
        this.param = param;
    }

    @Override
    public void run() {
        Object result = null;
        try {
            Long start = System.currentTimeMillis();
            result = method.invoke(service, param);
            Long end = System.currentTimeMillis();
            System.out.println(String.format("%s *** 執行 ((( %s ))) 方法,耗時 <<< %s 秒 >>> 參數",
                    service.getClass(),
                    method.getName(),
                    (end - start),
                    JsonUtils.toJson(param)));
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        modelMap.put(keyName, result);
        countDownLatch.countDown();
    }
}

實戰案例：

        @RequestMapping("/goodsDetail")
        public String goodsDetail(GoodsBean goodsBean, PageBean pageBean, ModelMap modelMap) throws Exception {
            final CountDownLatch latch = new CountDownLatch(7);
            Method getRelatedGoods = goodsService.getClass().getMethod("getRelatedGoods", GoodsBean.class, String.class);
            getRelatedGoods.setAccessible(Boolean.TRUE);
            ThreadTool.runMethod(latch , modelMap, "relatedGoods0", goodsService, getRelatedGoods, goodsBean, "0");
            //剩下六個類似的業務。。。。
            ...............................
            latch.await();
            return "production/index";
        }

對比：

    @RequestMapping("/getRelatedGoods")
    @AppController
    public String getRelatedGoods(GoodsBean goodsBean, String show_type,ModelMap modelMap) {
        modelMap.addAttribute("getRelatedGoods",goodsService.getRelatedGoods(goodsBean, show_type));
        return "production/index";
    }