在 Java 开发中，线程池是一项非常重要的技术，它能大大提升程序的性能和效率。通过合理地设计线程池，我们可以避免频繁创建和销毁线程带来的开销，同时更好地管理系统资源。接下来，我们就来详细探讨如何设计高性能的 Java 线程池，包括核心参数和拒绝策略。
一、线程池核心参数
1. corePoolSize（核心线程数）
核心线程数是线程池的基础配置，它表示线程池始终保持存活的线程数量。当有新任务提交时，如果当前线程池中的线程数量小于核心线程数，线程池会创建新的线程来处理任务。 示例代码：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class CorePoolSizeExample {
public static void main(String[] args) {
// 创建一个核心线程数为 2 的线程池
ExecutorService executorService = Executors.newFixedThreadPool(2);
// 提交 3 个任务
for (int i = 0; i < 3; i++) {
final int taskId = i;
executorService.submit(() -> {
System.out.println("Task " + taskId + " is running on thread: " + Thread.currentThread().getName());
try {
// 模拟任务执行时间
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Task " + taskId + " is completed.");
});
}
// 关闭线程池
executorService.shutdown();
}
}
在这个示例中，我们创建了一个核心线程数为 2 的线程池，并提交了 3 个任务。由于核心线程数为 2，所以一开始会创建 2 个线程来处理任务，第 3 个任务会在前面的任务完成后再由空闲的线程处理。
2. maximumPoolSize（最大线程数）
最大线程数是线程池所能容纳的最大线程数量。当任务队列已满，且当前线程数小于最大线程数时，线程池会创建新的线程来处理任务，直到达到最大线程数。 示例代码：
import java.util.concurrent.*;
public class MaximumPoolSizeExample {
public static void main(String[] args) {
// 创建一个线程池，核心线程数为 2，最大线程数为 4，任务队列容量为 2
ThreadPoolExecutor executor = new ThreadPoolExecutor(
2, // 核心线程数
4, // 最大线程数
60, TimeUnit.SECONDS, // 线程空闲时间
new ArrayBlockingQueue<>(2) // 任务队列
);
// 提交 6 个任务
for (int i = 0; i < 6; i++) {
final int taskId = i;
executor.submit(() -> {
System.out.println("Task " + taskId + " is running on thread: " + Thread.currentThread().getName());
try {
// 模拟任务执行时间
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Task " + taskId + " is completed.");
});
}
// 关闭线程池
executor.shutdown();
}
}
在这个示例中，核心线程数为 2，任务队列容量为 2，最大线程数为 4。当提交 6 个任务时，前 2 个任务由核心线程处理，接下来 2 个任务会被放入任务队列，最后 2 个任务会创建新的线程来处理，因为此时任务队列已满且线程数小于最大线程数。
3. keepAliveTime（线程空闲时间）
线程空闲时间表示当线程池中的线程数量超过核心线程数时，空闲线程在被销毁之前等待新任务的最长时间。如果在这个时间内没有新任务到来，空闲线程会被销毁。 示例代码：
import java.util.concurrent.*;
public class KeepAliveTimeExample {
public static void main(String[] args) throws InterruptedException {
// 创建一个线程池，核心线程数为 2，最大线程数为 4，线程空闲时间为 2 秒
ThreadPoolExecutor executor = new ThreadPoolExecutor(
2, // 核心线程数
4, // 最大线程数
2, TimeUnit.SECONDS, // 线程空闲时间
new ArrayBlockingQueue<>(2) // 任务队列
);
// 提交 4 个任务
for (int i = 0; i < 4; i++) {
final int taskId = i;
executor.submit(() -> {
System.out.println("Task " + taskId + " is running on thread: " + Thread.currentThread().getName());
try {
// 模拟任务执行时间
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Task " + taskId + " is completed.");
});
}
// 等待一段时间，让线程空闲
Thread.sleep(3000);
// 打印当前线程池中的线程数量
System.out.println("Current active threads: " + executor.getActiveCount());
// 关闭线程池
executor.shutdown();
}
}
在这个示例中，我们设置线程空闲时间为 2 秒。当任务执行完后，等待 3 秒，此时超过空闲时间的线程会被销毁，我们可以看到线程池中的活动线程数量会减少。
4. TimeUnit（时间单位）
时间单位用于指定 keepAliveTime 的时间单位，常见的有 TimeUnit.SECONDS、TimeUnit.MILLISECONDS 等。 示例代码：
import java.util.concurrent.*;
public class TimeUnitExample {
public static void main(String[] args) {
// 创建一个线程池，核心线程数为 2，最大线程数为 4，线程空闲时间为 500 毫秒
ThreadPoolExecutor executor = new ThreadPoolExecutor(
2, // 核心线程数
4, // 最大线程数
500, TimeUnit.MILLISECONDS, // 线程空闲时间
new ArrayBlockingQueue<>(2) // 任务队列
);
// 提交任务等操作...
executor.shutdown();
}
}
在这个示例中，我们将线程空闲时间的单位设置为毫秒。
5. workQueue（任务队列）
任务队列用于存储当线程池中的线程都在忙碌时提交的任务。常见的任务队列有 ArrayBlockingQueue、LinkedBlockingQueue、SynchronousQueue 等。 示例代码：
import java.util.concurrent.*;
public class WorkQueueExample {
public static void main(String[] args) {
// 创建一个线程池，使用 ArrayBlockingQueue 作为任务队列
ThreadPoolExecutor executor = new ThreadPoolExecutor(
2, // 核心线程数
4, // 最大线程数
60, TimeUnit.SECONDS, // 线程空闲时间
new ArrayBlockingQueue<>(2) // 任务队列
);
// 提交任务等操作...
executor.shutdown();
}
}
在这个示例中，我们使用了 ArrayBlockingQueue 作为任务队列，它是一个有界队列，容量为 2。
6. threadFactory（线程工厂）
线程工厂用于创建线程，我们可以通过自定义线程工厂来设置线程的名称、优先级等属性。 示例代码：
import java.util.concurrent.*;
public class ThreadFactoryExample {
public static void main(String[] args) {
// 自定义线程工厂
ThreadFactory threadFactory = new ThreadFactory() {
private int threadCount = 1;
@Override
public Thread newThread(Runnable r) {
Thread thread = new Thread(r, "CustomThread-" + threadCount++);
return thread;
}
};
// 创建一个线程池，使用自定义线程工厂
ThreadPoolExecutor executor = new ThreadPoolExecutor(
2, // 核心线程数
4, // 最大线程数
60, TimeUnit.SECONDS, // 线程空闲时间
new ArrayBlockingQueue<>(2), // 任务队列
threadFactory // 线程工厂
);
// 提交任务等操作...
executor.shutdown();
}
}
在这个示例中，我们自定义了一个线程工厂，为创建的线程设置了自定义的名称。
7. handler（拒绝策略）
当任务队列已满，且线程池中的线程数量达到最大线程数时，新提交的任务会触发拒绝策略。
二、拒绝策略详解
1. AbortPolicy（默认拒绝策略）
AbortPolicy 是线程池的默认拒绝策略，当触发拒绝策略时，会抛出 RejectedExecutionException 异常。 示例代码：
import java.util.concurrent.*;
public class AbortPolicyExample {
public static void main(String[] args) {
// 创建一个线程池，核心线程数为 2，最大线程数为 4，任务队列容量为 2
ThreadPoolExecutor executor = new ThreadPoolExecutor(
2, // 核心线程数
4, // 最大线程数
60, TimeUnit.SECONDS, // 线程空闲时间
new ArrayBlockingQueue<>(2), // 任务队列
new ThreadPoolExecutor.AbortPolicy() // 拒绝策略
);
// 提交 7 个任务，会触发拒绝策略
for (int i = 0; i < 7; i++) {
final int taskId = i;
try {
executor.submit(() -> {
System.out.println("Task " + taskId + " is running on thread: " + Thread.currentThread().getName());
try {
// 模拟任务执行时间
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Task " + taskId + " is completed.");
});
} catch (RejectedExecutionException e) {
System.out.println("Task " + taskId + " is rejected.");
}
}
// 关闭线程池
executor.shutdown();
}
}
在这个示例中，由于任务队列容量为 2，最大线程数为 4，当提交 7 个任务时，会触发拒绝策略，抛出 RejectedExecutionException 异常。
2. CallerRunsPolicy
CallerRunsPolicy 策略会让提交任务的线程来执行被拒绝的任务。 示例代码：
import java.util.concurrent.*;
public class CallerRunsPolicyExample {
public static void main(String[] args) {
// 创建一个线程池，核心线程数为 2，最大线程数为 4，任务队列容量为 2
ThreadPoolExecutor executor = new ThreadPoolExecutor(
2, // 核心线程数
4, // 最大线程数
60, TimeUnit.SECONDS, // 线程空闲时间
new ArrayBlockingQueue<>(2), // 任务队列
new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略
);
// 提交 7 个任务，会触发拒绝策略
for (int i = 0; i < 7; i++) {
final int taskId = i;
executor.submit(() -> {
System.out.println("Task " + taskId + " is running on thread: " + Thread.currentThread().getName());
try {
// 模拟任务执行时间
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Task " + taskId + " is completed.");
});
}
// 关闭线程池
executor.shutdown();
}
}
在这个示例中，当触发拒绝策略时，被拒绝的任务会由提交任务的线程（通常是主线程）来执行。
3. DiscardPolicy
DiscardPolicy 策略会直接丢弃被拒绝的任务，不会抛出异常。 示例代码：
import java.util.concurrent.*;
public class DiscardPolicyExample {
public static void main(String[] args) {
// 创建一个线程池，核心线程数为 2，最大线程数为 4，任务队列容量为 2
ThreadPoolExecutor executor = new ThreadPoolExecutor(
2, // 核心线程数
4, // 最大线程数
60, TimeUnit.SECONDS, // 线程空闲时间
new ArrayBlockingQueue<>(2), // 任务队列
new ThreadPoolExecutor.DiscardPolicy() // 拒绝策略
);
// 提交 7 个任务，会触发拒绝策略
for (int i = 0; i < 7; i++) {
final int taskId = i;
executor.submit(() -> {
System.out.println("Task " + taskId + " is running on thread: " + Thread.currentThread().getName());
try {
// 模拟任务执行时间
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Task " + taskId + " is completed.");
});
}
// 关闭线程池
executor.shutdown();
}
}
在这个示例中，当触发拒绝策略时，被拒绝的任务会被直接丢弃，不会有任何提示。
4. DiscardOldestPolicy
DiscardOldestPolicy 策略会丢弃任务队列中最老的任务，然后尝试重新提交被拒绝的任务。 示例代码：
import java.util.concurrent.*;
public class DiscardOldestPolicyExample {
public static void main(String[] args) {
// 创建一个线程池，核心线程数为 2，最大线程数为 4，任务队列容量为 2
ThreadPoolExecutor executor = new ThreadPoolExecutor(
2, // 核心线程数
4, // 最大线程数
60, TimeUnit.SECONDS, // 线程空闲时间
new ArrayBlockingQueue<>(2), // 任务队列
new ThreadPoolExecutor.DiscardOldestPolicy() // 拒绝策略
);
// 提交 7 个任务，会触发拒绝策略
for (int i = 0; i < 7; i++) {
final int taskId = i;
executor.submit(() -> {
System.out.println("Task " + taskId + " is running on thread: " + Thread.currentThread().getName());
try {
// 模拟任务执行时间
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Task " + taskId + " is completed.");
});
}
// 关闭线程池
executor.shutdown();
}
}
在这个示例中，当触发拒绝策略时，任务队列中最老的任务会被丢弃，然后尝试重新提交被拒绝的任务。
三、应用场景
1. 高并发任务处理
在电商系统的秒杀活动中，会有大量的用户请求同时到来。使用线程池可以高效地处理这些请求，避免因频繁创建和销毁线程导致系统性能下降。可以根据系统的硬件资源和预估的并发量来合理设置线程池的核心参数，确保系统的稳定性和响应速度。
2. 异步任务处理
在 Web 应用中，一些耗时的操作（如发送邮件、生成报表等）可以使用线程池进行异步处理。这样可以避免阻塞主线程，提高用户体验。例如，当用户注册成功后，系统可以将发送欢迎邮件的任务提交到线程池中异步执行，主线程可以继续处理其他业务逻辑。
四、技术优缺点
优点
- 提高性能：避免了频繁创建和销毁线程的开销，提高了系统的响应速度和吞吐量。
- 资源管理：可以更好地控制线程的数量和资源使用，防止系统因线程过多而崩溃。
- 可扩展性：可以根据不同的业务需求和系统负载，灵活调整线程池的核心参数。
缺点
- 配置复杂：线程池的核心参数较多，需要根据具体的应用场景进行合理配置，否则可能会导致性能不佳。
- 死锁风险：如果线程池中的任务存在依赖关系，可能会导致死锁问题，需要进行仔细的设计和测试。
五、注意事项
- 合理配置核心参数：要根据系统的硬件资源、业务需求和预估的并发量来合理设置核心线程数、最大线程数、任务队列容量等参数。
- 选择合适的拒绝策略：不同的拒绝策略适用于不同的场景，需要根据实际情况进行选择。例如，对于一些对数据准确性要求不高的任务，可以选择 DiscardPolicy 或 DiscardOldestPolicy；对于一些对任务执行要求较高的场景，可以选择 AbortPolicy 或 CallerRunsPolicy。
- 异常处理：在线程池中的任务执行过程中，要进行充分的异常处理，避免因异常导致线程池中的线程崩溃。
六、文章总结
设计高性能的 Java 线程池需要深入理解核心参数和拒绝策略。核心参数如核心线程数、最大线程数、线程空闲时间、任务队列等，它们相互配合，共同决定了线程池的性能和行为。拒绝策略则在任务队列已满且线程数达到最大时发挥作用，不同的拒绝策略适用于不同的场景。
评论