// 主要接口和類
Executor          // 執(zhí)行器接口
ExecutorService   // 執(zhí)行服務接口
ThreadPoolExecutor // 線程池核心實現(xiàn)類
ScheduledThreadPoolExecutor // 支持定時調(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 (當前線程數(shù) < corePoolSize) {
        創(chuàng)建新線程執(zhí)行任務;
    } else if (工作隊列未滿) {
        將任務加入工作隊列;
    } else if (當前線程數(shù) < maximumPoolSize) {
        創(chuàng)建新線程執(zhí)行任務;
    } else {
        執(zhí)行拒絕策略;
    }
}

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

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

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()
        );
        // 提交任務
        for (int i = 1; i <= 20; i++) {
            final int taskId = i;
            executor.execute(() -> {
                System.out.println(Thread.currentThread().getName() + 
                                 " 執(zhí)行任務 " + taskId);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }
        // 監(jiān)控線程池狀態(tài)
        monitorThreadPool(executor);
        // 優(yōu)雅關閉
        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("當前線程數(shù): " + executor.getPoolSize());
                System.out.println("活躍線程數(shù): " + executor.getActiveCount());
                System.out.println("隊列大小: " + executor.getQueue().size());
                System.out.println("完成任務數(shù): " + executor.getCompletedTaskCount());
                System.out.println("總?cè)蝿諗?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等待時間調(diào)整
int corePoolSize = Runtime.getRuntime().availableProcessors() * 2;

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