Java线程池详解

在Java多线程编程中，线程池是一种非常重要的技术。它能够有效地管理和复用线程资源，避免频繁创建和销毁线程带来的性能开销。详细讲解Java线程池的使用方法，并提供多种解决方案。

开头解决方案

线程池的核心思想是通过预先创建一定数量的线程来处理任务，从而避免了每次执行任务时都需要创建新线程的开销。Java提供了Executor框架来简化线程池的使用，其中最常用的类是ThreadPoolExecutor。通过合理配置线程池参数，我们可以根据实际需求选择合适的线程池类型，例如固定大小线程池、缓存线程池或单线程线程池。

一、线程池的基本概念

线程池的主要目的是重用已创建的线程，减少线程创建和销毁的开销。Java中的线程池主要由以下几部分组成：

核心线程数（corePoolSize）：线程池中保持的最小线程数。
线程数（maximumPoolSize）：线程池中允许的线程数。
任务队列（workQueue）：用于保存等待执行的任务。
线程工厂（threadFactory）：用于创建新线程。
拒绝策略（handler）：当线程池无法处理新任务时的处理策略。

二、线程池的创建与使用

Java提供了Executors类来快速创建不同类型的线程池。以下是几种常见的线程池类型及其代码示例。

1. 固定大小线程池

固定大小线程池会在创建时指定一个固定的线程数，所有任务都将在这些线程中执行。

java
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;</p>

<p>public class FixedThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(3); // 创建一个包含3个线程的线程池</p>

<pre><code>    for (int i = 0; i < 5; i++) {
        final int taskNumber = i;
        executor.submit(() -> {
            System.out.println("Task " + taskNumber + " is running on thread " + Thread.currentThread().getName());
        });
    }

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

}

2. 缓存线程池

缓存线程池会根据需要创建新线程，但在之前创建的线程可用时将重用它们。

java
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;</p>

<p>public class CachedThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool(); // 创建一个缓存线程池</p>

<pre><code>    for (int i = 0; i < 10; i++) {
        final int taskNumber = i;
        executor.submit(() -> {
            System.out.println("Task " + taskNumber + " is running on thread " + Thread.currentThread().getName());
        });
    }

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

}

3. 单线程线程池

单线程线程池确保所有任务都在同一个线程中按顺序执行。

java
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;</p>

<p>public class SingleThreadExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor(); // 创建一个单线程线程池</p>

<pre><code>    for (int i = 0; i < 5; i++) {
        final int taskNumber = i;
        executor.submit(() -> {
            System.out.println("Task " + taskNumber + " is running on thread " + Thread.currentThread().getName());
        });
    }

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

}

三、自定义线程池

如果内置的线程池类型无法满足需求，我们可以通过ThreadPoolExecutor类来自定义线程池。

java
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;</p>

<p>public class CustomThreadPoolExample {
    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            2, // 核心线程数
            4, // 线程数
            60L, // 空闲线程的存活时间
            TimeUnit.SECONDS, // 时间单位
            new ArrayBlockingQueue<>(3) // 任务队列，最多容纳3个任务
        );</p>

<pre><code>    for (int i = 0; i < 10; i++) {
        final int taskNumber = i;
        executor.submit(() -> {
            System.out.println("Task " + taskNumber + " is running on thread " + Thread.currentThread().getName());
        });
    }

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

}

四、线程池的拒绝策略

当线程池中的任务队列已满且无法创建新线程时，线程池会触发拒绝策略。Java提供了以下几种内置的拒绝策略：

AbortPolicy：直接抛出RejectedExecutionException异常。
CallerRunsPolicy：由调用线程执行该任务。
DiscardPolicy：直接丢弃任务，不抛出异常。
DiscardOldestPolicy：丢弃任务队列中最旧的任务，然后尝试重新提交当前任务。

以下是一个使用自定义拒绝策略的示例：

java
import java.util.concurrent.*;</p>

<p>public class RejectedExecutionHandlerExample {
    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            2, // 核心线程数
            4, // 线程数
            60L, // 空闲线程的存活时间
            TimeUnit.SECONDS, // 时间单位
            new ArrayBlockingQueue<>(3), // 任务队列，最多容纳3个任务
            new ThreadPoolExecutor.CallerRunsPolicy() // 使用CallerRunsPolicy拒绝策略
        );</p>

<pre><code>    for (int i = 0; i < 10; i++) {
        final int taskNumber = i;
        try {
            executor.submit(() -> {
                System.out.println("Task " + taskNumber + " is running on thread " + Thread.currentThread().getName());
            });
        } catch (RejectedExecutionException e) {
            System.out.println("Task " + taskNumber + " was rejected.");
        }
    }

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

}

五、线程池的关闭方式

线程池的关闭非常重要，如果不正确地关闭线程池，可能会导致程序无法正常退出。

shutdown()：平滑地关闭线程池，不再接受新任务，但会继续执行已提交的任务。
shutdownNow()：立即关闭线程池，尝试停止所有正在执行的任务，并返回等待执行的任务列表。

java
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;</p>

<p>public class ShutdownExample {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(3);</p>

<pre><code>    for (int i = 0; i < 5; i++) {
        final int taskNumber = i;
        executor.submit(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Task " + taskNumber + " is running on thread " + Thread.currentThread().getName());
        });
    }

    // 平滑关闭线程池
    executor.shutdown();
    if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
        executor.shutdownNow(); // 强制关闭线程池
    }
}

}

通过的讲解，我们了解了Java线程池的基本概念、创建方式以及如何自定义线程池。线程池的合理使用可以显著提升程序的性能和稳定性。在实际开发中，我们需要根据具体的业务场景选择合适的线程池类型和配置参数，同时注意线程池的关闭方式以避免资源泄漏。

// 来源：https://www.nzw6.com