// 主要接口和類
Executor          // 執(zhí)行器接口
ExecutorService   // 執(zhí)行服務(wù)接口
ThreadPoolExecutor // 線程池核心實(shí)現(xiàn)類
ScheduledThreadPoolExecutor // 支持定時(shí)調(diào)度的線程池
Executors         // 線程池工廠類

public ThreadPoolExecutor(
    int corePoolSize,
    int maximumPoolSize,
    long keepAliveTime,
    TimeUnit unit,
    BlockingQueue<Runnable> workQueue,
    ThreadFactory threadFactory,
    RejectedExecutionHandler handler
)

// 自定義線程工廠示例
ThreadFactory customThreadFactory = new ThreadFactory() {
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    @Override
    public Thread newThread(Runnable r) {
        Thread thread = new Thread(r);
        thread.setName("MyThread-" + threadNumber.getAndIncrement());
        thread.setDaemon(false);
        thread.setPriority(Thread.NORM_PRIORITY);
        return thread;
    }
};

// 線程池工作流程偽代碼
public void execute(Runnable task) {
    if (當(dāng)前線程數(shù) < corePoolSize) {
        創(chuàng)建新線程執(zhí)行任務(wù);
    } else if (工作隊(duì)列未滿) {
        將任務(wù)加入工作隊(duì)列;
    } else if (當(dāng)前線程數(shù) < maximumPoolSize) {
        創(chuàng)建新線程執(zhí)行任務(wù);
    } else {
        執(zhí)行拒絕策略;
    }
}

任務(wù)提交
    ↓
當(dāng)前線程數(shù) < corePoolSize? → 是 → 創(chuàng)建核心線程執(zhí)行
    ↓否
工作隊(duì)列未滿? → 是 → 任務(wù)入隊(duì)等待
    ↓否
當(dāng)前線程數(shù) < maximumPoolSize? → 是 → 創(chuàng)建非核心線程執(zhí)行
    ↓否
執(zhí)行拒絕策略

// 1. 固定大小線程池
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(10);
// 特點(diǎn)：核心線程數(shù)=最大線程數(shù)，使用無界隊(duì)列
// 2. 單線程線程池
ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();
// 特點(diǎn)：只有一個(gè)線程，任務(wù)順序執(zhí)行
// 3. 緩存線程池
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
// 特點(diǎn)：核心線程數(shù)為0，最大線程數(shù)為Integer.MAX_VALUE，使用同步隊(duì)列
// 4. 定時(shí)任務(wù)線程池
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
// 支持定時(shí)和周期性任務(wù)

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    5,                                      // corePoolSize
    10,                                     // maximumPoolSize
    60L,                                    // keepAliveTime
    TimeUnit.SECONDS,                       // unit
    new ArrayBlockingQueue<>(100),          // workQueue
    Executors.defaultThreadFactory(),       // threadFactory
    new ThreadPoolExecutor.AbortPolicy()    // handler
);

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 創(chuàng)建線程池
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            2, 5, 60, TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(10),
            new CustomThreadFactory(),
            new ThreadPoolExecutor.CallerRunsPolicy()
        );
        // 提交任務(wù)
        for (int i = 1; i <= 20; i++) {
            final int taskId = i;
            executor.execute(() -> {
                System.out.println(Thread.currentThread().getName() + 
                                 " 執(zhí)行任務(wù) " + taskId);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }
        // 監(jiān)控線程池狀態(tài)
        monitorThreadPool(executor);
        // 優(yōu)雅關(guān)閉
        executor.shutdown();
        try {
            if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                executor.shutdownNow();
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }
    // 自定義線程工廠
    static class CustomThreadFactory implements ThreadFactory {
        private final AtomicInteger counter = new AtomicInteger(1);
        @Override
        public Thread newThread(Runnable r) {
            Thread thread = new Thread(r);
            thread.setName("CustomThread-" + counter.getAndIncrement());
            thread.setDaemon(false);
            thread.setPriority(Thread.NORM_PRIORITY);
            return thread;
        }
    }
    // 監(jiān)控線程池狀態(tài)
    private static void monitorThreadPool(ThreadPoolExecutor executor) {
        new Thread(() -> {
            while (!executor.isTerminated()) {
                System.out.println("=== 線程池狀態(tài)監(jiān)控 ===");
                System.out.println("核心線程數(shù): " + executor.getCorePoolSize());
                System.out.println("當(dāng)前線程數(shù): " + executor.getPoolSize());
                System.out.println("活躍線程數(shù): " + executor.getActiveCount());
                System.out.println("隊(duì)列大小: " + executor.getQueue().size());
                System.out.println("完成任務(wù)數(shù): " + executor.getCompletedTaskCount());
                System.out.println("總?cè)蝿?wù)數(shù): " + executor.getTaskCount());
                System.out.println("========================\n");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                }
            }
        }).start();
    }
}

// 線程數(shù) ≈ CPU核心數(shù) + 1
int corePoolSize = Runtime.getRuntime().availableProcessors() + 1;

// 線程數(shù) ≈ CPU核心數(shù) * 2
// 或根據(jù)具體IO等待時(shí)間調(diào)整
int corePoolSize = Runtime.getRuntime().availableProcessors() * 2;

// Java 1.7+ 支持動(dòng)態(tài)調(diào)整參數(shù)
executor.setCorePoolSize(10);
executor.setMaximumPoolSize(20);
executor.setKeepAliveTime(120, TimeUnit.SECONDS);