线程池的工作流程

整体流程：当有任务提交时，首先看核心线程是否都在忙，如果没满，就创建新线程执行。如果核心线程满了，就把任务放到队列里。如果队列也满了，就创建非核心线程，直到达到最大线程数。如果连最大线程数都满了，就会执行拒绝策略。

参数含义：corePoolSize是核心线程数，即使空闲也不会被回收，而maximumPoolSize是最大线程数，当任务很多时，可以创建更多的线程，直到达到这个数目。那keepAliveTime应该是指非核心线程空闲时的存活时间，超过这个时间就会被回收。

代码示例
public ThreadPoolExecutor(
int corePoolSize, // 核心线程数
int maximumPoolSize, // 最大线程数
long keepAliveTime, // 非核心线程空闲存活时间
TimeUnit unit, // 存活时间单位
BlockingQueue workQueue, // 任务队列
ThreadFactory threadFactory, // 线程工厂
RejectedExecutionHandler handler // 拒绝策略
)
corePoolSize=2；maximumPoolSize=3；LinkedBlockingQueue.size=2；

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadPoolExecutorTest {
    public static void main(String[] args) {
        ThreadPoolExecutor pool = new ThreadPoolExecutor(2, 3,
                0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<>(2), new ThreadPoolExecutor.DiscardOldestPolicy());
        try (pool) {
            for (int i = 0; i < 6; i++) {
                execute(pool, i);
            }
        }
    }


    private static void execute(ThreadPoolExecutor pool, int i) {
        pool.execute(() -> doTask(i));
        System.out.println("activeCount=" + pool.getActiveCount());
        System.out.println("queueSize=" + pool.getQueue().size());
        System.out.println("#########");
    }

    private static void doTask(int i) {
        Thread.currentThread().setName("Thread" + i);
        try {
            Thread.sleep(1000L);
        } catch (InterruptedException _) {
        }
        System.out.println("Task end. Thread =" + Thread.currentThread().getName());
    }
}

打印：
activeCount=1
queueSize=0
#########
activeCount=2
queueSize=0
#########
activeCount=2
queueSize=1
#########
activeCount=2
queueSize=2
#########
activeCount=3
queueSize=2
#########
activeCount=3
queueSize=2
#########
Task end. Thread =Thread0
Task end. Thread =Thread1
Task end. Thread =Thread4
Task end. Thread =Thread3
Task end. Thread =Thread5

流程: thread0、thread1入线程池，activeCount=2；当thread2入池时，发现线程数已经达到corePoolSize，于是将thread2、thread3存到BlockingQueue中；当thread4入池时，发现corePoolSize和BlockingQueue都满了，于是创建新的线程，此时activeCount=3(达到maximumPoolSize)；当thread5入池时，发现线程数和队列数都满了 ，根据DiscardOldestPolicy拒绝策略，将最早入队列的thread2丢弃，将thread5对队列BlockingQueue（队列中有thread3、thread5）。

其他拒绝策略
AbortPolicy：默认的拒绝策略，程序会抛出RejectedExecutionException异常；
DiscardPolicy：静默丢弃策略，不做任何处理；
CallerRunsPolicy：让调用者线程执行任务。

常见队列类型
LinkedBlockingQueue：无界队列（默认Integer.MAX_VALUE），可能导致内存溢出。
ArrayBlockingQueue：有界队列，需指定固定容量。
SynchronousQueue：不存储任务，直接将任务交给线程，需与足够大的maximumPoolSize配合。
PriorityBlockingQueue：支持优先级的无界队列。

提交方式
execute()：提交Runnable任务，无返回值。

executor.execute(() -> System.out.println("Task executed!"));

submit()：提交Callable或Runnable任务，返回Future对象。

Future<String> future = executor.submit(() -> "Result");
String result = future.get(); // 阻塞获取结果

线程池关闭
shutdown()：平缓关闭，不再接受新任务，等待已提交任务完成。
shutdownNow()：立即关闭，尝试中断所有线程，返回未处理的任务列表。
awaitTermination()：阻塞等待线程池完全终止。

executor.shutdown();
if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
    executor.shutdownNow();
}

监控与调优
重写钩子方法：通过beforeExecute()和afterExecute()监控任务执行。

class MonitorThreadPool extends ThreadPoolExecutor {
    protected void afterExecute(Runnable r, Throwable t) {
        super.afterExecute(r, t);
        // 记录任务执行时间、异常等
    }
}

处理任务异常：通过Future.get()捕获异常，或重写afterExecute()处理。