Java并发编程核心知识体系与高频面试要点详解

一、为什么要系统学习Java并发

在多核处理器已成为标配的今天，能否正确、高效地编写并发程序，直接决定了系统能否充分利用硬件资源。然而并发编程同时也是Java面试中区分候选人水平的关键领域：它不仅考查记忆性的知识点，更考查对内存模型、线程调度、锁机制等底层原理的理解深度。

很多开发者的学习困境在于知识点零散——今天背一个synchronized的锁升级，明天记一个线程池参数，始终无法形成体系。要突破这一困境，最佳切入点是把握java.util.concurrent（以下简称JUC）包的整体架构，再逐个模块深入。下面我们按照“总—分”的顺序展开。

二、JUC整体架构：五大模块一图看清

从设计角度看，JUC包可以划分为五个层次分明的模块，它们共同构成了Java并发工具箱：

java.util.concurrent
├── locks（锁框架）
│    ├── Lock 接口
│    │    ├── ReentrantLock
│    │    └── ReentrantReadWriteLock
│    ├── Condition（条件队列）
│    └── AbstractQueuedSynchronizer（AQS 同步器骨架）
├── atomic（原子类）
│    ├── AtomicInteger / AtomicLong
│    ├── AtomicReference
│    └── AtomicStampedReference
├── collections（并发集合）
│    ├── ConcurrentHashMap
│    ├── CopyOnWriteArrayList
│    └── BlockingQueue 接口及其实现（ArrayBlockingQueue、
│         LinkedBlockingQueue、PriorityBlockingQueue 等）
├── executors（线程池）
│    ├── Executor 接口
│    ├── ExecutorService 接口
│    ├── ThreadPoolExecutor
│    ├── ScheduledThreadPoolExecutor
│    └── Executors 工具类
└── tools（同步工具）
     ├── CountDownLatch
     ├── CyclicBarrier
     ├── Semaphore
     └── Exchanger

理解这张架构图有两层意义：其一，面试中回答“谈谈你对JUC的了解”时，能从全局视角切入，展示系统性思维；其二，日常开发中遇到并发问题时，可以快速定位应使用哪一层工具——需要互斥找锁框架，需要无锁计数找原子类，需要线程安全容器找并发集合，需要任务调度找线程池，需要线程协作找同步工具。

三、锁框架：从AQS骨架到具体锁实现

3.1 AQS：整个锁体系的基石

AbstractQueuedSynchronizer（AQS）是JUC中绝大多数同步器的底层骨架，其核心设计可以概括为三点：

1. volatile状态变量state：用一个小整数表达同步资源的状态，例如在ReentrantLock中state表示锁被重入了几次，在Semaphore中state表示剩余许可数，在CountDownLatch中state表示还剩多少个计数。
2. CLH变体的等待队列：获取锁失败的线程会被封装成节点，加入一个双向队列中阻塞等待，醒来后按序尝试获取。
3. 模板方法模式：AQS把“如何改变state、如何判断获取成功”留给子类实现（如tryAcquire、tryRelease），而把排队、阻塞、唤醒这些复杂且易错的通用逻辑封装好。子类只需关注差异化逻辑，这正是不变与变化的经典分离。

面试中若被问到“ReentrantLock的加锁流程”，本质上就是在考AQS：先通过CAS修改state，成功则获取锁；失败则入队阻塞，等待前驱节点唤醒后重试。

3.2 ReentrantLock：可重入互斥锁

典型用法如下，务必将unlock放入finally块，防止异常导致锁永不释放：

public class ReentrantLockExample {
    private final ReentrantLock lock = new ReentrantLock();
    public void method() {
        lock.lock();
        try {
            // 临界区代码
        } finally {
            lock.unlock();
        }
    }
}

它的核心特性包括：

• 可重入性：同一线程可以多次获取同一把锁，state随之递增，释放时递减到零才真正释放。这避免了线程在递归调用或锁内调用另一把同一锁的方法时把自己锁死。
• 公平与非公平模式：构造时可传入boolean参数。非公平锁（默认）在新线程到达时直接尝试插队抢占，吞吐量更高但可能导致队列中线程长期得不到锁；公平锁严格按排队顺序分配，避免饥饿但代价是更多线程切换。
• 尝试获取tryLock()：可带超时时间，拿不到锁立即返回或限时等待，避免无限期阻塞，非常适合防止死锁的场景。
• 可中断获取lockInterruptibly()：等待锁的过程中可以响应中断，而synchronized一旦进入等待无法被中断。

与synchronized相比，两者都是可重入互斥锁，synchronized由JVM层面实现、使用简单且经过持续优化；ReentrantLock则是API层面的实现，功能更丰富（公平性、可中断、可超时、多条件变量Condition），但要求开发者手动释放锁。面试时应能根据场景说明取舍依据，而非简单说“哪个更好”。

3.3 ReadWriteLock：读写分离提升读多写少场景吞吐

public class ReadWriteLockExample {
    private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    private final Map<String, Object> cache = new HashMap<>();
    public Object get(String key) {
        rwLock.readLock().lock();
        try {
            return cache.get(key);
        } finally {
            rwLock.readLock().unlock();
        }
    }
    public void put(String key, Object value) {
        rwLock.writeLock().lock();
        try {
            cache.put(key, value);
        } finally {
            rwLock.writeLock().unlock();
        }
    }
}

其设计思想是按访问模式细化锁粒度：

• 读锁共享：多个读线程可以同时持有读锁，因为它们不修改数据，互不冲突。在缓存、配置读取等读远多于写的场景中，并发度远高于单一互斥锁。
• 写锁独占：写线程持锁期间，其他读线程和写线程全部阻塞，保证写入的完整性与可见性。
• 写锁优先（防饥饿）：当已有写线程在等待时，新到的读线程通常不再直接插队获取读锁，否则写线程可能被源源不断的读请求“饿死”。

需要补充的高频考点是锁降级：写线程可以先释放写锁前获取读锁（写锁降级为读锁），从而保证自己刚写入的数据对后续读操作可见，同时允许其他读线程进入。反之，锁升级（持读锁直接获取写锁）不被支持，容易造成死锁。

四、原子类：CAS驱动的无锁编程

4.1 CAS的原理与三大问题

原子类的底层依赖处理器的Compare-And-Swap指令：CAS需要三个操作数——内存地址V、期望值E、新值N，仅当V处的当前值等于E时才将其更新为N，否则失败。整个过程由硬件保证原子性，无需加锁，因此也称“乐观锁”或“无锁编程”。

CAS并非完美，面试常考它的三个弱点：

1. ABA问题：值从A改为B又改回A，CAS察觉不到中间变化。对于普通数值计数影响不大，但对链表、栈等结构可能引发严重逻辑错误。
2. 自旋开销：竞争激烈时CAS反复失败重试，CPU空转消耗资源。
3. 只能保证单个变量原子性：多个变量的复合操作需要封装成对象后用AtomicReference整体更新。

4.2 常用原子类与ABA的解决方案

AtomicInteger、AtomicLong适合计数器、序列号生成；AtomicReference适合以对象为单位的原子更新；AtomicIntegerFieldUpdater等反射式更新器则能在不改动类定义的前提下为字段提供原子访问。

针对ABA问题，AtomicStampedReference在引用之外额外维护一个版本号戳，每次修改版本号递增，CAS时同时比对引用与版本号，从根源上识别“值被改过又改回来”的情况。这是面试中“如何解决ABA问题”的标准答案。

五、并发集合：线程安全容器的演进

ConcurrentHashMap是面试出镜率最高的并发集合。要点在于：早期版本采用分段锁设计，将整表划分为多个段，不同段可并发写入；后续版本放弃了分段，改为对桶头节点加锁的细粒度方案，空桶插入用CAS完成，冲突桶才用synchronized锁住头节点，锁粒度进一步缩小。此外，size的统计采用了类似分片计数的设计以减少竞争，且迭代器为弱一致性，不抛出并发修改异常。

CopyOnWriteArrayList采用写时复制：读操作完全无锁直接读当前数组；写操作先复制一份新数组，在新数组上修改后原子替换引用。它适合读极多、写极少且数据量不大的场景（如监听器列表、白名单），缺点是写开销大且只能保证最终一致性。

BlockingQueue家族以“阻塞”为核心语义：队列满时生产者阻塞、队列空时消费者阻塞，天然适合解耦生产者与消费者。ArrayBlockingQueue基于定长数组、单锁实现；LinkedBlockingQueue基于链表、默认近乎无界且读写分离两把锁，吞吐更高但需警惕内存溢出；PriorityBlockingQueue则按优先级出队。线程池的任务缓冲正是构建在BlockingQueue之上，两者应对照学习。

六、线程池：参数、流程与规范

6.1 为什么用线程池

频繁创建销毁线程的开销巨大，且无限制的线程数量会导致内存耗尽与过度上下文切换。线程池通过复用线程、控制并发度，将“任务”与“线程”解耦，是服务端程序稳定性的基石。

6.2 七大核心参数与执行流程

ThreadPoolExecutor的核心构造参数包括：核心线程数corePoolSize、最大线程数maximumPoolSize、空闲存活时间keepAliveTime及其单位、任务队列workQueue、线程工厂threadFactory、拒绝策略handler。

任务提交后的处理顺序是高频考题，务必牢记：

1. 当前线程数小于corePoolSize，直接创建核心线程执行；
2. 核心线程满，任务入队等待；
3. 队列也满，创建非核心线程（不超过maximumPoolSize）执行；
4. 线程数达到最大且队列满，触发拒绝策略。

四种内置拒绝策略为：直接抛异常中止、由提交线程自己执行（实现简单的负反馈限流）、静默丢弃新任务、丢弃队首最老任务。

参数设置的经验法则：CPU密集型任务线程数接近核心数加一，IO密集型可适当放大，但最终应以压测数据为准，而非死记公式。实际工程中不建议使用Executors的快捷工厂方法直接创建线程池，因为其默认的无界队列或超大线程数可能带来内存溢出与资源耗尽风险，推荐显式new ThreadPoolExecutor并明确每个参数。

七、同步工具类：线程协作四件套

• CountDownLatch（倒计时门闩）：计数器只能减不能重置，某线程调用await()阻塞，直到其他线程将计数减到零。典型场景是主线程等待多个并行子任务全部完成后汇总结果，强调“一次性、等全部”。
• CyclicBarrier（循环栅栏）：一组线程互相等待，全部到达屏障点后一起继续，计数可重置，因此可重复用于多轮同步，还支持在屏障动作中执行回调。它与CountDownLatch的区别——可重用、参与者彼此等待而非单方等待——是经典对比题。
• Semaphore（信号量）：维护一组许可，acquire获取、release归还，用于限制同时访问某资源的并发数量，如接口限流、连接池容量控制。其公平模式同样由AQS支撑。
• Exchanger（交换器）：提供两个线程在同步点交换数据的通道，适用于成对线程间的双向数据传递，例如缓冲区轮换。

这四个工具的共同底层正是前文提到的AQS：CountDownLatch与Semaphore基于共享模式，ReentrantLock基于独占模式。理解了AQS，整个同步工具家族就不再是孤立的知识点，而是一套设计模式的多种应用。

八、备考建议：从记忆到体系

面对并发面试题，建议按以下路径构建知识网络：

1. 先立骨架：以JUC五大模块为纲，确保每个模块都能说出核心类与适用场景；
2. 再通原理：围绕AQS这一枢纽，打通ReentrantLock、Semaphore、CountDownLatch的实现脉络，围绕CAS打通原子类与并发容器；
3. 后补模型：补充Java内存模型中的可见性、有序性、happens-before规则，理解volatile与final的语义，这是所有并发工具正确性的理论根基；
4. 落到实践：亲手实现生产者—消费者、多任务并行汇总等经典案例，把线程池参数调优、死锁排查等工程问题纳入复习范围。

并发编程的深度决定了天花板的高度。当你不再逐题背诵，而是能从架构设计、底层原理、实践规范三个层面自如展开时，任何并发面试题都会成为展示知识体系的舞台。