Java 线程池与内存管理
2021-04-025.9k 阅读
Java 线程池基础
在 Java 中，线程池是一种管理和复用线程的机制。通过线程池，可以避免频繁地创建和销毁线程带来的开销，提高系统的性能和资源利用率。
Java 提供了 java.util.concurrent.Executor 框架来支持线程池的创建和管理。其中，Executor 接口是线程池的基础，它只有一个方法 execute(Runnable task)，用于提交一个任务到线程池中执行。
ExecutorService 接口继承自 Executor，提供了更多管理线程池生命周期和任务执行的方法，比如 shutdown() 用于平滑关闭线程池，submit(Callable<T> task) 用于提交一个有返回值的任务等。
ThreadPoolExecutor 类是 ExecutorService 接口的主要实现类，它提供了丰富的构造函数来创建不同配置的线程池。以下是一个简单的线程池创建示例：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExample {
public static void main(String[] args) {
// 创建一个固定大小为 5 的线程池
ExecutorService executorService = Executors.newFixedThreadPool(5);
for (int i = 0; i < 10; i++) {
int taskNumber = i;
executorService.submit(() -> {
System.out.println("Task " + taskNumber + " is running on thread " + Thread.currentThread().getName());
// 模拟任务执行
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
});
}
// 关闭线程池
executorService.shutdown();
}
}
在上述代码中，我们使用 Executors.newFixedThreadPool(5) 创建了一个固定大小为 5 的线程池。然后提交了 10 个任务到线程池中执行。由于线程池大小为 5，所以同一时间最多有 5 个任务在执行，其余任务会在队列中等待。
线程池的核心参数
ThreadPoolExecutor 的构造函数如下：
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
- corePoolSize：核心线程数。线程池会一直维护至少
corePoolSize数量的线程，即使这些线程处于空闲状态也不会被销毁，除非设置了allowCoreThreadTimeOut(true)。 - maximumPoolSize：最大线程数。线程池允许创建的最大线程数。当任务队列已满且当前线程数小于
maximumPoolSize时，线程池会创建新的线程来处理任务。 - keepAliveTime：存活时间。当线程数大于
corePoolSize时，多余的空闲线程在存活时间内没有任务可执行，就会被销毁。 - unit：存活时间的单位，比如
TimeUnit.SECONDS表示秒。 - workQueue：任务队列。用于存放等待执行的任务。常见的任务队列有
ArrayBlockingQueue、LinkedBlockingQueue、SynchronousQueue等。 - threadFactory：线程工厂。用于创建新的线程，可以设置线程的名称、优先级等属性。
- handler：拒绝策略。当任务队列已满且线程数达到
maximumPoolSize时，新提交的任务会被拒绝，此时会调用拒绝策略来处理被拒绝的任务。常见的拒绝策略有AbortPolicy（抛出异常）、CallerRunsPolicy（由调用者线程来执行任务）、DiscardPolicy（直接丢弃任务）、DiscardOldestPolicy（丢弃队列中最老的任务，然后尝试提交新任务）。
线程池的工作流程
- 当一个任务提交到线程池时，首先会检查核心线程是否都在执行任务。如果有核心线程空闲，则将任务分配给空闲的核心线程执行。
- 如果所有核心线程都在执行任务，且任务队列未满，则将任务放入任务队列中等待执行。
- 如果任务队列已满，且当前线程数小于
maximumPoolSize，则创建新的线程来执行任务。 - 如果任务队列已满且线程数达到
maximumPoolSize，则根据拒绝策略来处理新提交的任务。
例如，我们使用不同的任务队列和拒绝策略来创建线程池：
import java.util.concurrent.*;
public class ThreadPoolWorkflowExample {
public static void main(String[] args) {
// 创建一个容量为 3 的有界队列
BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(3);
// 创建线程池，核心线程数为 2，最大线程数为 4，存活时间为 10 秒
ThreadPoolExecutor executor = new ThreadPoolExecutor(
2,
4,
10,
TimeUnit.SECONDS,
workQueue,
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.CallerRunsPolicy()
);
for (int i = 0; i < 10; i++) {
int taskNumber = i;
executor.submit(() -> {
System.out.println("Task " + taskNumber + " is running on thread " + Thread.currentThread().getName());
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
});
}
executor.shutdown();
}
}
在这个示例中，我们使用了 ArrayBlockingQueue 作为任务队列，容量为 3。核心线程数为 2，最大线程数为 4。当提交 10 个任务时，首先 2 个任务会由核心线程执行，接着 3 个任务会放入队列，再创建 2 个新线程执行任务，此时线程池已满，剩余 3 个任务会按照 CallerRunsPolicy 策略，由调用者线程（即主线程）来执行。
Java 内存管理基础
Java 的内存管理主要涉及堆内存和栈内存。
栈内存：主要用于存储局部变量、方法参数和方法调用的上下文等。每个线程都有自己独立的栈，栈的大小在创建线程时确定。当方法被调用时，会在栈中分配一块栈帧，用于存储该方法的局部变量和中间计算结果等。当方法执行完毕，栈帧会被销毁，局部变量占用的空间也会被释放。
堆内存：是 Java 程序中对象存储的主要区域。所有通过 new 关键字创建的对象都存放在堆内存中。堆内存由 JVM 自动管理，负责对象的分配和回收。JVM 采用分代垃圾回收机制来管理堆内存，将堆分为新生代、老年代和永久代（Java 8 及以后为元空间）。
新生代：主要存放新创建的对象，又分为 Eden 区和两个 Survivor 区（一般称为 S0 和 S1）。大多数对象在 Eden 区创建，当 Eden 区满时，会触发 Minor GC，将存活的对象复制到其中一个 Survivor 区（比如 S0），如果 Survivor 区也满了，就会将存活时间较长的对象晋升到老年代。
老年代：存放经过多次 Minor GC 仍然存活的对象，当老年代满时，会触发 Major GC（也称为 Full GC），回收老年代的垃圾对象。
元空间（Java 8 及以后）：在 Java 8 之前，类的元数据信息存放在永久代中，永久代的大小在启动 JVM 时就固定了，容易出现内存溢出问题。从 Java 8 开始，使用元空间代替永久代，元空间使用本地内存，其大小只受本地内存限制。
线程池与内存管理的关系
- 线程内存占用：每个线程都需要占用一定的栈内存空间，线程池中的线程也不例外。如果线程池中的线程数量过多，会消耗大量的栈内存。例如，默认情况下，在 64 位 JVM 中，每个线程的栈大小约为 1MB。如果创建 1000 个线程，仅栈内存就需要 1GB。因此，合理设置线程池的大小对于避免内存溢出非常重要。
- 任务对象内存占用：线程池中的任务通常是实现了
Runnable或Callable接口的对象。这些任务对象在执行过程中可能会创建大量其他对象，占用堆内存。如果任务执行时间过长且不断创建新对象，可能导致堆内存不足。例如，以下任务在执行过程中不断创建大对象：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class MemoryIntensiveTask {
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(10);
for (int i = 0; i < 100; i++) {
executorService.submit(() -> {
byte[] largeArray = new byte[1024 * 1024]; // 1MB 对象
// 模拟任务执行
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
});
}
executorService.shutdown();
}
}
在这个示例中，每个任务都创建了一个 1MB 的字节数组，如果线程池中有大量这样的任务同时执行，很容易导致堆内存溢出。
- 线程池缓存与内存管理：线程池中的线程在执行完任务后，并不会立即销毁，而是会被缓存起来，等待下一个任务。这意味着这些线程所占用的栈内存不会被释放。如果线程池长时间运行且任务执行频率较高，虽然避免了频繁创建和销毁线程的开销，但也会持续占用一定的内存。因此，需要根据实际应用场景，合理调整线程池的核心线程数和最大线程数，以及线程的存活时间，以平衡性能和内存占用。
优化线程池与内存管理的策略
- 合理设置线程池大小：根据系统的 CPU 核心数、I/O 负载等因素来确定线程池的大小。对于 CPU 密集型任务，线程池大小一般设置为 CPU 核心数 + 1，以充分利用 CPU 资源并避免线程上下文切换开销。对于 I/O 密集型任务，可以适当增大线程池大小，例如设置为 CPU 核心数 * 2，因为 I/O 操作会使线程处于等待状态，需要更多线程来提高系统利用率。
- 优化任务实现：在任务的实现中，尽量减少不必要的对象创建和内存占用。可以使用对象池技术来复用对象，避免频繁创建和销毁对象。例如，对于数据库连接对象，可以使用数据库连接池来复用连接，而不是每次执行数据库操作都创建新的连接。
- 监控和调优：使用 JVM 提供的工具，如
jconsole、jvisualvm等，监控线程池的运行状态和内存使用情况。通过分析监控数据，调整线程池的参数和任务实现，以达到最佳的性能和内存利用率。例如，通过观察堆内存的使用曲线，判断是否存在内存泄漏或对象创建过多的情况；通过观察线程池的任务队列长度和线程活跃数，判断线程池大小是否合适。
示例：优化后的线程池与内存管理
以下是一个优化后的示例，展示了如何根据任务类型合理设置线程池大小，并优化任务中的内存使用：
import java.util.concurrent.*;
// 模拟 I/O 密集型任务
class IOIntensiveTask implements Runnable {
@Override
public void run() {
try {
// 模拟 I/O 操作，如读取文件或网络请求
Thread.sleep(2000);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
// 模拟 CPU 密集型任务
class CPUIntensiveTask implements Runnable {
@Override
public void run() {
for (int i = 0; i < 100000000; i++) {
// 简单的 CPU 计算
Math.sqrt(i);
}
}
}
public class OptimizedThreadPoolExample {
public static void main(String[] args) {
// 获取 CPU 核心数
int cpuCores = Runtime.getRuntime().availableProcessors();
// 创建 I/O 密集型任务的线程池
ExecutorService ioExecutor = new ThreadPoolExecutor(
cpuCores * 2,
cpuCores * 2,
10,
TimeUnit.SECONDS,
new LinkedBlockingQueue<>()
);
// 创建 CPU 密集型任务的线程池
ExecutorService cpuExecutor = new ThreadPoolExecutor(
cpuCores + 1,
cpuCores + 1,
10,
TimeUnit.SECONDS,
new LinkedBlockingQueue<>()
);
// 提交 I/O 密集型任务
for (int i = 0; i < 10; i++) {
ioExecutor.submit(new IOIntensiveTask());
}
// 提交 CPU 密集型任务
for (int i = 0; i < 10; i++) {
cpuExecutor.submit(new CPUIntensiveTask());
}
ioExecutor.shutdown();
cpuExecutor.shutdown();
}
}
在上述示例中，我们根据 CPU 核心数分别为 I/O 密集型任务和 CPU 密集型任务创建了合适大小的线程池。同时，在任务实现中，尽量避免了不必要的内存占用。对于 I/O 密集型任务，通过 Thread.sleep 模拟 I/O 等待；对于 CPU 密集型任务，进行简单的 CPU 计算。这样可以在提高系统性能的同时，合理管理内存。
内存泄漏与线程池
内存泄漏是指程序中已经不再使用的对象，由于某些原因无法被垃圾回收器回收，导致这些对象持续占用内存，最终可能导致内存耗尽。在线程池中，内存泄漏可能发生在以下几种情况：
- 任务持有外部对象引用：如果任务对象持有对外部对象的强引用，而这些外部对象在任务执行完毕后不再需要，但由于任务对象在线程池中被缓存，导致外部对象无法被垃圾回收。例如：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class MemoryLeakExample {
private static class TaskWithLeak implements Runnable {
private final LargeObject largeObject;
public TaskWithLeak(LargeObject largeObject) {
this.largeObject = largeObject;
}
@Override
public void run() {
// 任务执行逻辑
System.out.println("Task is running");
}
}
private static class LargeObject {
private byte[] data = new byte[1024 * 1024]; // 1MB 对象
}
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(10);
for (int i = 0; i < 10; i++) {
LargeObject largeObject = new LargeObject();
executorService.submit(new TaskWithLeak(largeObject));
}
// 这里 largeObject 虽然在 main 方法中不再使用，但由于 TaskWithLeak 持有其引用，
// 导致 largeObject 无法被垃圾回收，可能造成内存泄漏
executorService.shutdown();
}
}
在这个例子中，TaskWithLeak 任务持有 LargeObject 的引用，即使 LargeObject 在 main 方法中不再被使用，由于任务在线程池中缓存，LargeObject 也无法被垃圾回收。
- 线程本地存储（ThreadLocal）的误用：
ThreadLocal用于在每个线程中存储独立的变量副本。如果不正确使用ThreadLocal，也可能导致内存泄漏。例如，在线程池中使用ThreadLocal时，如果没有在任务执行完毕后及时清理ThreadLocal中的数据，由于线程池中的线程会被复用，ThreadLocal中的数据可能会一直存在，占用内存。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadLocalMemoryLeakExample {
private static final ThreadLocal<LargeObject> threadLocal = ThreadLocal.withInitial(() -> new LargeObject());
private static class TaskWithThreadLocalLeak implements Runnable {
@Override
public void run() {
LargeObject object = threadLocal.get();
// 任务执行逻辑
System.out.println("Task is running");
// 没有清理 ThreadLocal 中的数据
}
}
private static class LargeObject {
private byte[] data = new byte[1024 * 1024]; // 1MB 对象
}
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(10);
for (int i = 0; i < 10; i++) {
executorService.submit(new TaskWithThreadLocalLeak());
}
// 这里由于没有清理 ThreadLocal 中的 LargeObject，随着线程的复用，
// 可能会导致大量 LargeObject 占用内存，造成内存泄漏
executorService.shutdown();
}
}
为了避免线程池中由于 ThreadLocal 导致的内存泄漏，应该在任务执行完毕后调用 threadLocal.remove() 方法清理数据。
避免内存泄漏的方法
- 使用弱引用或软引用：对于任务中持有外部对象引用的情况，可以考虑使用弱引用或软引用代替强引用。弱引用的对象在垃圾回收器扫描到它时，如果没有其他强引用指向它，就会被回收；软引用的对象在系统内存不足时会被回收。例如：
import java.lang.ref.WeakReference;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class WeakReferenceExample {
private static class TaskWithWeakReference implements Runnable {
private final WeakReference<LargeObject> weakReference;
public TaskWithWeakReference(LargeObject largeObject) {
this.weakReference = new WeakReference<>(largeObject);
}
@Override
public void run() {
LargeObject largeObject = weakReference.get();
if (largeObject != null) {
// 任务执行逻辑
System.out.println("Task is running with large object");
} else {
System.out.println("Large object has been garbage collected");
}
}
}
private static class LargeObject {
private byte[] data = new byte[1024 * 1024]; // 1MB 对象
}
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(10);
for (int i = 0; i < 10; i++) {
LargeObject largeObject = new LargeObject();
executorService.submit(new TaskWithWeakReference(largeObject));
}
// 这里即使 TaskWithWeakReference 持有 LargeObject 的弱引用，
// 当没有其他强引用指向 LargeObject 时，它仍可能被垃圾回收
executorService.shutdown();
}
}
- 及时清理 ThreadLocal：在使用
ThreadLocal的任务中，确保在任务执行完毕后调用threadLocal.remove()方法清理数据。例如：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class FixedThreadLocalExample {
private static final ThreadLocal<LargeObject> threadLocal = ThreadLocal.withInitial(() -> new LargeObject());
private static class TaskWithFixedThreadLocal implements Runnable {
@Override
public void run() {
LargeObject object = threadLocal.get();
// 任务执行逻辑
System.out.println("Task is running");
threadLocal.remove(); // 清理 ThreadLocal 中的数据
}
}
private static class LargeObject {
private byte[] data = new byte[1024 * 1024]; // 1MB 对象
}
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(10);
for (int i = 0; i < 10; i++) {
executorService.submit(new TaskWithFixedThreadLocal());
}
executorService.shutdown();
}
}
通过以上方法，可以有效地避免线程池中可能出现的内存泄漏问题，确保系统的稳定运行和高效的内存管理。
线程池与垃圾回收机制的交互
- 任务执行与垃圾回收触发：线程池中的任务在执行过程中会创建对象，这些对象占用堆内存。当堆内存的使用达到一定阈值时，会触发垃圾回收。例如，新生代的 Eden 区满时会触发 Minor GC。如果任务创建对象的速度很快，频繁触发垃圾回收，可能会影响系统性能。因为垃圾回收过程需要暂停应用线程（Stop - The - World），进行对象的标记、清理等操作。
- 线程池线程生命周期与垃圾回收：线程池中的线程在执行完任务后，不会立即销毁，而是被缓存起来等待下一个任务。这意味着这些线程所占用的栈内存不会被释放，直到线程池关闭或线程被销毁。从垃圾回收的角度看，只要线程存在，其栈中引用的对象就不会被回收，即使这些对象在业务逻辑上已经不再需要。例如，如果一个任务在执行过程中创建了一个大对象，并且该任务执行完毕后，大对象不再被其他地方引用，但由于执行该任务的线程被缓存在线程池中，大对象可能无法立即被垃圾回收。
- 优化建议：为了减少线程池与垃圾回收机制的冲突，可以采取以下措施：
- 合理设置堆内存大小：根据应用的内存需求，合理设置堆的初始大小和最大大小。如果堆内存设置过小，会频繁触发垃圾回收；如果设置过大，可能会导致单次垃圾回收时间过长。
- 调整垃圾回收器参数：根据应用的特点，选择合适的垃圾回收器，并调整其参数。例如，对于注重响应时间的应用，可以选择 CMS 或 G1 垃圾回收器，并调整相关参数，如 CMS 的
-XX:CMSInitiatingOccupancyFraction参数，用于设置老年代达到多少使用率时触发 CMS 垃圾回收。 - 优化任务逻辑：尽量减少任务执行过程中不必要的对象创建，及时释放不再使用的对象引用，以降低垃圾回收的压力。
示例：线程池与垃圾回收优化
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolGCExample {
private static class TaskWithObjectCreation implements Runnable {
@Override
public void run() {
byte[] largeArray = new byte[1024 * 1024]; // 1MB 对象
// 模拟任务执行
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
// 及时释放对象引用
largeArray = null;
}
}
public static void main(String[] args) {
// 设置堆内存参数，例如 -Xms512m -Xmx1024m
ExecutorService executorService = Executors.newFixedThreadPool(10);
for (int i = 0; i < 100; i++) {
executorService.submit(new TaskWithObjectCreation());
}
executorService.shutdown();
}
}
在上述示例中，任务在执行完毕后及时将 largeArray 置为 null，以便垃圾回收器能够及时回收该对象占用的内存。同时，通过设置合适的堆内存参数（-Xms512m -Xmx1024m），可以根据应用的内存需求调整堆的大小，减少垃圾回收对性能的影响。
总结线程池与内存管理要点
- 线程池方面：
- 深入理解线程池的核心参数，如核心线程数、最大线程数、存活时间、任务队列和拒绝策略等，根据任务类型（CPU 密集型或 I/O 密集型）合理设置这些参数，以平衡性能和资源消耗。
- 避免线程池中的线程数量过多，导致栈内存过度消耗，引发内存溢出问题。
- 注意线程池的生命周期管理，及时关闭不再使用的线程池，释放资源。
- 内存管理方面：
- 了解 Java 内存管理的基本原理，包括堆内存和栈内存的分配与回收机制，特别是分代垃圾回收机制。
- 在线程池任务中，优化对象的创建和使用，避免不必要的内存占用，例如使用对象池技术复用对象。
- 警惕内存泄漏问题，如任务持有外部对象强引用、
ThreadLocal的误用等情况，通过使用弱引用、软引用或及时清理ThreadLocal数据等方法避免内存泄漏。
- 两者交互方面：
- 认识到线程池中的任务执行和线程生命周期对垃圾回收的影响，合理设置堆内存大小和垃圾回收器参数，减少垃圾回收对性能的影响。
- 优化任务逻辑，及时释放不再使用的对象引用，降低垃圾回收压力，提高系统整体性能和稳定性。
通过对线程池和内存管理的深入理解与优化，可以构建高效、稳定的 Java 应用程序，充分利用系统资源，提升用户体验。在实际开发中，需要不断实践和调整，根据具体应用场景找到最合适的配置和实现方式。