java 线程池避免 oom 的核心做法是限制队列容量并配置饱和拒绝策略,防止任务堆积撑爆堆内存。具体实现时,应使用有界队列如 arrayblockingqueue 替代无界队列,并在提交任务时设置 rejectedexecutionhandler 处理无法入队的任务。这样当系统负载过高时,线程池会直接拒绝新任务而非无限排队,从而保护 jvm 不被 oom 击垮。

为什么无界队列会导致 OOM
在 Java 中,如果线程池使用了无界队列(如 LinkedBlockingQueue),且生产者的速度远快于消费者的处理速度,队列会不断累积任务对象。这些任务对象及其关联的数据结构会一直占用堆内存,直到触发 OutOfMemoryError。因此,必须明确队列的边界。

import java.util.concurrent.*;
public class SafeThreadPool {
public static void main(String[] args) {
// 核心线程数5,最大线程数10,空闲存活60秒
ThreadPoolExecutor executor = new ThreadPoolExecutor(
5, 10, 60L, TimeUnit.SECONDS,
new ArrayBlockingQueue(100), // 有界队列,容量100
new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略:调用者运行
);
for (int i = 0; i {
System.out.println("Task " + taskId + " running on " + Thread.currentThread().getName());
try { Thread.sleep(100); } catch (InterruptedException e) {}
});
} catch (Exception e) {
System.err.println("Task rejected: " + e.getMessage());
}
}
executor.shutdown();
}
}
上述代码中,ArrayBlockingQueue 限制了队列最多容纳 100 个任务。当活跃线程达到 10 个且队列满时,后续提交的任务将触发 CallerRunsPolicy,由提交任务的线程直接执行,这既起到了背压作用,又避免了任务丢失或无限堆积导致的 OOM。
如何选择合适的拒绝策略
当队列满且线程池达到最大线程数时,必须通过拒绝策略来处理新任务。常见的策略包括 AbortPolicy(抛出异常)、DiscardPolicy(静默丢弃)和 CallerRunsPolicy(调用者运行)。选择哪种策略取决于业务对数据一致性和吞吐量的要求。

import java.util.concurrent.*;
public class RejectionDemo {
public static void main(String[] args) {
ThreadPoolExecutor executor = new ThreadPoolExecutor(
2, 2, 0L, TimeUnit.SECONDS,
new ArrayBlockingQueue(1),
new ThreadPoolExecutor.DiscardOldestPolicy()
);
for (int i = 0; i {
System.out.println("Executing task " + id);
try { Thread.sleep(500); } catch (InterruptedException e) {}
});
// 模拟快速提交填满队列和线程池
if (i == 2) {
try { Thread.sleep(10); } catch (InterruptedException e) {}
}
}
executor.shutdown();
}
}
在上面的示例中,DiscardOldestPolicy 会在拒绝新任务时丢弃队列中最老的任务。这种策略适用于可以容忍少量任务丢失的场景,如日志收集或监控数据上报。相比之下,CallerRunsPolicy 虽然会降低提交线程的速度,但能保证所有任务最终被执行,适合对数据完整性要求较高的场景。
动态调整线程池参数以应对突发流量
在实际生产中,固定大小的线程池可能无法适应波动的流量。可以通过继承 ThreadPoolExecutor 并重写 beforeExecute 和 afterExecute 方法,或者结合监控指标动态调整核心线程数和队列大小。例如,当队列长度超过阈值时,自动增加最大线程数以提升处理能力。
import java.util.concurrent.*;
public class DynamicThreadPool extends ThreadPoolExecutor {
public DynamicThreadPool(int corePoolSize, int maximumPoolSize,
long keepAliveTime, TimeUnit unit, BlockingQueue<runnable> workQueue) {
super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
}
@Override
protected void afterExecute(Runnable r, Throwable t) {
super.afterExecute(r, t);
// 简单示例:根据队列长度动态调整
if (getQueue().size() > getMaximumPoolSize()) {
System.out.println("Queue full, consider increasing max pool size");
}
}
}
public class Main {
public static void main(String[] args) {
DynamicThreadPool pool = new DynamicThreadPool(5, 20, 60, TimeUnit.SECONDS, new ArrayBlockingQueue(50));
pool.submit(() -> System.out.println("Dynamic task"));
pool.shutdown();
}
}</runnable>
通过这种方式,线程池可以在高负载时自动扩展资源,而在低负载时回收资源,从而在性能和稳定性之间取得平衡。关键在于监控队列深度和线程活跃度,并据此调整参数,避免静态配置带来的 OOM 风险。
Java免费学习笔记:立即使用
解锁 Java 大师之旅:从入门到精通的终极指南











