Java并发编程学习
在当今互联网高并发场景下,掌握Java并发编程已成为后端开发者的必备核心能力。从单机到分布式,从同步阻塞到异步非阻塞,从简单线程创建到复杂并发框架设计,Java并发编程体系庞大而精深。本页面系统梳理并发学习路径,覆盖线程生命周期、同步机制、内存可见性、CAS原理、AQS源码解析、线程池调优、高并发系统架构等关键模块,结合真实项目案例与高频面试题,助您构建扎实的并发知识体系。
为何并发编程如此重要?
现代应用系统对吞吐量、响应时间、资源利用率的要求日益严苛。以电商大促、直播抢购、金融交易系统为例,单机每秒需处理数千至数万请求。若缺乏并发处理能力,系统极易出现线程阻塞、资源争抢、响应延迟甚至崩溃。Java作为企业级开发主流语言,其强大的并发工具库(java.util.concurrent)为开发者提供了从底层线程控制到高层并发抽象的完整支持。
据2025年Stack Overflow开发者调查,并发编程是Java开发者最常遇到的技术难点之一。超过68%的Java工程师表示在项目中遭遇过线程死锁、可见性问题、指令重排序等典型并发缺陷。这些问题往往难以复现、定位困难,且可能引发线上生产事故。因此,系统学习并发原理,理解JMM(Java Memory Model)、volatile语义、synchronized锁升级机制等底层逻辑,是写出高质量、高可靠性代码的前提。
学习路径建议
- 掌握线程基础:线程创建、启动、中断、生命周期、线程通信
- 理解同步机制:synchronized、volatile、原子类、Lock体系
- 深入内存模型:happens-before规则、重排序、内存屏障
- 熟练使用并发工具:CountDownLatch、CyclicBarrier、Semaphore、ConcurrentHashMap等
- 掌握线程池原理与调优:ThreadPoolExecutor核心参数、拒绝策略、任务队列选择
- 实战高并发设计:限流、降级、熔断、异步化、无锁化设计
- 阅读源码:JUC包核心类实现,如AQS、ForkJoinPool、StampedLock
常见误区提醒
- 误区一:使用线程越多性能越高 → 实际:线程切换开销大,过多线程反而降低吞吐量
- 误区二:volatile保证原子性 → 实际:仅保证可见性与有序性,不保证复合操作原子性
- 误区三:synchronized是重量级锁 → 实际:JDK6后引入偏向锁、轻量级锁优化,多数场景开销可控
- 误区四:线程池不需关闭 → 实际:不调用shutdown()可能导致线程泄漏、资源无法释放
并发编程基础
并发(Concurrency)指多个任务在一段时间内交替执行;并行(Parallelism)指多个任务真正同时执行。Java并发编程的核心在于:正确性(线程安全)、性能(高吞吐、低延迟)、可维护性(清晰结构)。
线程创建方式对比
Java中创建线程主要有三种方式:继承Thread类、实现Runnable接口、实现Callable接口。从JDK5起,推荐使用Executor框架统一管理线程。
| 方式 | 是否支持返回值 | 是否支持异常抛出 | 是否推荐 |
|---|---|---|---|
| 继承Thread | 否 | 需重写run()无法throws | ❌ 不推荐(耦合高) |
| 实现Runnable | 否 | 同上 | ⚠️ 基础场景可用 |
| 实现Callable | ✓ 是(Future.get) | ✓ 是(可抛出异常) | ✅ 推荐 |
| ExecutorService.submit() | ✓ 是 | ✓ 是 | ✅ 最佳实践 |
// 示例:使用Callable + FutureTask实现带返回值的线程
import java.util.concurrent.*;
public class CallableExample {
public static void main(String[] args) throws Exception {
Callable task = () -> {
System.out.println("执行计算...");
Thread.sleep(1000);
return 42;
};
FutureTask future = new FutureTask<>(task);
new Thread(future).start();
System.out.println("结果:" + future.get()); // 阻塞等待结果
}
}
线程状态与生命周期
Java线程有6种状态(Thread.State):NEW(初始)、RUNNABLE(可运行)、BLOCKED(阻塞)、WAITING(无限等待)、TIMED_WAITING(计时等待)、TERMINATED(终止)。
- 调用start()后进入RUNNABLE状态,但实际是否运行取决于CPU调度
- 进入synchronized块/方法未获锁 → BLOCKED
- 调用Object.wait()、Thread.join()、LockSupport.park() → WAITING
- 调用Thread.sleep()、Object.wait(timeout)、LockSupport.parkNanos() → TIMED_WAITING
- run()方法执行完毕 → TERMINATED
线程中断机制详解
中断(Interrupt)是协作式机制,非强制终止。核心方法:
interrupt():设置中断标志位isInterrupted():检查当前线程中断状态(不清除)interrupted():静态方法,检查并清除中断状态
当线程处于WAITING或TIMED_WAITING状态时调用interrupt(),会抛出InterruptedException并清除中断状态。因此,捕获异常后应恢复中断状态:
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
Thread.currentThread().interrupt(); // 恢复中断状态
}
线程模型与上下文切换
Java线程基于操作系统原生线程(1:1模型)。每个Java线程对应一个OS线程,由JVM调用OS API创建。线程切换(Context Switch)是CPU从一个线程切换到另一个线程的过程,涉及保存当前寄存器、程序计数器、栈指针等上下文信息,开销较大(约1000~10000纳秒)。
影响上下文切换的因素
- 线程数量:线程越多,切换越频繁,CPU花在保存/恢复上的时间越多
- 锁竞争:高竞争导致线程频繁阻塞/唤醒,增加切换次数
- 任务粒度:过小任务(如每个任务仅1ms)导致切换开销占比过高
- CPU缓存局部性:频繁切换使CPU缓存命中率下降,影响性能
实测数据:1000个空循环线程 vs 10个长任务线程,在相同CPU下,前者上下文切换次数高出30倍,吞吐量下降65%。
减少切换的策略
- 使用线程池:复用线程,避免频繁创建/销毁
- 减少同步范围:缩小synchronized块,降低阻塞时间
- 无锁化设计:使用CAS、ThreadLocal等避免锁竞争
- 任务合并:将多个小任务合并为大任务(如批量处理)
- 异步化:使用CompletableFuture、Reactor模式解耦任务
实战案例:日志处理中的线程切换优化
某系统日志处理模块原采用“每条日志新建线程”模式,日均切换超200万次,CPU上下文切换开销占比达18%。优化方案:
- 改用FixedThreadPool(线程数=CPU核心数)
- 引入异步日志队列(Disruptor无锁队列)
- 批量刷盘:每100条日志或500ms刷一次
优化后:切换次数下降至2万次/日,CPU利用率提升22%,日志延迟从50ms降至5ms。
锁机制与同步原理
锁是并发控制的核心手段。Java中锁分为:内置锁(synchronized)、显式锁(ReentrantLock)、读写锁(ReentrantReadWriteLock)、轻量级锁(CAS优化)。
synchronized深度解析
JVM对synchronized的优化经历了:无锁 → 偏向锁 → 轻量级锁 → 重量级锁的升级路径:
- 偏向锁:适用于单线程重复获取锁场景。首次获取时,将对象头Mark Word设为偏向线程ID,后续无需CAS
- 轻量级锁:多线程竞争但锁持有时间短。通过CAS将对象头指向栈帧中的Lock Record
- 自旋锁:锁竞争激烈但持有时间短时,线程不阻塞而循环等待(默认10次自旋)
- 重量级锁:自旋失败后,升级为OS互斥量,线程阻塞挂起
可通过JVM参数调整:-XX:BiasedLockingStartupDelay=0(禁用延迟偏向锁)、-XX:AutoBoxCacheMax(影响Integer缓存,间接影响锁优化)
ReentrantLock优势与陷阱
- 可中断锁:lockInterruptibly()支持响应中断
- 超时锁:tryLock(timeout)避免死锁
- 公平锁:构造函数传true启用,按请求顺序获取
- 条件变量:await/signal替代wait/notify,更灵活
⚠️ 注意:必须在finally中释放锁!否则可能导致死锁:
Lock lock = new ReentrantLock();
lock.lock();
try {
// 业务逻辑
} finally {
lock.unlock(); // 关键!
}
读写锁适用场景
ReentrantReadWriteLock适用于“读多写少”场景,如缓存、配置中心、状态管理:
- 读锁(共享锁):多个线程可同时读,但禁止写
- 写锁(独占锁):写时禁止读写,保证数据一致性
案例:本地缓存实现:
class CachedData {
final Map cache = new HashMap<>();
final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
String get(String key) {
rwLock.readLock().lock();
try {
return cache.get(key); // 允许多线程并发读
} finally {
rwLock.readLock().unlock();
}
}
void put(String key, String value) {
rwLock.writeLock().lock();
try {
cache.put(key, value); // 写时独占
} finally {
rwLock.writeLock().unlock();
}
}
}
公平锁 vs 非公平锁
| 特性 | 公平锁 | 非公平锁(默认) |
|---|---|---|
| 吞吐量 | 较低(维护队列开销大) | 较高(允许插队) |
| 线程饥饿 | 无 | 可能(写线程被饿死) |
| 适用场景 | 任务优先级严格场景 | 通用场景(如线程池) |
实测数据:在高并发写场景下,公平锁吞吐量比非公平锁低30%~40%,但非公平锁可能导致部分线程长期等待。
线程池原理与调优
线程池通过复用线程降低创建/销毁开销,是高并发系统的基石。核心类:ThreadPoolExecutor。
ThreadPoolExecutor七参数详解
- corePoolSize:核心线程数(常驻线程)
- maximumPoolSize:最大线程数(动态扩展上限)
- keepAliveTime:非核心线程空闲存活时间
- unit:时间单位
- workQueue:任务队列(关键!)
- threadFactory:线程工厂(可命名线程)
- handler:拒绝策略(队列满时处理)
任务队列类型对比
| 队列类型 | 有界/无界 | 适用场景 | 风险 |
|---|---|---|---|
| ArrayBlockingQueue | 有界 | 需限流场景(如API网关) | 队列满触发拒绝 |
| LinkedBlockingQueue | 无界 | 任务波动大(默认构造器) | 内存溢出风险 |
| SynchronousQueue | 零容量 | 直接提交任务(ForkJoinPool) | 线程数需设大 |
| PriorityBlockingQueue | 无界 | 任务优先级排序(如定时任务) | 可能饿死低优先级任务 |
⚠️ 禁止使用无界队列(如LinkedBlockingQueue())!易导致OOM。
拒绝策略选择
- AbortPolicy:抛出RejectedExecutionException(默认)
- CallerRunsPolicy:由调用线程执行任务(限流降级)
- DiscardPolicy:直接丢弃任务(不推荐)
- DiscardOldestPolicy:丢弃队头任务,插入新任务
推荐:核心业务用CallerRunsPolicy实现反压,日志/通知类任务用DiscardPolicy。
生产环境调优经验
某支付系统线程池配置经验:
- 计算密集型任务:
corePoolSize = CPU核心数 + 1 - IO密集型任务:
corePoolSize = CPU核心数 × 2(参考公式) - 实际调优步骤:
- ① 监控GC、线程数、队列长度、任务耗时
- ② 使用Arthas或Prometheus采集指标
- ③ 压测:逐步增加线程数,观察TPS拐点
- ④ 设置合理队列长度(如1000~5000)
最终配置:new ThreadPoolExecutor(20, 40, 60L, TimeUnit.SECONDS, new ArrayBlockingQueue<>(2000))
JMM内存模型与可见性
Java Memory Model(JMM)是Java虚拟机规范,定义了线程如何与主内存交互。核心原则:可见性、原子性、有序性。
三大特性详解
- 可见性:一个线程修改对其他线程可见。volatile通过内存屏障实现;synchronized通过“获取-释放”锁同步主内存
- 原子性:不可中断的操作。基本类型读写(long/double除外);synchronized、Lock保证复合操作原子性
- 有序性:禁止指令重排序。volatile、synchronized、happens-before规则约束
happens-before八大规则
- 程序顺序规则:单线程内,按代码顺序happens-before
- 监视器锁规则:解锁happens-before后续加锁
- volatile变量规则:写happens-before后续读
- 线程启动规则:start() h-b 子线程内操作
- 线程终止规则:线程内操作 h-b join()返回
- 线程中断规则:interrupt() h-b 中断检测
- 对象终结规则:构造完成 h-b finalize()
- 传递性:A h-b B,B h-b C → A h-b C
volatile底层原理
volatile变量在字节码层面插入内存屏障(Memory Barrier):
- LoadLoad屏障:禁止读操作重排序
- StoreStore屏障:禁止写操作重排序
- StoreLoad屏障:防止写与后续读重排序(开销最大)
示例:双重检查锁定单例:
class Singleton {
private static volatile Singleton instance;
static Singleton getInstance() {
if (instance == null) { // 第一次检查
synchronized (Singleton.class) {
if (instance == null) { // 第二次检查
instance = new Singleton(); // volatile保证有序性
}
}
}
return instance;
}
}
若无volatile,new操作可能被重排序为:
1. 分配内存 → 2. 设置引用 → 3. 调用构造器
导致其他线程看到未初始化完成的对象!
重排序案例:发布-订阅模式
错误写法(可能漏发消息):
// 线程A(发布者)
flag = true; // 重排序可能发生在data赋值前!
data = "message";
// 线程B(订阅者)
if (flag) {
System.out.println(data); // 可能打印null!
}
正确写法:将flag设为volatile,或使用synchronized包裹赋值操作。
原子操作与CAS原理
原子类(AtomicInteger、LongAdder等)基于CAS(Compare-And-Swap)实现,避免锁开销。
CAS工作原理
CAS操作包含三个操作数:内存位置(V)、预期值(A)、新值(B)。仅当V=A时,将V更新为B,否则不更新。
- 原子性:由CPU LOCK#信号保证(多核下总线锁定)
- ABA问题:值从A→B→A,CAS误判。解决方案:版本号(AtomicStampedReference)
- 自旋开销:高竞争下CPU空转。解决方案:自适应自旋或改用锁
AtomicInteger核心方法
// getAndIncrement() 实现
public final int getAndIncrement() {
return unsafe.getAndAddInt(this, valueOffset, 1);
}
// unsafe.getAndAddInt 实现(伪代码)
do {
current = getIntVolatile(obj, offset);
} while (!compareAndSwapInt(obj, offset, current, current + delta));
每次调用都触发CAS循环,高并发下性能下降。LongAdder通过分段累加解决此问题。
LongAdder高性能原理
LongAdder采用“空间换时间”策略:
- base值:无竞争时直接累加到base
- cells数组:竞争激烈时,将累加分散到不同cell(哈希分片)
- sum()方法:返回base + 所有cell值
实测:在100线程并发写场景下,AtomicInteger吞吐量约5万TPS,LongAdder可达200万TPS。
ThreadLocal内存泄漏分析
ThreadLocalMap使用弱引用作为key,但value是强引用:
- ThreadLocal对象被GC回收后,key=null,但value仍被ThreadLocalMap引用
- 若线程长期存活(如线程池),value无法释放 → 内存泄漏
解决方案:
- 使用完后调用remove()
- 避免在ThreadLocal中存储大对象
- 自定义ThreadLocal子类重写remove()逻辑
并发工具类实战
JUC提供丰富的并发工具,合理使用可大幅提升开发效率。
核心工具类对比
| 工具类 | 主要用途 | 典型场景 |
|---|---|---|
| CountDownLatch | 等待多个任务完成 | 主线程等待子线程初始化 |
| CyclicBarrier | 多线程同步点 | 多线程计算后汇总结果 |
| Semaphore | 信号量控制 | 数据库连接池限流 |
| Exchanger | 两线程交换数据 | 生产者-消费者数据交换 |
CountDownLatch:启动协调
场景:启动服务前需完成数据库、缓存、MQ连接初始化:
public class ServiceStarter {
private final CountDownLatch latch = new CountDownLatch(3);
void initDatabase() { ... latch.countDown(); }
void initCache() { ... latch.countDown(); }
void initMQ() { ... latch.countDown(); }
void start() throws InterruptedException {
new Thread(this::initDatabase).start();
new Thread(this::initCache).start();
new Thread(this::initMQ).start();
latch.await(); // 等待所有初始化完成
System.out.println("服务启动完成!");
}
}
CyclicBarrier:分阶段计算
场景:并行计算矩阵乘法,每行由独立线程处理,完成后汇总:
class MatrixMultiply {
final CyclicBarrier barrier;
final float[][] A, B, C;
MatrixMultiply(float[][] A, float[][] B, float[][] C) {
this.A = A; this.B = B; this.C = C;
this.barrier = new CyclicBarrier(A.length, () -> {
System.out.println("阶段完成,汇总结果...");
});
}
void calculateRow(int row) {
for (int col = 0; col < B[0].length; col++) {
C[row][col] = 0;
for (int k = 0; k < B.length; k++) {
C[row][col] += A[row][k] * B[k][col];
}
}
try {
barrier.await(); // 等待所有行计算完成
} catch (Exception e) { e.printStackTrace(); }
}
}
ConcurrentHashMap分段锁演进
- JDK7:Segment数组 + HashEntry链表(分段锁)
- JDK8:Node数组 + 链表/红黑树 + CAS + synchronized
核心改进:
- 移除Segment,直接使用Node数组
- 头节点加锁(synchronized),减少锁粒度
- 链表转红黑树阈值:8
- 扩容时支持并发(分段迁移)
实测:100线程并发写,ConcurrentHashMap比HashMap快50倍以上。
高并发系统设计实战
从单机到分布式,高并发架构需兼顾性能、一致性、容错性。
常见架构模式
- 分层架构:接入层(Nginx)→ 服务层(Spring Cloud)→ 数据层(MySQL+Redis)
- 异步化:消息队列(Kafka)解耦业务,削峰填谷
- 缓存策略:多级缓存(本地缓存+Caffeine+Redis集群)
- 限流降级:令牌桶算法、漏桶算法、Sentinel熔断
- 数据分片:分库分表(ShardingSphere)、读写分离
秒杀系统核心优化点
- 静态化:商品详情页缓存至CDN,减少服务端压力
- 库存预热:提前将库存写入Redis,使用Lua脚本原子扣减
- 请求排队:RabbitMQ/Kafka削峰,消费端限流
- 库存超卖:
- 方案1:Redis原子操作(DECR)
- 方案2:乐观锁(version字段)
- 防刷单:IP限流、人机验证(滑块)、风控规则引擎
分布式ID生成方案
| 方案 | 优点 | 缺点 | 适用场景 |
|---|---|---|---|
| UUID | 全球唯一,简单 | 无序,长度长,性能差 | 日志ID |
| 数据库自增 | 有序,简单 | 单点瓶颈,扩展难 | 单体应用 |
| Redis INCR | 高性能,有序 | 依赖Redis,可能重复 | 中等规模系统 |
| Snowflake | 高性能,有序,分布式 | 时钟回拨问题 | 大型分布式系统 |
分布式事务方案对比
- 2PC(两阶段提交):强一致,但性能差,阻塞时间长
- 3PC(三阶段提交):减少阻塞,但无法彻底避免数据不一致
- TCC(Try-Confirm-Cancel):业务层实现,高性能,但开发复杂
- 本地消息表:基于消息最终一致性,可靠但延迟高
- Seata(AT模式):对业务无侵入,自动补偿,推荐
推荐:核心交易用TCC,非核心用Seata或本地消息表。
高频面试题解析
整理近3年大厂并发编程面试真题,覆盖原理、源码、实战。
必考题(原理类)
- volatile与synchronized区别?
→ volatile保证可见性与有序性,不保证原子性;synchronized保证三性,但性能较低。volatile适用于状态标记、单次写入场景。 - CAS的ABA问题如何解决?
→ 使用AtomicStampedReference添加版本号,或改用锁。 - 线程池核心参数有哪些?如何调优?
→ 参考ThreadPoolExecutor七参数;调优需结合CPU核数、任务类型(IO/计算)、监控指标(队列长度、线程数、任务耗时)。
源码题(JUC)
- AQS如何实现锁?
→ AQS维护state(状态)和CLH队列(FIFO等待队列)。tryAcquire()尝试获取锁,失败则入队等待;release()释放锁,唤醒后继节点。 - ReentrantLock如何实现可重入?
→ 持有线程记录为exclusiveOwnerThread,state记录重入次数。每次获取state++,释放state--,为0时释放锁。
实战题(生产问题)
- 线上服务频繁Full GC,如何排查?
→ 步骤:
① jstat -gcutil PID 1000 观察GC频率
② jmap -histo:live PID | head 查看对象分布
③ 检查ThreadLocal未清理、大对象缓存、死循环创建对象
④ 使用Arthas监控内存分配速率 - 如何定位死锁?
→ jstack PID → 查找"Found one Java-level deadlock:"
→ 分析线程栈:锁持有者、等待者、锁对象地址