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

// 第一種線程池:固定個(gè)數(shù)的線程池,可以為每個(gè)CPU核綁定一定數(shù)量的線程數(shù)
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(processors * 2);
// 緩存線程池，無上限
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
// 單一線程池,永遠(yuǎn)會(huì)維護(hù)存在一條線程
ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();
// 固定個(gè)數(shù)的線程池，可以執(zhí)行延時(shí)任務(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();
        //分布式計(jì)數(shù)器，若業(yè)務(wù)不需要?jiǎng)t可以不定義
        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);
                    //計(jì)數(shù)器-1
                    countDownLatch.countDown();
                }
            });
        }
        //await阻塞，直到計(jì)數(shù)器為0
        countDownLatch.await();
        System.out.println("主線程"+"====");
        return futureList2;
    }
 
    public List<AccountRecordVO> test(List<String> ids, List<AccountRecordVO> list2){
        //隨便寫的業(yè)務(wù)邏輯代碼，無實(shí)際意義，僅作演示
        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;
    }