public ThreadPoolExecutor(int corePoolSize,//核心線程數(shù)
                          int maximumPoolSize,//最大線程數(shù)
                          long keepAliveTime,//線程空閑時間
                          TimeUnit unit,//時間單位
                          BlockingQueue<Runnable> workQueue,//任務(wù)隊列
                          ThreadFactory threadFactory,//線程工廠
                          RejectedExecutionHandler handler//拒絕策略) 
{
    ...
}

package com.thgy.bc.common.config;
 
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
 
import java.util.concurrent.*;
 
@Slf4j
@Configuration
public class ThreadPoolConfig {
    @Bean
    public ThreadPoolTaskExecutor threadPoolTaskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        int i = Runtime.getRuntime().availableProcessors();
        //核心線程數(shù)目
        executor.setCorePoolSize(i * 2);
        //指定最大線程數(shù)
        executor.setMaxPoolSize(i * 2);
        //隊列中最大的數(shù)目
        executor.setQueueCapacity(i * 2 * 10);
        //線程名稱前綴
        executor.setThreadNamePrefix("ThreadPoolTaskExecutor-");
        //rejection-policy：當pool已經(jīng)達到max size的時候，如何處理新任務(wù)
        //CALLER_RUNS：不在新線程中執(zhí)行任務(wù)，而是由調(diào)用者所在的線程來執(zhí)行
        //對拒絕task的處理策略
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        //當調(diào)度器shutdown被調(diào)用時等待當前被調(diào)度的任務(wù)完成
        executor.setWaitForTasksToCompleteOnShutdown(true);
        //線程空閑后的最大存活時間
        executor.setKeepAliveSeconds(60);
        //加載
        executor.initialize();
        log.info("初始化線程池成功");
        return executor;
    }
 
    @Bean
    public ThreadPoolExecutor threadPoolExecutor() {
        //獲取cpu核心數(shù)
        int i = Runtime.getRuntime().availableProcessors();
        //核心線程數(shù)
        int corePoolSize = i * 2;
        //最大線程數(shù)
        int maximumPoolSize = i * 2;
        //線程無引用存活時間
        long keepAliveTime = 60;
        //時間單位
        TimeUnit unit = TimeUnit.SECONDS;
        //任務(wù)隊列，接收一個整型的參數(shù)，這個整型參數(shù)指的是隊列的長度，
        //ArrayBlockingQueue(int,boolean)，boolean類型的參數(shù)是作為可重入鎖的參數(shù)進行初始化，默認false，另外初始化了notEmpty、notFull兩個信號量。
        BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue(i * 2 * 10);
        //1. 同步阻塞隊列 (put,take)，直接提交。直接提交策略表示線程池不對任務(wù)進行緩存。新進任務(wù)直接提交給線程池，當線程池中沒有空閑線程時，創(chuàng)建一個新的線程處理此任務(wù)。
        // 這種策略需要線程池具有無限增長的可能性。實現(xiàn)為：SynchronousQueue
        //2. 有界隊列。當線程池中線程達到corePoolSize時，新進任務(wù)被放在隊列里排隊等待處理。有界隊列（如ArrayBlockingQueue）有助于防止資源耗盡，
        // 但是可能較難調(diào)整和控制。隊列大小和最大池大小可能需要相互折衷：使用大型隊列和小型池可以最大限度地降低 CPU 使用率、操作系統(tǒng)資源和上下文切換開銷，
        // 但是可能導(dǎo)致人工降低吞吐量。如果任務(wù)頻繁阻塞（例如，如果它們是 I/O 邊界），則系統(tǒng)可能為超過您許可的更多線程安排時間。使用小型隊列通常要求較大的池大小，
        // CPU 使用率較高，但是可能遇到不可接受的調(diào)度開銷，這樣也會降低吞吐量。
        //3. 無界隊列。使用無界隊列（例如，不具有預(yù)定義容量的 LinkedBlockingQueue）將導(dǎo)致在所有 corePoolSize 線程都忙時新任務(wù)在隊列中等待。
        // 這樣，創(chuàng)建的線程就不會超過 corePoolSize。（因此，maximumPoolSize 的值也就無效了。）當每個任務(wù)完全獨立于其他任務(wù)，即任務(wù)執(zhí)行互不影響時，
        // 適合于使用無界隊列；例如，在 Web 頁服務(wù)器中。這種排隊可用于處理瞬態(tài)突發(fā)請求，當命令以超過隊列所能處理的平均數(shù)連續(xù)到達時，此策略允許無界線程具有增長的可能性。
 
        //線程工廠
        //defaultThreadFactory()
        //返回用于創(chuàng)建新線程的默認線程工廠。
        //privilegedThreadFactory()
        //返回一個用于創(chuàng)建與當前線程具有相同權(quán)限的新線程的線程工廠。
        ThreadFactory threadFactory =Executors.defaultThreadFactory();
        //拒絕執(zhí)行處理器
        RejectedExecutionHandler handler = new ThreadPoolExecutor.CallerRunsPolicy();
        //創(chuàng)建線程池
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);
        return threadPoolExecutor;
    }
}
 

// 第一種線程池:固定個數(shù)的線程池,可以為每個CPU核綁定一定數(shù)量的線程數(shù)
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(processors * 2);
// 緩存線程池，無上限
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
// 單一線程池,永遠會維護存在一條線程
ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();
// 固定個數(shù)的線程池，可以執(zhí)行延時任務(wù)，也可以執(zhí)行帶有返回值的任務(wù)。
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);

public List<AccountRecordVO> requestTest() throws ExecutionException, InterruptedException {
        List<String> ids = Lists.newArrayList();
        ids.add("1");
        ids.add("2");
        ids.add("3");
        ids.add("4");
        //有返回值的情況，定義接收返回值
        List<AccountRecordVO> futureList2 = Lists.newArrayList();
        //分布式計數(shù)器，若業(yè)務(wù)不需要則可以不定義
        CountDownLatch countDownLatch = new CountDownLatch(ids.size());
        for (String id : ids) {
            //調(diào)用線程池的線程執(zhí)行任務(wù)
            threadPoolTaskExecutor.submit(new Runnable() {
                @Override
                public void run() {
                    test(Lists.newArrayList(id),futureList2);
                    //計數(shù)器-1
                    countDownLatch.countDown();
                }
            });
        }
        //await阻塞，直到計數(shù)器為0
        countDownLatch.await();
        System.out.println("主線程"+"====");
        return futureList2;
    }
 
    public List<AccountRecordVO> test(List<String> ids, List<AccountRecordVO> list2){
        //隨便寫的業(yè)務(wù)邏輯代碼，無實際意義，僅作演示
        System.out.println("線程體" + "====");
        List<AccountRecordVO> accountRecordVOS = Lists.newArrayList();
        int i = 0;
        AccountRecordVO accountRecordVO = new AccountRecordVO();
        accountRecordVO.setUserId("123");
        accountRecordVO.setAmount(12333);
        for (String id : ids){
            accountRecordVOS.add(accountRecordVO);
            list2.add(accountRecordVO);
        }
        try{
            Thread.sleep(Long.valueOf("1000"));
        }catch (Exception e){
            log.error(e.getMessage());
        }
        System.out.println("線程體結(jié)束" + "====");
        return accountRecordVOS;
    }