《java并发编程艺术pdf》权威指南

深入理解Java并发核心机制|从原理到实践的系统化解决方案

⚡ JVM线程模型深度剖析

理解Java并发的根基在于掌握JVM对线程的管理机制。Java线程与操作系统线程存在映射关系,但又具有自身独特的调度与生命周期特征。

每个Java线程在JVM中对应一个JavaThread对象,其底层通过操作系统原生线程实现。从JDK 5开始,HotSpot采用1:1线程模型(内核级线程),即一个Java线程映射一个内核线程。

〔1〕线程生命周期

Java线程状态由java.lang.Thread.State定义,共六种状态,其转换关系如下:

NEW → RUNNABLE

调用start()方法后,线程进入可运行状态。此时线程已分配必要资源,等待CPU调度执行。

RUNNABLE → BLOCKED

线程等待获取synchronized监视器锁时进入阻塞状态,属于被动等待。

RUNNABLE → WAITING

调用wait()/join()/LockSupport.park()进入无限期等待,需其他线程显式唤醒。

RUNNABLE → TIMED_WAITING

调用sleep()/wait(timeout)/join(timeout)/parkNanos()等进入限期等待。

WAITING/TIMED_WAITING → RUNNABLE

被notify()/notifyAll()或中断/超时后重新进入可运行队列。

RUNNABLE → TERMINATED

run()方法正常退出或抛出未捕获异常后进入终止状态。

〔2〕线程上下文切换

多线程并发执行时,CPU在不同线程间切换需保存当前执行上下文(寄存器、程序计数器、栈指针等),该过程称为上下文切换。

上下文切换开销不可忽视:在高并发场景下,频繁切换可能导致CPU时间大部分消耗在状态保存/恢复上,反而降低有效计算能力。

典型优化策略:

〔3〕守护线程与用户线程

JVM中线程分为用户线程与守护线程(Daemon Thread)。守护线程用于服务用户线程,当所有用户线程结束时,JVM自动退出,不会等待守护线程执行完毕。

典型守护线程场景:垃圾回收器(GC)、JIT编译器后台线程、JMX监控线程等。可通过thread.setDaemon(true)设置,但必须在start()前调用。

常见误区:认为守护线程会自动中断——实际上JVM退出时直接终止所有线程,不保证守护线程执行finally块。

⚙️ JUC核心工具类详解

java.util.concurrent包(JUC)是Java并发编程的基石,提供了一套高度封装、可复用的并发工具。掌握其原理与适用场景,是编写高质量并发代码的前提。

〔1〕原子类(Atomic*)

基于CAS(Compare-And-Swap)机制实现无锁原子操作,避免传统synchronized带来的性能开销。

AtomicInteger

适用于计数器、状态标识等场景。内部使用Unsafe类实现CAS操作,避免线程阻塞。

// 示例:线程安全计数器
AtomicInteger counter = new AtomicInteger(0);
int newValue = counter.incrementAndGet();

AtomicReference

支持对引用类型对象进行原子更新,常用于实现无锁数据结构。

AtomicStampedReference

解决ABA问题:通过版本戳(stamp)机制确保引用变化可追溯。

LongAdder

高并发场景下性能优于AtomicLong。采用分段累加策略,降低CAS竞争概率。

〔2〕同步工具类

CountDownLatch
CyclicBarrier
Semaphore

倒计时器,允许一个或多个线程等待其他线程完成操作。典型场景:主线程等待多个子线程初始化完成后继续执行。

// 示例:等待3个服务启动完成
CountDownLatch latch = new CountDownLatch(3);
executor.submit(() -> { serviceA.start(); latch.countDown(); });
executor.submit(() -> { serviceB.start(); latch.countDown(); });
executor.submit(() -> { serviceC.start(); latch.countDown(); });
latch.await(); // 主线程阻塞直至计数归零

循环屏障,允许多个线程在屏障处等待,直至所有线程到达后继续执行。支持重用( cyclic ),适用于多阶段并行计算。

// 示例:多线程分阶段计算
CyclicBarrier barrier = new CyclicBarrier(4, () -> System.out.println("阶段完成!"));
// 每个线程执行到barrier.await()时阻塞,4个线程全部到达后继续

信号量,控制同时访问特定资源的线程数量。可用于限流(如数据库连接池)。

// 示例:限制最多5个线程访问资源
Semaphore semaphore = new Semaphore(5);
semaphore.acquire(); // 获取许可
try {  } finally { semaphore.release(); }

〔3〕并发集合

JUC提供了一系列线程安全的集合类,性能与可扩展性远超传统Vector/Hashtable。

集合类型 线程安全机制 适用场景 性能特点
ConcurrentHashMap 分段锁(JDK7)→ CAS + synchronized(JDK8) 高并发读写场景的键值对存储 读无锁,写锁粒度小
CopyOnWriteArrayList 写时复制(修改时拷贝新数组) 读多写少场景(如监听器列表) 写性能差,读性能极高
ConcurrentLinkedQueue 无锁CAS实现的链表队列 高吞吐量无界队列 适用于生产者-消费者模型
BlockingQueue实现类 条件队列(Condition)或LockSupport 任务调度、工作队列 支持阻塞式take/poll操作

〔4〕Fork/Join框架

工作窃取(Work-Stealing)算法实现的并行任务框架,适用于可分解的大任务。

典型应用:并行计算大数组求和、并行文件处理、MapReduce预处理阶段。

public class SumTask extends RecursiveTask {
    private final long[] array;
    private final int start, end;
    @Override
    protected Long compute() {
        if (end - start < 10000) {
            long sum = 0;
            for (int i = start; i < end; i++) sum += array[i];
            return sum;
        }
        int mid = (start + end) / 2;
        invokeAll(new SumTask(array, start, mid), new SumTask(array, mid, end));
        return join() + join();
    }
}

〔锁机制〕Synchronized与Lock深度对比

锁是并发控制的核心手段,但不同锁的适用场景与性能特征差异显著。理解其底层原理是合理选型的基础。

〔1〕synchronized原理

Java对象头中的Mark Word存储锁状态,通过偏向锁→轻量级锁→重量级锁的升级路径优化性能:

锁升级是单向过程(不可降级),由JVM自动完成。可通过-XX:-UseBiasedLocking禁用偏向锁(高并发场景推荐)。

〔2〕ReentrantLock特性

可重入锁,提供比synchronized更灵活的控制能力:

可中断获取

lockInterruptibly()允许在等待锁时响应中断,避免死锁

公平锁支持

构造时传入true启用公平锁(按请求顺序分配),但吞吐量略低

条件队列(Condition)

替代Object.wait/notify,支持多条件队列(如读写锁的读/写队列)

尝试获取锁

tryLock()支持超时返回,避免无限期等待

〔3〕读写锁(ReentrantReadWriteLock)

分离读写操作:读锁共享、写锁独占,适用于读多写少场景。

private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
private final Lock readLock = rwLock.readLock();
private final Lock writeLock = rwLock.writeLock();
public Data read() {
    readLock.lock();
    try { return cache.get(); } finally { readLock.unlock(); }
}
public void write(Data data) {
    writeLock.lock();
    try { cache.put(data); } finally { writeLock.unlock(); }
}

注意:读锁可升级为写锁(需先释放读锁再获取写锁),但写锁不可降级为读锁(避免死锁风险)。

〔内存模型〕JMM与可见性保障

Java内存模型(JMM)定义了线程与主内存的交互规则,确保并发程序的正确性。核心概念包括happens-before关系、volatile语义、内存屏障等。

〔1〕happens-before原则

程序执行的可见性保障基于以下规则:

程序顺序规则

单线程内,按代码顺序执行

监视器锁规则

解锁synchronized前的写对后续加锁可见

volatile规则

写volatile变量前的写对后续读volatile变量可见

线程启动规则

start()前的写对新线程可见

线程加入规则

join()后的读对线程内写可见

中断检测规则

检测到中断前的写对后续处理可见

〔2〕volatile深度解析

volatile关键字提供轻量级同步机制,适用于状态标志、单次初始化等场景:

// 示例:安全的单例模式(DCL + volatile)
public class Singleton {
    private static volatile Singleton instance;
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton(); // 避免指令重排序导致未完全初始化
                }
            }
        }
        return instance;
    }
}

典型误用:在多线程计数器中使用volatile int counter++——应改用AtomicInteger或synchronized。

〔3〕内存屏障(Memory Barrier)

JMM通过内存屏障禁止特定指令重排序:

屏障类型 作用 对应volatile操作
LoadLoad 禁止Load1与Load2重排序 读volatile前屏障
StoreStore 禁止Store1与Store2重排序 写volatile前屏障
StoreLoad 防止Store与后续Load重排序 写volatile后屏障(最重)
LoadStore 禁止Load与后续Store重排序 读volatile后屏障

〔线程池〕ThreadPoolExecutor原理与实践

线程池通过复用线程减少创建/销毁开销,是高并发系统的基石。合理配置参数对性能至关重要。

〔1〕核心参数详解

ThreadPoolExecutor(
    corePoolSize,      // 核心线程数(常驻)
    maximumPoolSize,   // 最大线程数(含非核心)
    keepAliveTime,     // 非核心线程存活时间
    unit,
    workQueue,         // 任务队列
    threadFactory,     // 线程创建工厂
    handler            // 拒绝策略
)

workQueue类型

  • SynchronousQueue:无缓冲队列,直接提交给线程
  • LinkedBlockingQueue:无界队列(默认Integer.MAX_VALUE)
  • ArrayBlockingQueue:有界队列,需指定容量
  • PriorityBlockingQueue:优先级队列

拒绝策略

  • AbortPolicy:抛出RejectedExecutionException
  • CallerRunsPolicy:由调用线程执行任务
  • DiscardPolicy:静默丢弃
  • DiscardOldestPolicy:丢弃最旧任务

〔2〕动态线程池配置

生产环境推荐使用可配置化的线程池(如阿里DynamicThreadPool):

示例:基于配置中心动态调整核心线程数(每核2线程)
corePoolSize = Runtime.getRuntime().availableProcessors() * 2
maxPoolSize = corePoolSize * 2
queueCapacity = 1000

〔3〕常见陷阱

// 推荐写法:显式配置线程池
@Bean
public ExecutorService orderExecutor() {
    return new ThreadPoolExecutor(
        8, 16, 60, TimeUnit.SECONDS,
        new ArrayBlockingQueue<>(500),
        new ThreadFactoryBuilder().setNameFormat("order-pool-%d").build(),
        new ThreadPoolExecutor.CallerRunsPolicy()
    );
}

〔性能优化〕高并发场景实战策略

理论知识需结合实践验证。以下策略经生产环境反复验证,可显著提升系统吞吐量与稳定性。

〔1〕减少锁竞争

分段锁(Segmented Locking)

将数据分片,每片独立加锁。ConcurrentHashMap即采用此策略。

读写分离

使用ReentrantReadWriteLock分离读写操作,提升读吞吐量。

无锁化设计

采用CAS操作(Atomic类)、线程本地存储(ThreadLocal)、不可变对象等技术。

批量操作

批量获取资源(如批量数据库操作),减少锁持有时间。

〔2〕避免上下文切换

〔3〕性能调优工具链

工具 用途 典型命令
jstack 线程堆栈分析 jstack -l PID | grep "WAITING" -A 5
jstat GC与内存统计 jstat -gcutil PID 1000
Arthas 在线诊断 thread -n 10 # 查看CPU占用最高的线程
VisualVM 可视化监控 本地连接或远程JMX

性能调优黄金法则:先测量,再优化;小步快跑,持续验证。避免“预优化”陷阱!

〔4〕真实案例:电商订单处理

某电商平台订单处理系统,原方案使用单线程队列处理,QPS仅2000。优化方案:

  1. 将订单处理拆分为:校验→库存扣减→支付→通知
  2. 为各阶段配置专用线程池(核心线程数=CPU核心数)
  3. 使用Disruptor替代BlockingQueue(环形缓冲+无锁)
  4. 库存扣减采用预占库存+异步提交方案

优化后系统QPS提升至18,000,平均响应时间从42ms降至8ms。

〔高频问题〕网友最关心的10个问题

Q1:为什么synchronized比Lock慢?
Q2:volatile能替代synchronized吗?
Q3:线程池如何设置合理参数?
Q4:如何避免死锁?
Q5:Java线程与OS线程一一对应吗?

答案是否定的!JDK6后synchronized进行了大量优化(偏向锁/轻量级锁),在低竞争场景下性能优于Lock。仅在高竞争、需高级功能(如公平锁、超时获取)时推荐Lock。

不能!volatile仅保证可见性与禁止重排序,不保证原子性。例如i++包含读-改-写三步操作,仍需加锁。

通用公式:
CPU密集型:corePoolSize = CPU核心数 + 1
IO密集型:corePoolSize = CPU核心数 × 2
实际需结合压测调整。推荐先用CorePoolSize=2×CPU核数,再逐步优化。

死锁四要素:互斥、持有并等待、不可剥夺、循环等待。避免方案:
1. 统一锁顺序(如按对象ID排序)
2. 使用tryLock()设置超时
3. 减少锁嵌套
4. 使用线程池内置的中断机制

JDK5起采用1:1模型(一个Java线程对应一个OS线程)。早期Green Thread为M:N模型,但已废弃。

网友们还关心