首页|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并发编程实战》给出经典定义:当多个线程访问某个类时,不管运行时环境采用何种调度方式或者这些线程如何交替执行,该类都能表现出正确的行为,就称该类是线程安全的。
关键点在于“正确的行为”,而非具体实现方式。线程安全并非二元(安全/不安全),而是存在五级渐进式分类:
- 不可变(Immutable):如String、Integer、Long,天然线程安全
- 绝对线程安全:如CopyOnWriteArrayList,所有操作内部同步
- 相对线程安全:如ArrayList、HashMap,单个操作线程安全,复合操作不安全
- 接口线程安全:如Collections.synchronizedList,需外部同步保证复合操作
- 线程兼容:如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 Mapconfigs = 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_enabled | true | 是否启用偏向锁 |
| BiasedLockingStartupDelay | 4000 | 延迟4秒后启用偏向锁(允许程序稳定运行) |
| LockingMode | 0 | 锁模式: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
| 特性 | volatile | synchronized | Atomic(如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读取值A
- 线程2将A→B→A
- 线程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实现原理
【获取锁流程】
- 尝试CAS设置state(0→1),成功则设置exclusiveOwnerThread
- 若state≠0,检查是否当前线程(重入)
- 否则将当前线程封装为Node加入CLH队列尾部
- 尝试自旋获取锁(最多一次CAS)
- 自旋失败则park挂起当前线程
【释放锁流程】
- 尝试CAS设置state(减少1)
- 若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)
- 计算hash值(避免高16位干扰)
- 若table未初始化,初始化(CAS)
- 若对应桶为空,CAS插入(无锁)
- 若为ForwardingNode,协助扩容
- 对桶头节点加synchronized(仅锁定当前桶)
- 遍历链表:找到则更新;未找到则尾插
- 链表长度≥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 内存泄漏根因与解决方案
【泄漏场景】
- ThreadLocal引用被回收(弱引用)
- Entry.key = null,但value仍被强引用
- 线程长期存活(如线程池),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|面试高频追问
A: 相同点:都可保证线程安全;不同点:
- ● ReentrantLock需手动加锁/释放(try-finally),synchronized自动释放
- ● ReentrantLock支持公平锁、条件变量、可中断锁
- ● synchronized支持JIT优化(如锁消除、锁粗化)
- ● ReentrantLock在高竞争下性能更优
A: volatile仅保证单次读/写的原子性,但i++包含读→加1→写三步,非原子操作。需用AtomicInteger或synchronized。
A: 避免使用Executors.newFixedThreadPool()(无界队列)。应手动创建ThreadPoolExecutor,设置有界队列(如ArrayBlockingQueue)和合理拒绝策略。
A: 使用jmap生成堆转储,用MAT分析ThreadLocalMap中key为null的Entry数量。重点检查线程池中ThreadLocal的remove()调用。