Java并发编程学习

在当今互联网高并发场景下,掌握Java并发编程已成为后端开发者的必备核心能力。从单机到分布式,从同步阻塞到异步非阻塞,从简单线程创建到复杂并发框架设计,Java并发编程体系庞大而精深。本页面系统梳理并发学习路径,覆盖线程生命周期、同步机制、内存可见性、CAS原理、AQS源码解析、线程池调优、高并发系统架构等关键模块,结合真实项目案例与高频面试题,助您构建扎实的并发知识体系。

为何并发编程如此重要?

现代应用系统对吞吐量、响应时间、资源利用率的要求日益严苛。以电商大促、直播抢购、金融交易系统为例,单机每秒需处理数千至数万请求。若缺乏并发处理能力,系统极易出现线程阻塞、资源争抢、响应延迟甚至崩溃。Java作为企业级开发主流语言,其强大的并发工具库(java.util.concurrent)为开发者提供了从底层线程控制到高层并发抽象的完整支持。

据2025年Stack Overflow开发者调查,并发编程是Java开发者最常遇到的技术难点之一。超过68%的Java工程师表示在项目中遭遇过线程死锁、可见性问题、指令重排序等典型并发缺陷。这些问题往往难以复现、定位困难,且可能引发线上生产事故。因此,系统学习并发原理,理解JMM(Java Memory Model)、volatile语义、synchronized锁升级机制等底层逻辑,是写出高质量、高可靠性代码的前提。

学习路径建议

  1. 掌握线程基础:线程创建、启动、中断、生命周期、线程通信
  2. 理解同步机制:synchronized、volatile、原子类、Lock体系
  3. 深入内存模型:happens-before规则、重排序、内存屏障
  4. 熟练使用并发工具:CountDownLatch、CyclicBarrier、Semaphore、ConcurrentHashMap等
  5. 掌握线程池原理与调优:ThreadPoolExecutor核心参数、拒绝策略、任务队列选择
  6. 实战高并发设计:限流、降级、熔断、异步化、无锁化设计
  7. 阅读源码: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纳秒)。

上下文切换影响因素
减少切换的策略
实战案例分析

影响上下文切换的因素

  1. 线程数量:线程越多,切换越频繁,CPU花在保存/恢复上的时间越多
  2. 锁竞争:高竞争导致线程频繁阻塞/唤醒,增加切换次数
  3. 任务粒度:过小任务(如每个任务仅1ms)导致切换开销占比过高
  4. CPU缓存局部性:频繁切换使CPU缓存命中率下降,影响性能

实测数据:1000个空循环线程 vs 10个长任务线程,在相同CPU下,前者上下文切换次数高出30倍,吞吐量下降65%。

减少切换的策略

  • 使用线程池:复用线程,避免频繁创建/销毁
  • 减少同步范围:缩小synchronized块,降低阻塞时间
  • 无锁化设计:使用CAS、ThreadLocal等避免锁竞争
  • 任务合并:将多个小任务合并为大任务(如批量处理)
  • 异步化:使用CompletableFuture、Reactor模式解耦任务

实战案例:日志处理中的线程切换优化

某系统日志处理模块原采用“每条日志新建线程”模式,日均切换超200万次,CPU上下文切换开销占比达18%。优化方案:

  1. 改用FixedThreadPool(线程数=CPU核心数)
  2. 引入异步日志队列(Disruptor无锁队列)
  3. 批量刷盘:每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核心特性
读写锁使用场景
锁公平性权衡

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规则
volatile底层原理
重排序案例分析

happens-before八大规则

  1. 程序顺序规则:单线程内,按代码顺序happens-before
  2. 监视器锁规则:解锁happens-before后续加锁
  3. volatile变量规则:写happens-before后续读
  4. 线程启动规则:start() h-b 子线程内操作
  5. 线程终止规则:线程内操作 h-b join()返回
  6. 线程中断规则:interrupt() h-b 中断检测
  7. 对象终结规则:构造完成 h-b finalize()
  8. 传递性: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源码分析
LongAdder高性能原理
ThreadLocal内存泄漏

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无法释放 → 内存泄漏

解决方案:

  1. 使用完后调用remove()
  2. 避免在ThreadLocal中存储大对象
  3. 自定义ThreadLocal子类重写remove()逻辑

并发工具类实战

JUC提供丰富的并发工具,合理使用可大幅提升开发效率。

核心工具类对比

工具类主要用途典型场景
CountDownLatch等待多个任务完成主线程等待子线程初始化
CyclicBarrier多线程同步点多线程计算后汇总结果
Semaphore信号量控制数据库连接池限流
Exchanger两线程交换数据生产者-消费者数据交换
CountDownLatch实战
CyclicBarrier与Phaser
ConcurrentHashMap原理

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

核心改进:

  1. 移除Segment,直接使用Node数组
  2. 头节点加锁(synchronized),减少锁粒度
  3. 链表转红黑树阈值:8
  4. 扩容时支持并发(分段迁移)

实测:100线程并发写,ConcurrentHashMap比HashMap快50倍以上。

高并发系统设计实战

从单机到分布式,高并发架构需兼顾性能、一致性、容错性。

常见架构模式

  • 分层架构:接入层(Nginx)→ 服务层(Spring Cloud)→ 数据层(MySQL+Redis)
  • 异步化:消息队列(Kafka)解耦业务,削峰填谷
  • 缓存策略:多级缓存(本地缓存+Caffeine+Redis集群)
  • 限流降级:令牌桶算法、漏桶算法、Sentinel熔断
  • 数据分片:分库分表(ShardingSphere)、读写分离
秒杀系统设计
分布式ID生成
分布式事务方案

秒杀系统核心优化点

  1. 静态化:商品详情页缓存至CDN,减少服务端压力
  2. 库存预热:提前将库存写入Redis,使用Lua脚本原子扣减
  3. 请求排队:RabbitMQ/Kafka削峰,消费端限流
  4. 库存超卖:
    • 方案1:Redis原子操作(DECR)
    • 方案2:乐观锁(version字段)
  5. 防刷单: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:"
    → 分析线程栈:锁持有者、等待者、锁对象地址