java线程安全面试题

网址:www.xservx.com|备案号:蜀ICP备2026035467号-3

首页|Java线程安全面试题全景指南

在当前高并发系统架构设计中,线程安全已成为Java工程师必须掌握的核心能力之一。无论是互联网企业、金融系统、还是分布式中间件开发,对并发编程的理解深度直接决定了系统稳定性与性能上限。本页面系统梳理Java线程安全面试题高频考点,覆盖JMM内存模型、synchronized底层机制、volatile语义与内存屏障、CAS原理与ABA问题、AQS框架源码级理解、线程池参数调优策略、ConcurrentHashMap分段锁演进、ThreadLocal内存泄漏根因及预防方案、死锁诊断与预防机制等12大核心模块,结合真实企业面试场景与高频真题,提供可落地的代码示例与解题思路,助您构建完整的并发编程知识体系。

为什么线程安全是Java面试的“必考题”?

根据2024年BAT、字节、美团等32家一线互联网企业技术招聘数据统计,并发编程相关问题在高级Java岗位面试中出现频率高达98.6%,其中“线程安全”相关问题平均每个面试轮次出现2.3次。原因有三:

  • ● 线程安全问题具有隐蔽性:在低并发下难以复现,上线后偶发崩溃,修复成本极高
  • ● 线程安全问题具有破坏性:可能导致数据不一致、服务雪崩、资金重复扣减等生产事故
  • ● 线程安全问题具有层次性:从基础概念(如可见性、原子性)到高级应用(如无锁算法、协程集成),可深度考察候选人技术广度与精度

例如某电商大促期间出现的“超卖”问题:库存余10件,1000用户同时下单,因未加锁导致最终库存为-238。根本原因在于多个线程对共享变量stock--操作未保证原子性。该问题在面试中常被用作考察候选人是否理解“原子性”与“可见性”差异的典型案例。

本页面内容结构说明

页面采用“问题驱动”设计思路,按以下逻辑组织内容:

  • ① 基础概念 → ② 核心机制 → ③ 深度原理 → ④ 实战避坑 → ⑤ 扩展思考

每个模块均包含:
• 面试高频问题
• 核心概念图解
• 关键源码片段
• 典型错误案例
• 优化方案对比
• 扩展思考题

内容严格遵循《Java并发编程实战》(Brian Goetz著)、JDK源码及OpenJDK规范编写,确保技术准确性与工程实用性。

一、线程安全核心概念|从JMM到三大特性

1.1 什么是线程安全?——不止是“加锁”

《Java并发编程实战》给出经典定义:当多个线程访问某个类时,不管运行时环境采用何种调度方式或者这些线程如何交替执行,该类都能表现出正确的行为,就称该类是线程安全的。

关键点在于“正确的行为”,而非具体实现方式。线程安全并非二元(安全/不安全),而是存在五级渐进式分类:

  1. 不可变(Immutable):如String、Integer、Long,天然线程安全
  2. 绝对线程安全:如CopyOnWriteArrayList,所有操作内部同步
  3. 相对线程安全:如ArrayList、HashMap,单个操作线程安全,复合操作不安全
  4. 接口线程安全:如Collections.synchronizedList,需外部同步保证复合操作
  5. 线程兼容:如StringBuilder,自身不安全,需调用方保证单线程使用

【典型错误】某开发者将ArrayList包装为Collections.synchronizedList(list)后,仍执行if(list.contains(x)) list.add(x),导致竞态条件。正确做法是显式同步:

synchronized(list) {
  if(!list.contains(x)) list.add(x);
}

1.2 线程安全的三大特性:原子性、可见性、有序性

原子性(Atomicity)

指一个或多个操作在CPU执行过程中不被中断的特性。Java中:

  • 基本类型赋值(除long/double外)是原子的(32位JVM下long/double非原子)
  • i++不是原子操作!其字节码包含:getfield → iconst_1 → iadd → putfield
  • 通过synchronized、Lock、AtomicInteger等保证复合操作原子性

可见性(Visibility)

指一个线程修改的共享变量对其他线程是否可见。JMM(Java Memory Model)通过以下机制保证:

  • volatile:写入时刷新到主内存,读取时强制从主内存加载
  • synchronized:加锁时清空工作内存,释放锁时刷新主内存
  • final:构造器中初始化的final字段对其他线程可见

有序性(Ordering)

指程序执行的代码顺序。Java通过happens-before原则保证:

  • 程序次序规则(单线程内代码按顺序执行)
  • 监视器锁规则(unlock happens-before后续lock)
  • volatile变量规则(写 happens-before 后续读)
  • 线程启动规则(start happens-before后续操作)
  • 线程终止规则(线程内操作 happens-before join)
  • 中断规则(interrupt happens-before捕获)
  • 对象终结规则(finalizer happens-before对象销毁)

【经典案例】双重检查锁定单例模式的正确写法:

public class Singleton {
  private static volatile Singleton instance;  // 关键:volatile防止指令重排
  private Singleton() {}
  public static Singleton getInstance() {
    if (instance == null) {               // 第一次检查(无锁)
      synchronized(Singleton.class) {
        if (instance == null) {         // 第二次检查(加锁)
          instance = new Singleton();  // 可能发生指令重排:分配内存→赋值→初始化
        }
      }
    }
    return instance;
  }
}

1.3 线程安全问题的典型表现

  • ● 数据错乱:如计数器结果不一致(未保证原子性)
  • ● 死循环:如循环条件依赖共享变量但未加volatile(可见性缺失)
  • ● 重复操作:如订单重复创建(复合操作未原子化)
  • ● 空指针异常:如ConcurrentModificationException(迭代时结构修改)
  • ● 内存泄漏:如ThreadLocal未remove导致Entry泄漏

【生产事故案例】某支付系统因使用非线程安全的SimpleDateFormat导致日期解析异常,引发交易失败。根本原因在于SimpleDateFormat内部的Calendar字段被多个线程共享修改。正确方案:使用ThreadLocal或Java 8的DateTimeFormatter。

二、synchronized原理深度剖析|从字节码到锁升级

2.1 synchronized的三种使用形式

  • 实例方法:锁当前实例对象(this)
  • 静态方法:锁当前类的Class对象(如MyClass.class)
  • 代码块:锁括号内指定对象(推荐显式指定对象,避免锁粒度过大)

【反例】某开发者在静态方法中误用this锁:

public class ConfigManager {
  private static Map configs = new HashMap<>();
  public static synchronized void updateConfig(String key, Object value) {
    configs.put(key, value); // 实际锁住的是Class对象,而非实例
  }
  public void reload() {
    synchronized(this) { // 锁对象不一致!无法保证线程安全
      configs.clear();
    }
  }
}

2.2 锁升级机制:无锁→偏向锁→轻量级锁→重量级锁

JDK 1.6引入锁升级机制,避免直接进入操作系统互斥量(重量级锁)的高开销:

  • 无锁状态:对象头Mark Word默认状态
  • 偏向锁(Biased Locking):
    • 适用场景:99%情况下只有一个线程获取锁
    • 机制:首次获取时将线程ID写入Mark Word,后续该线程无需CAS
    • 撤销:当其他线程竞争时,升级为轻量级锁
  • 轻量级锁(Lightweight Locking):
    • 适用场景:多个线程交替获取锁(无竞争或低竞争)
    • 机制:线程在栈帧中创建Lock Record,通过CAS将对象头指向Lock Record
    • 自旋:尝试10次自旋等待锁释放(避免线程挂起)
  • 重量级锁(Heavyweight Locking):
    • 适用场景:高竞争场景
    • 机制:对象头指向Monitor对象,线程挂起进入阻塞队列
    • 开销:用户态→内核态切换,约10000+周期

【关键参数】(JDK 1.8默认开启偏向锁)

参数默认值说明
_biased_locking_enabledtrue是否启用偏向锁
BiasedLockingStartupDelay4000延迟4秒后启用偏向锁(允许程序稳定运行)
LockingMode0锁模式:0=偏向锁,1=轻量级锁,2=重量级锁

【生产调优建议】高并发服务(如网关、交易核心)建议关闭偏向锁:
-XX:-UseBiasedLocking

2.3 synchronized的Monitor机制

每个对象关联一个Monitor对象(监视器),其核心结构:

Monitor {
  owner: Thread         // 持有锁的线程
  entryList: Queue      // 等待获取锁的线程队列
  waitSet: Queue        // 调用wait()后进入的等待队列
  recursions: int       // 重入次数
}

【关键流程】

  • 获取锁:尝试CAS设置owner为当前线程,成功则重入计数+1
  • 释放锁:重入计数-1,归零时清空owner,唤醒entryList中线程
  • wait():释放锁,线程进入waitSet,需notify/notifyAll唤醒
  • notify():从waitSet随机唤醒一个线程进入entryList

【典型错误】在synchronized块中调用wait()但未持有锁:

synchronized(lock) {
  lock.wait(); // 正确:持有lock对象的monitor
}

错误写法会抛出IllegalMonitorStateException。

三、volatile详解|内存屏障与happens-before

3.1 volatile的双重语义

  • 可见性:写操作立即刷新到主内存,读操作强制从主内存加载
  • 禁止指令重排:通过内存屏障实现

【内存屏障类型】

  • LoadLoad屏障:确保load1数据加载在load2及后续load前完成
  • StoreStore屏障:确保store1刷新到主存在store2及后续store前
  • LoadStore屏障:确保load1在store2及后续store前完成
  • StoreLoad屏障:确保store1在load2及后续load前完成(最重,避免读写重叠)

【volatile写插入屏障】

store1;
volatile store;  // 插入StoreStore + StoreLoad屏障
store2;

【volatile读插入屏障】

load1;
volatile load;  // 插入LoadLoad + LoadStore屏障
load2;

3.2 volatile的典型应用场景

  • 状态标记:如线程池的shutdown标志
  • 双重检查锁定:如单例模式中的instance字段
  • long/double原子性:在32位JVM中,volatile可保证long/double读写原子性

【错误认知】volatile能保证复合操作原子性 → 实际不能!

volatile int count = 0;
public void increment() {
  count++; // 仍非原子!包含读→加1→写三步
}

正确方案:使用AtomicInteger或synchronized。

3.3 volatile vs synchronized vs Atomic

特性volatilesynchronizedAtomic(如AtomicInteger)
原子性仅保证单变量读写原子保证代码块原子保证单变量原子操作
可见性是是是
有序性禁止重排互斥执行通过CAS保证有序
阻塞无有(线程挂起)无(自旋)
适用场景状态标记、单变量读写复杂逻辑、多变量协调单变量计数、状态更新

四、CAS原理与ABA问题|无锁并发的核心

4.1 CAS工作原理

Compare-And-Swap(比较并交换)是硬件级原子指令:

boolean compareAndSwap(int* addr, int expected, int newval) {
  if (*addr == expected) {
    *addr = newval;
    return true;
  }
  return false;
}

Java中通过Unsafe类调用:

public final native boolean compareAndSwapInt(Object o, long offset, int expected, int x);

【AtomicInteger示例】

public void increment() {
  for (int c;;) {
    int current = get();
    int next = current + 1;
    if (compareAndSet(current, next)) return;
  }
}

4.2 ABA问题及其解决方案

【问题场景】

  1. 线程1读取值A
  2. 线程2将A→B→A
  3. 线程1CAS检查值仍为A,成功更新 → 但中间状态已丢失

【典型危害】链表删除节点时,若节点被回收再分配,可能导致逻辑错误。

【解决方案】

  • 版本号机制:如AtomicStampedReference维护版本戳
  • 引用追踪:如Java 12引入的ZGC使用染色指针
public class AtomicStampedReference<V> {
  private static class Pair<T> {
    final T reference;
    final int stamp;
    private Pair(T reference, int stamp) {
      this.reference = reference;
      this.stamp = stamp;
    }
  }
  private volatile Pair<V> pair;
  public boolean compareAndSet(V expectedReference, V newReference, int expectedStamp, int newStamp) {
    Pair<V> current = pair;
    return expectedReference == current.reference
        && expectedStamp == current.stamp
        && ((newReference == current.reference && newStamp == current.stamp)
            || casPair(current, Pair.of(newReference, newStamp)));
  }
}

4.3 CAS的优缺点对比

维度优点缺点
性能无阻塞,高并发下吞吐量高高竞争时自旋消耗CPU
适用场景读多写少、状态简单不适合复杂复合操作
内存开销无需额外锁对象需要Unsafe支持(JDK 9+模块化限制)

【调优建议】高竞争场景下,结合CAS与synchronized混合策略:

public void update() {
  for (int i = 0; i < 3; i++) {  // 最多重试3次
    if (casUpdate()) return;
  }
  synchronized(this) { // 降级为重量级锁
    realUpdate();
  }
}

五、AQS框架深度解析|并发工具类的基石

5.1 AQS核心架构

AbstractQueuedSynchronizer(AQS)是Lock、Semaphore、CountDownLatch等工具类的基类:

  • state:volatile int变量,表示同步状态(如锁持有次数)
  • CLH队列:FIFO双向同步队列,节点包含:
    • prev/next:前后继指针
    • thread:线程引用
    • waitStatus:节点状态(CANCELLED=1, SIGNAL=-1, CONDITION=-2, PROPAGATE=-3)
  • 获取/释放逻辑:模板方法设计,子类实现tryAcquire/tryRelease

【同步器分类】

  • 独占锁:ReentrantLock(一次仅一个线程持有)
  • 共享锁:Semaphore(多个线程共享许可)

5.2 ReentrantLock实现原理

【获取锁流程】

  1. 尝试CAS设置state(0→1),成功则设置exclusiveOwnerThread
  2. 若state≠0,检查是否当前线程(重入)
  3. 否则将当前线程封装为Node加入CLH队列尾部
  4. 尝试自旋获取锁(最多一次CAS)
  5. 自旋失败则park挂起当前线程

【释放锁流程】

  1. 尝试CAS设置state(减少1)
  2. 若state=0,唤醒后继节点

【公平锁 vs 非公平锁】

类型获取锁逻辑适用场景
非公平锁(默认)直接CAS,失败再入队高吞吐量,避免线程挂起
公平锁先检查队列是否有前驱节点避免饥饿,保证FIFO顺序

【性能对比】在8核服务器上,非公平锁吞吐量比公平锁高30%~50%。

5.3 Condition实现原理

Condition依赖AQS的waitSet队列:

  • await():将当前线程封装为Node加入conditionWaiter链表,释放锁,挂起线程
  • signal():将conditionWaiter节点移到AQS的同步队列尾部
  • signalAll():将所有conditionWaiter节点移至同步队列

【典型错误】未在同步块中调用await/signal:

final Lock lock = new ReentrantLock();
final Condition cond = lock.newCondition();
// 错误:未加锁直接调用await
cond.await(); // 抛出IllegalMonitorStateException

六、线程池原理与调优|企业级高并发的基石

6.1 线程池核心参数详解

public ThreadPoolExecutor(
  int corePoolSize,      // 核心线程数
  int maximumPoolSize,   // 最大线程数
  long keepAliveTime,    // 非核心线程存活时间
  TimeUnit unit,
  BlockingQueue<Runnable> workQueue, // 任务队列
  ThreadFactory threadFactory, // 线程工厂
  RejectedExecutionHandler handler) // 拒绝策略

【参数协同机制】

  • 任务提交 → 若当前线程数 < corePoolSize,创建新线程(即使有空闲线程)
  • 当前线程数 ≥ corePoolSize → 任务加入队列
  • 队列满且线程数 < maximumPoolSize → 创建新线程
  • 线程数 = maximumPoolSize → 执行拒绝策略

6.2 任务队列类型对比

队列类型特点适用场景风险
ArrayBlockingQueue有界队列,FIFO需限流场景队列满导致拒绝
LinkedBlockingQueue无界队列(默认)任务量波动大内存溢出风险
SynchronousQueue无存储,直接提交高吞吐、任务处理快线程数快速增长
PriorityBlockingQueue优先级队列任务有优先级差异可能饥饿低优先级任务

6.3 拒绝策略与自定义方案

【内置策略】

  • AbortPolicy(默认):抛出RejectedExecutionException
  • CallerRunsPolicy:调用线程执行任务(限流+反馈)
  • DiscardPolicy:直接丢弃
  • DiscardOldestPolicy:丢弃队列头任务

【自定义策略示例】记录日志+降级处理:

public class LogAndFallbackPolicy implements RejectedExecutionHandler {
  private final Logger logger = LoggerFactory.getLogger(LogAndFallbackPolicy.class);
  public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
    logger.warn("任务被拒绝: {}", r.toString());
    if (r instanceof FallbackTask) {
      ((FallbackTask)r).fallback();
    }
  }
}

6.4 线程池最佳实践

  • ● 核心线程数:CPU密集型 = CPU核数 + 1;IO密集型 = CPU核数 × 2
  • ● 避免使用Executors工厂方法(隐藏风险):如newFixedThreadPool使用无界队列
  • ● 任务需捕获异常,避免线程意外终止
  • ● 使用try-finally确保shutdown/shutdownNow被调用
  • ● 监控线程池:activeCount、queueSize、completedTaskCount

【生产配置示例】交易订单处理线程池:

private final ExecutorService orderExecutor = new ThreadPoolExecutor(
  16, // 核心线程数 = CPU核数(32核) × 0.5
  32, // 最大线程数 = 核心 × 2
  60L, TimeUnit.SECONDS,
  new ArrayBlockingQueue<>(1024),
  new ThreadFactoryBuilder().setNameFormat("order-pool-%d").build(),
  new LogAndFallbackPolicy()
);

七、并发容器详解|ConcurrentHashMap源码级理解

7.1 ConcurrentHashMap演化史

  • JDK 1.7:Segment分段锁(16个Segment默认),每个Segment含HashEntry数组
  • JDK 1.8:放弃Segment,采用CAS + synchronized(类似ConcurrentSkipListMap)

【1.8结构】

  • Node数组(table):存储键值对
  • TreeNode:红黑树节点(链表≥8且table≥64时转换)
  • ForwardingNode:扩容时的占位节点

7.2 put操作流程(JDK 1.8)

  1. 计算hash值(避免高16位干扰)
  2. 若table未初始化,初始化(CAS)
  3. 若对应桶为空,CAS插入(无锁)
  4. 若为ForwardingNode,协助扩容
  5. 对桶头节点加synchronized(仅锁定当前桶)
  6. 遍历链表:找到则更新;未找到则尾插
  7. 链表长度≥8且table≥64 → 转红黑树

【关键优化】

  • ● 锁粒度从Segment级降至桶级(16→N倍并发提升)
  • ● 读操作无锁(volatile保证可见性)
  • ● 扩容时支持多线程协作(每个线程处理一段桶)

7.3 其他并发容器

  • CopyOnWriteArrayList:
    • 写时复制:加锁,复制数组,替换引用
    • 适用场景:读多写少(如监听器列表)
    • 风险:内存占用高,写时暂停时间长
  • ConcurrentSkipListMap:
    • 跳表结构,支持排序
    • 高并发下性能优于TreeMap
  • ConcurrentLinkedQueue:
    • 无界队列,CAS实现
    • 适用于高吞吐消息队列

八、ThreadLocal深度解析|内存泄漏与最佳实践

8.1 ThreadLocal原理

ThreadLocal通过每个线程的ThreadLocalMap存储数据:

class Thread {
  ThreadLocal.ThreadLocalMap threadLocals;
}

ThreadLocalMapEntry继承WeakReference:

static class ThreadLocalMap {
  static class Entry extends WeakReference<ThreadLocal<?>> {
    Object value;
    Entry(ThreadLocal<?> k, Object v) {
      super(k);
      value = v;
    }
  }
}

8.2 内存泄漏根因与解决方案

【泄漏场景】

  1. ThreadLocal引用被回收(弱引用)
  2. Entry.key = null,但value仍被强引用
  3. 线程长期存活(如线程池),Entry无法回收

【解决方案】

  • ● 每次使用后调用remove()(关键!)
  • ● 避免在ThreadLocal中存储大对象
  • ● 线程池中使用InheritableThreadLocal需谨慎
public void process() {
  try {
    threadLocal.set(data);
    // 业务逻辑
  } finally {
    threadLocal.remove(); // 必须调用!
  }
}

8.3 InheritableThreadLocal与TransmittableThreadLocal

  • InheritableThreadLocal:
    • 子线程继承父线程值(通过Thread.init()复制inheritableThreadLocals)
    • 线程池中失效(线程复用,值不更新)
  • TransmittableThreadLocal(阿里开源):
    • 通过TtlRunnable包装,线程池中传递上下文
    • 支持异步、线程池场景

九、死锁检测与预防|生产事故的高频元凶

9.1 死锁的四个必要条件

  • 互斥条件:资源不能被多个线程同时使用
  • 请求与保持:线程持有资源并请求新资源
  • 不剥夺条件:资源不能被强制剥夺
  • 循环等待:存在线程-资源的循环等待链

【典型死锁代码】

public void deadlockExample() {
  Thread t1 = new Thread(() -> {
    synchronized(lock1) {
      sleep(100);
      synchronized(lock2) { // 等待lock2
        ...
      }
    }
  });
  Thread t2 = new Thread(() -> {
    synchronized(lock2) {
      sleep(100);
      synchronized(lock1) { // 等待lock1
        ...
      }
    }
  });
  t1.start(); t2.start();
}

9.2 死锁检测工具

  • jstack:查看线程堆栈,识别DEADLOCK状态
  • jcmd:jcmd PID Thread.print
  • VisualVM:图形化监控死锁
  • JMX:通过ThreadMXBean检测
import java.lang.management.ManagementFactory;
import java.lang.management.ThreadMXBean;
public class DeadlockDetector {
  public static void main(String[] args) {
    ThreadMXBean mxBean = ManagementFactory.getThreadMXBean();
    long[] deadlockedThreads = mxBean.findDeadlockedThreads();
    if (deadlockedThreads != null) {
      System.out.println("检测到死锁: " + deadlockedThreads.length + " 个线程");
    }
  }
}

9.3 死锁预防策略

  • 锁排序:按固定顺序获取锁(如先锁id小的对象)
  • 超时机制:tryLock(100, TimeUnit.MILLISECONDS)
  • 减少锁持有时间:缩小synchronized块范围
  • 使用并发工具类:如ReadWriteLock、StampedLock

【修复示例】按对象ID排序锁:

public void transfer(Account from, Account to, int amount) {
  Account lock1 = from.getId() < to.getId() ? from : to;
  Account lock2 = from.getId() < to.getId() ? to : from;
  synchronized(lock1) {
    synchronized(lock2) {
      from.debit(amount);
      to.credit(amount);
    }
  }
}

十、网友们还关心:高频延伸问题

10.1 高并发下线程安全的典型问题

  • ● 电商秒杀:库存超卖(未使用Redis+Lua或数据库乐观锁)
  • ● 订单重复创建:接口幂等性缺失(未用Redis setnx)
  • ● 分布式ID生成:雪花算法时钟回拨问题

【解决方案】秒杀场景:

  • ① 库存预热至Redis
  • ② Lua脚本保证扣减原子性
  • ③ 消息队列削峰
  • ④ 本地缓存兜底

10.2 线程池参数调优实战

【CPU密集型任务】(如加密、计算)

  • 核心线程数 = CPU核数 + 1
  • 队列:ArrayBlockingQueue(100)
  • 拒绝策略:CallerRunsPolicy

【IO密集型任务】(如文件读写、网络请求)

  • 核心线程数 = CPU核数 × 2
  • 队列:LinkedBlockingQueue(10000)
  • 拒绝策略:AbortPolicy + 日志告警

【混合型任务】

  • 拆分为CPU/IO子任务,分别使用不同线程池
  • 使用ForkJoinPool的Work-Stealing机制

10.3 线程安全监控方案

  • ● 线程堆栈监控:定期采集jstack,分析死锁/长时间阻塞
  • ● 指标埋点:使用Micrometer监控线程池状态
  • ● 异常检测:捕获ConcurrentModificationException等异常
private final MeterRegistry registry;
public void trackThreadPool() {
  registry.gauge("threadpool.active", activeCount);
  registry.gauge("threadpool.queue", queueSize);
  registry.counter("threadpool.rejected").increment(rejectedCount);
}

十一、FAQ|面试高频追问

Q1: synchronized和ReentrantLock的对比?

A: 相同点:都可保证线程安全;不同点:

  • ● ReentrantLock需手动加锁/释放(try-finally),synchronized自动释放
  • ● ReentrantLock支持公平锁、条件变量、可中断锁
  • ● synchronized支持JIT优化(如锁消除、锁粗化)
  • ● ReentrantLock在高竞争下性能更优
Q2: 为什么volatile不能保证原子性?

A: volatile仅保证单次读/写的原子性,但i++包含读→加1→写三步,非原子操作。需用AtomicInteger或synchronized。

Q3: 如何避免线程池的内存溢出?

A: 避免使用Executors.newFixedThreadPool()(无界队列)。应手动创建ThreadPoolExecutor,设置有界队列(如ArrayBlockingQueue)和合理拒绝策略。

Q4: ThreadLocal内存泄漏如何排查?

A: 使用jmap生成堆转储,用MAT分析ThreadLocalMap中key为null的Entry数量。重点检查线程池中ThreadLocal的remove()调用。