【Java】多线程篇 —— 线程池

原创已于 2025-07-10 23:45:14 修改 · 1.5k 阅读

15 ·

CC 4.0 BY-SA版权

文章标签：

#开发语言 #java

于 2025-03-02 13:17:07 首次发布

Java 基础专栏收录该内容

32 篇文章

订阅专栏

线程池

线程池的核心类

Java 线程池的实现基于 java.util.concurrent 包，核心类和接口如下：

类/接口	说明
`Executor`	最基础的线程池接口，仅定义 `execute(Runnable)` 方法。
`ExecutorService`	扩展了 `Executor`，提供更丰富的线程池管理功能（如任务提交、关闭）。
`ThreadPoolExecutor`	线程池的核心实现类，所有功能均通过此类实现。
`ScheduledExecutorService`	支持定时任务和周期性任务的线程池接口。
`Executors`	工厂类，提供快捷创建线程池的静态方法（如 `newFixedThreadPool`）。

`ThreadPoolExecutor` 的构造方法

ThreadPoolExecutor 的构造函数包含7个参数，以下是详细说明：

public ThreadPoolExecutor(
    int corePoolSize,           // 核心线程数
    int maximumPoolSize,        // 最大线程数
    long keepAliveTime,         // 临时线程的空闲存活时间
    TimeUnit unit,              // 时间单位（秒、毫秒等）
    BlockingQueue<Runnable> workQueue, // 任务队列
    ThreadFactory threadFactory,       // 线程工厂（自定义线程创建）
    RejectedExecutionHandler handler   // 拒绝策略
)

参数详解

corePoolSize
- 作用：线程池中始终保持存活的线程数量（即使空闲也不会被回收）。
- 示例：若设置为3，线程池最少有3个线程处理任务。
maximumPoolSize
- 作用：线程池允许创建的最大线程数（包括核心线程和临时线程）。
- 示例：若设置为10，当任务队列满时，最多创建10个线程。
keepAliveTime + unit
- 作用：临时线程（超出核心线程数的线程）的空闲存活时间。超过该时间且无任务执行时，临时线程会被回收。
- 示例：60, TimeUnit.SECONDS 表示临时线程空闲60秒后终止。
workQueue
- 作用：存储待执行任务的队列。
- 常用实现类：
  - ArrayBlockingQueue：有界队列（需指定容量）。
  - LinkedBlockingQueue：无界队列（默认容量为 Integer.MAX_VALUE）。
  - SynchronousQueue：直接传递任务的队列（无存储能力）。
threadFactory
- 作用：自定义线程的创建方式（如设置线程名称、优先级）。
- 默认实现：Executors.defaultThreadFactory()。
handler
- 作用：当任务队列已满且线程数达到最大值时的拒绝策略。
- 内置策略：
  - AbortPolicy（默认）：抛出 RejectedExecutionException 异常。
  - CallerRunsPolicy：由提交任务的线程直接执行任务。
  - DiscardPolicy：静默丢弃新任务。
  - DiscardOldestPolicy：丢弃队列中最旧的任务，然后重新提交新任务。

线程池的常用方法

提交任务

方法	说明
`void execute(Runnable task)`	提交一个无需返回值的任务（适合异步执行）。
`Future<T> submit(Callable<T> task)`	提交一个有返回值的任务，通过 `Future` 获取结果或异常。
`Future<?> submit(Runnable task)`	提交 `Runnable` 任务，返回的 `Future` 可用于判断任务是否完成。

示例：

ExecutorService executor = Executors.newFixedThreadPool(3);

// 使用 execute 提交任务（无返回值）
executor.execute(() -> {
    System.out.println("任务执行中...");
});

// 使用 submit 提交任务（有返回值）
Future<Integer> future = executor.submit(() -> {
    return 42;
});

try {
    int result = future.get(); // 获取任务结果
} catch (Exception e) {
    e.printStackTrace();
}

关闭线程池

方法	说明
`void shutdown()`	停止接收新任务，等待已提交任务执行完成。
`List<Runnable> shutdownNow()`	尝试立即停止所有任务，返回未执行的任务列表。
`boolean awaitTermination(long timeout, TimeUnit unit)`	阻塞等待线程池关闭，直到所有任务完成或超时。

示例：

executor.shutdown(); // 优雅关闭

// 强制关闭（立即终止）
List<Runnable> unfinishedTasks = executor.shutdownNow();

// 等待线程池关闭（最多等10秒）
if (!executor.awaitTermination(10, TimeUnit.SECONDS)) {
    System.out.println("线程池未完全关闭！");
}

监控线程池状态

方法	说明
`int getActiveCount()`	获取当前活动线程数。
`long getCompletedTaskCount()`	获取已完成任务数。
`int getPoolSize()`	获取当前线程池中的线程总数（核心 + 临时）。
`BlockingQueue<Runnable> getQueue()`	获取任务队列，可进一步查询队列大小。

示例：

System.out.println("活动线程数：" + executor.getActiveCount());
System.out.println("已完成任务数：" + executor.getCompletedTaskCount());
System.out.println("队列中的任务数：" + executor.getQueue().size());

通过 `Executors` 快速创建线程池

Executors 提供了一些静态方法创建预配置的线程池：

方法	说明
`newFixedThreadPool(int nThreads)`	创建固定大小的线程池（核心线程数 = 最大线程数）。
`newCachedThreadPool()`	创建可缓存的线程池（核心线程数为0，最大线程数为 `Integer.MAX_VALUE`）。
`newSingleThreadExecutor()`	创建单线程的线程池（所有任务按顺序执行）。
`newScheduledThreadPool(int corePoolSize)`	创建支持定时任务的线程池。

示例：

// 创建固定大小的线程池
ExecutorService fixedPool = Executors.newFixedThreadPool(3);

// 创建可缓存的线程池
ExecutorService cachedPool = Executors.newCachedThreadPool();

// 创建单线程池
ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();

// 创建定时任务线程池
ScheduledExecutorService scheduledPool = Executors.newScheduledThreadPool(2);

线程池的完整示例

以下是一个结合构造方法、任务提交和关闭的完整示例：

import java.util.concurrent.*;

public class ComprehensiveThreadPoolExample {
    public static void main(String[] args) {
        // 1. 创建自定义线程池
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            2,                              // 核心线程数
            4,                              // 最大线程数
            60, TimeUnit.SECONDS,           // 临时线程存活时间
            new ArrayBlockingQueue<>(10),   // 有界队列（容量10）
            Executors.defaultThreadFactory(), // 默认线程工厂
            new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略
        );

        // 2. 提交20个任务（触发拒绝策略）
        for (int i = 1; i <= 20; i++) {
            final int taskId = i;
            try {
                executor.execute(() -> {
                    System.out.println("任务 " + taskId + " 由线程 " + Thread.currentThread().getName() + " 执行");
                    try {
                        Thread.sleep(1000); // 模拟耗时操作
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                });
            } catch (RejectedExecutionException e) {
                System.out.println("任务 " + taskId + " 被拒绝！");
            }
        }

        // 3. 监控线程池状态
        System.out.println("活动线程数: " + executor.getActiveCount());
        System.out.println("队列大小: " + executor.getQueue().size());

        // 4. 关闭线程池
        executor.shutdown();
        try {
            if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                executor.shutdownNow();
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
        }
    }
}

输出示例：

任务 1 由线程 pool-1-thread-1 执行
任务 2 由线程 pool-1-thread-2 执行
任务 3 由线程 pool-1-thread-3 执行  // 临时线程创建
...
任务 15 由线程 main 执行         // 触发 CallerRunsPolicy
任务 16 被拒绝！                // 队列和线程均满

常见问题与解决方案

任务被拒绝怎么办？
- 方案：根据业务需求选择合适的拒绝策略（如记录日志、降级处理或重试）。
如何避免内存溢出？
- 方案：避免使用无界队列（如 LinkedBlockingQueue 需设置容量）。
如何处理任务中的异常？
- 方案：在任务内部使用 try-catch，或通过 Future.get() 捕获异常。
如何动态调整线程池参数？
- 方案：使用 setCorePoolSize() 和 setMaximumPoolSize() 方法（需谨慎）。

总结

核心思想：线程池通过复用线程、管理任务队列和拒绝策略，提升系统性能和稳定性。
关键配置：核心线程数、最大线程数、队列类型和拒绝策略。
最佳实践：
1. 根据任务类型（CPU/I/O 密集）配置线程数。
2. 使用有界队列防止内存溢出。
3. 始终在 finally 块中关闭线程池。