什么是线程池？

线程池是一种基于池化思想管理和复用线程的机制。其核心原理是预先创建一定数量的线程并存储在“池子”中，当有任务需要执行时，直接从池中分配空闲线程处理任务，避免频繁创建和销毁线程的开销。这种机制在提高资源利用率、优化系统性能方面具有重要作用。

核心作用与优势

1. 降低资源消耗：
   线程的创建和销毁涉及内存分配、系统调用等开销。线程池通过复用已有线程，将线程生命周期开销分摊到多个任务上，显著减少资源浪费。

2. 提高响应速度：
   任务到达时可直接使用池中空闲线程，无需等待线程创建。例如，若线程创建时间为T1，任务执行时间为T2，销毁时间为T3，使用线程池可节省T1+T3的时间。

3. 增强可管理性：
   线程池统一管理线程数量和行为，避免因线程过多导致资源耗尽（如内存溢出或CPU过载）。同时支持任务队列、拒绝策略等机制，提升系统稳定性。

4. 优化线程复用：
   通过参数（如corePoolSize、maxPoolSize）动态调整线程数量，空闲线程超时回收（keepAliveTime），平衡资源占用与任务处理效率。

核心参数解析

• corePoolSize：常驻核心线程数，即使空闲也不会销毁（除非设置allowCoreThreadTimeOut）。
• maxPoolSize：线程池允许的最大线程数。
• keepAliveTime：非核心线程的空闲存活时间，超时后自动回收。
• workQueue：任务队列，用于缓存待执行任务（如ArrayBlockingQueue、LinkedBlockingQueue）。
• ThreadFactory：自定义线程创建方式（如设置线程名称、优先级）。
• RejectedExecutionHandler：拒绝策略，处理任务队列满且线程数达上限的情况。

适用场景

• CPU密集型任务：需控制线程数接近CPU核数，避免过多线程导致上下文切换。
• 高并发网络服务：快速响应客户端请求，复用线程处理短任务。
• 异步I/O操作：如文件读写、数据库访问，避免阻塞主线程。

Java中如何创建线程池？

在Java中，线程池主要通过java.util.concurrent包下的ThreadPoolExecutor类实现，同时提供Executors工具类简化创建。以下分两种方式详细说明：

---

1. 手动创建（推荐）

通过ThreadPoolExecutor构造函数自定义参数，灵活控制线程池行为。

import java.util.concurrent.*;

public class CustomThreadPool {
    public static void main(String[] args) {
        // 定义核心参数
        int corePoolSize = 5;
        int maxPoolSize = 10;
        long keepAliveTime = 60L;
        TimeUnit unit = TimeUnit.SECONDS;
        BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>(100);
        ThreadFactory threadFactory = Executors.defaultThreadFactory();
        RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();

        // 创建线程池
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            corePoolSize,
            maxPoolSize,
            keepAliveTime,
            unit,
            workQueue,
            threadFactory,
            handler
        );

        // 提交任务
        executor.execute(() -> System.out.println("Task executed by thread: " + Thread.currentThread().getName()));

        // 关闭线程池
        executor.shutdown();
    }
}

关键配置说明：

• workQueue选择：

  • ArrayBlockingQueue：固定大小数组队列，适合任务量可控场景。
  • LinkedBlockingQueue：无界队列（默认Integer.MAX_VALUE），可能导致内存溢出。
  • SynchronousQueue：不存储任务，直接提交给线程，适用于高吞吐。

• 拒绝策略：

  • AbortPolicy（默认）：直接抛出RejectedExecutionException。
  • CallerRunsPolicy：由提交任务的线程直接执行任务。
  • DiscardPolicy：静默丢弃被拒绝的任务。
  • DiscardOldestPolicy：丢弃队列中最旧的任务并重试提交。

2. 使用Executors工具类

提供预定义配置的线程池，适合快速开发，但需注意潜在问题：

FixedThreadPool
固定线程数，使用无界队列（LinkedBlockingQueue）。
风险：任务堆积可能导致内存溢出。

ExecutorService fixedPool = Executors.newFixedThreadPool(5);

CachedThreadPool
线程数无上限（maxPoolSize=Integer.MAX_VALUE），空闲线程60秒回收。
风险：高并发下可能创建过多线程导致资源耗尽。

ExecutorService cachedPool = Executors.newCachedThreadPool();

• SingleThreadExecutor
  单线程串行执行任务，使用无界队列。
  风险：任务失败后线程终止，需手动重启。

3. Spring框架中的线程池（补充）

通过ThreadPoolTaskExecutor简化配置，支持与Spring集成：

@Bean
public ThreadPoolTaskExecutor taskExecutor() {
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    executor.setCorePoolSize(5);
    executor.setMaxPoolSize(10);
    executor.setQueueCapacity(100);
    executor.setThreadNamePrefix("Spring-Thread-");
    executor.initialize();
    return executor;
}

线程池的工作流程

1. 任务提交后，优先使用核心线程执行。
2. 核心线程全忙时，任务进入队列等待。
3. 队列满后，启动新线程（不超过maxPoolSize）。
4. 线程数和队列均满时，触发拒绝策略。

最佳实践与注意事项

1. 避免使用无界队列：防止任务堆积导致内存溢出。
2. 合理设置maxPoolSize：根据系统资源（CPU、内存）和任务类型调整。
3. 监控线程池状态：通过getActiveCount()、getQueue().size()等接口实时监控。
4. 优雅关闭：调用shutdown()或shutdownNow()确保任务完成。

通过合理配置线程池参数，可显著提升Java应用在高并发场景下的稳定性和性能。