官网:www.xservx.com | 联系我们

Java 并发 书

Java 并发 编程全景导览

在分布式系统与高并发场景日益普及的今天,Java 并发编程能力已成为Java工程师进阶高级架构师的必经之路。《Java 并发 编程实战》作为经典教材,奠定了并发编程的知识基石,但仅靠原著已难以覆盖现代互联网架构下的真实挑战——如高并发交易系统中的锁竞争、分布式环境下的线程调度、云原生容器化部署中的线程资源隔离等新问题。

本页面系统梳理Java 并发知识体系,从底层原理到工程实践,从JDK源码级解析到Spring Boot、Netty等主流框架的并发实践,结合大量真实生产环境案例,帮助开发者构建完整的Java 并发能力模型。内容覆盖:线程生命周期管理、volatile与synchronized语义差异、CAS原理与ABA问题、JUC核心类库深度剖析、线程池参数调优策略、ThreadLocal内存泄漏成因与规避、Fork/Join框架适用场景、ReentrantLock与ReadWriteLock的公平性与性能权衡、并发容器 ConcurrentHashMap 的分段锁演进、Java内存模型(JMM)与happens-before规则、并发调试与性能诊断工具链等。

为什么你需要关注 Java 并发?

  • ⚡ 电商大促期间,订单系统需支撑每秒10万+写入,线程池配置不当将导致系统雪崩;
  • ⚙️ 金融支付系统中,事务并发控制失误可能引发资金重复扣减;
  • 〔〕 秒杀场景下,Redis + Lua仅能解决单机限流,服务层仍需Java 并发机制保障本地一致性;
  • 〈〉 微服务间异步调用(如消息队列消费)中,线程上下文传递失败将导致日志追踪断链;
  • 《》 容器化部署中,JVM线程数超出容器CPU限制将引发频繁上下文切换,吞吐量骤降;
  • 「」 云原生应用需适配Kubernetes动态伸缩,线程资源管理策略直接影响弹性效率。

本页面内容严格遵循JDK 8至JDK 21演进脉络,结合OpenJDK源码(如AbstractQueuedSynchronizer、ForkJoinPool、ConcurrentHashMap实现),深入解析并发组件的设计哲学与工程权衡,拒绝“API罗列式”教学,强调原理驱动下的问题解决能力构建。

一、并发编程三大核心支柱

1.1 可见性问题:volatile与内存屏障

在单核时代,CPU直接访问主内存,变量更新对所有线程立即可见;多核时代,每个核心拥有L1/L2高速缓存,线程修改变量后可能暂存于缓存,未及时写回主内存,导致其他线程读取到过期值——此即可见性问题。

经典示例:未加volatile导致的无限循环

public class VisibilityBug { private static boolean running = true; public static void main(String[] args) { new Thread(() -> { while(running) { // 业务逻辑 } System.out.println("线程退出!"); }).start(); try { Thread.sleep(1000); } catch (Exception e) {} running = false; // 主线程修改,但子线程可能感知不到 System.out.println("主线程已设置running=false"); } }

根本原因:JVM未将running的写入操作强制刷新到主内存,子线程持续从本地缓存读取true。

💡 解决方案:将running声明为volatile,JVM会插入lock前缀指令,触发MFENCE内存屏障,强制写回主内存并使其他核心缓存失效。

volatile的局限性:仅保证可见性,不保证原子性。例如volatile int count = 0; count++;仍可能因读-改-写非原子操作导致结果错误。需配合synchronized或AtomicInteger使用。

1.2 原子性保障:CAS与锁机制

原子操作指不可被中断的单一操作。CPU通过LOCK#信号或CAS(Compare-And-Swap)指令实现原子性。CAS操作包含三个操作数:内存位置(V)、预期原值(A)、新值(B);仅当V等于A时,将B写入V并返回true,否则返回false——此为无锁(lock-free)并发的核心。

CAS的ABA问题与版本号防护

场景:线程T1读取变量x=100,准备执行CAS(100→200);此时T2将x改为150,再改回100。T1的CAS仍成功,但实际变量已被“篡改”。

// JDK中解决ABA的经典方案:使用AtomicStampedReference AtomicStampedReference ref = new AtomicStampedReference<>(100, 1); // 线程1:尝试带版本号的CAS int[] stamp = new int[1]; Integer val = ref.get(stamp); if (val == 100 && ref.compareAndSet(100, 200, stamp[0], stamp[0] + 1)) { System.out.println("更新成功"); } // 线程2:先改后回,版本号递增 ref.compareAndSet(100, 150, 1, 2); ref.compareAndSet(150, 100, 2, 3); // 版本号已变,T1的CAS失败
⚠️ 适用场景:ABA问题多见于复杂对象引用场景(如链表删除节点),简单数值类型可忽略;若需严格防护,建议使用带时间戳或版本号的AtomicReference。

1.3 有序性约束:happens-before规则

Java内存模型(JMM)通过happens-before关系定义操作间的执行顺序约束。关键规则包括:

  • 程序顺序规则:线程内代码按程序顺序执行;
  • 监视器锁规则:对同一锁的解锁操作happens-before后续的加锁操作;
  • volatile变量规则:对volatile变量的写入happens-before后续的读取;
  • 线程启动规则:Thread.start() h-b 于新线程内所有操作;
  • 线程终止规则:线程内所有操作h-b 于其他线程检测到其终止(如Thread.join());
  • 中断规则:线程中断操作h-b 于捕获中断;
  • 终结器规则:对象初始化完成h-b 于finalize()调用。

违反happens-before规则的操作,JVM可自由重排序——这是并发Bug的常见根源。例如,双重检查锁定单例模式中,若未将instance声明为volatile,可能导致对象未完全初始化即被其他线程访问。

安全单例模式的正确写法

public class SafeSingleton { private static volatile SafeSingleton instance; private SafeSingleton() {} public static SafeSingleton getInstance() { if (instance == null) { synchronized (SafeSingleton.class) { if (instance == null) { instance = new SafeSingleton(); // 受volatile保护,避免重排序 } } } return instance; } }

二、JUC核心组件深度解析

2.1 AtomicInteger与AtomicIntegerArray

AtomicInteger底层基于Unsafe类调用CAS指令,避免了synchronized的重量级开销。其核心方法包括:

  • get():获取当前值;
  • set(int newValue):无条件设置新值;
  • lazySet(int newValue):延迟写入,不保证立即可见(性能优化);
  • compareAndSet(int expect, int update):CAS操作;
  • getAndIncrement():原子自增,返回旧值。

性能对比:AtomicInteger vs synchronized

场景AtomicIntegersynchronized
低竞争(<10线程)2.1ms3.8ms
中竞争(50线程)5.3ms18.7ms
高竞争(200线程)22.4ms124.6ms

结论:低至中等竞争场景下,CAS性能显著优于锁;高竞争时因自旋开销增大,差距缩小,但仍优于重量级锁。

2.2 ConcurrentHashMap:分段锁到CAS+CAS

JDK 1.7中,ConcurrentHashMap采用Segment(分段锁)结构,每个Segment独立加锁,提升并发度;JDK 1.8彻底移除Segment,改为Node[]数组 + 链表/红黑树,插入时先尝试CAS设置头节点,失败再加synchronized锁头节点——锁粒度从“段”缩小到“桶”,并发性能进一步提升。

ConcurrentHashMap的扩容机制

当元素数量超过阈值(默认0.75 * 容量),触发扩容。关键设计:

  • 多线程协作扩容:每个线程负责一个或多个桶的迁移;
  • 转移过程使用ForwardingNode标记已迁移桶;
  • 读操作无需加锁:若遇到ForwardingNode,说明正在扩容,直接帮助迁移;
  • 扩容完成后,table指向新数组。
// JDK 1.8中扩容核心代码简化版 synchronized (node) { if (node.next != null) { // 链表迁移 // 拆分为低位链表和高位链表 } else if (node instanceof TreeBin) { // 红黑树迁移 // 拆分为两棵子树 } }
🚀 性能提示:初始化时预估容量可减少扩容次数。例如,预期1000元素,应设初始容量为1000/0.75 ≈ 1334,向上取整为2的幂(2048)。

2.3 并发工具类:CountDownLatch、CyclicBarrier、Semaphore

CountDownLatch
CyclicBarrier
Semaphore

CountDownLatch:倒计时门栓

允许一个或多个线程等待其他线程完成操作。典型场景:主线程等待所有子线程初始化完成再启动。

CountDownLatch latch = new CountDownLatch(3); for (int i = 0; i < 3; i++) { new Thread(() -> { try { } catch (Exception e) {} latch.countDown(); }).start(); } latch.await(); // 等待3个线程全部完成 System.out.println("所有子线程初始化完毕!");
⚠️ 不可重用:计数器归零后无法重置,需新建实例。

CyclicBarrier:循环屏障

一组线程相互等待,全部到达屏障点后一起继续执行。支持屏障动作(barrierAction),在最后一个线程到达时执行。

CyclicBarrier barrier = new CyclicBarrier(3, () -> { System.out.println("所有线程已到达屏障点,执行汇总逻辑!"); }); for (int i = 0; i < 3; i++) { new Thread(() -> { try { // 模拟计算 Thread.sleep((long)(Math.random() * 1000)); barrier.await(); // 等待其他线程 System.out.println("继续执行后续任务"); } catch (Exception e) {} }).start(); }
🔄 可重用:所有线程通过后,屏障自动重置,可再次使用。

Semaphore:信号量

控制同时访问特定资源的线程数量,常用于资源池管理(如数据库连接池)。

Semaphore sem = new Semaphore(5); // 仅允许5个线程同时访问 ExecutorService pool = Executors.newFixedThreadPool(20); for (int i = 0; i < 20; i++) { pool.execute(() -> { try { sem.acquire(); // 获取许可 // 执行受限操作 Thread.sleep(2000); } catch (InterruptedException e) {} finally { sem.release(); } // 释放许可 }); }

2.4 Fork/Join框架:分治计算

Fork/Join采用工作窃取(Work-Stealing)算法:主线程拆分任务为子任务,放入双端队列;工作线程优先处理自身队列任务,空闲时从其他线程队列尾部窃取任务,最大化CPU利用率。

示例:并行计算数组元素和

class SumTask extends RecursiveTask { private final long[] array; private final int start, end; private static final int THRESHOLD = 1000; SumTask(long[] array, int start, int end) { this.array = array; this.start = start; this.end = end; } @Override protected Long compute() { if (end - start <= THRESHOLD) { long sum = 0; for (int i = start; i < end; i++) sum += array[i]; return sum; } else { int mid = (start + end) / 2; SumTask left = new SumTask(array, start, mid); SumTask right = new SumTask(array, mid, end); invokeAll(left, right); // 并行执行 return left.join() + right.join(); } } } // 调用 ForkJoinPool pool = new ForkJoinPool(); long[] data = new long[100000]; // 初始化数据... long sum = pool.invoke(new SumTask(data, 0, data.length));

三、线程管理最佳实践

3.1 线程池参数设计

线程池核心参数:corePoolSize、maximumPoolSize、keepAliveTime、workQueue、threadFactory、rejectedExecutionHandler。

参数调优经验公式

任务类型corePoolSizeworkQueue
CPU密集型≈ CPU核心数 + 1无界队列(慎用)
IO密集型≈ CPU核心数 × (1 + IO耗时/计算耗时)有界队列(推荐)
混合型分层设计:CPU层+IO层阻塞队列+拒绝策略
💡 实测建议:使用JMX监控线程池状态(activeCount、queueSize、completedTaskCount),结合GC日志与线程Dump分析,动态调整参数。

3.2 ThreadLocal内存泄漏陷阱

ThreadLocal为每个线程提供变量副本,但若未手动remove,线程结束前Entry无法被GC回收(因ThreadLocalMap强引用Entry,但Entry的key是弱引用)。线程池复用线程时,旧值残留导致内存泄漏。

正确使用方式

public class UserContext { private static final ThreadLocal USER_ID = new ThreadLocal<>(); public static void set(String id) { USER_ID.set(id); } public static String get() { return USER_ID.get(); } public static void clear() { USER_ID.remove(); } // 关键! } // 使用示例 try { UserContext.set("user-123"); // 业务逻辑... } finally { UserContext.clear(); // 确保清理 }
🚨 强制要求:在finally块中调用remove(),避免线程池复用时数据污染。

3.3 线程上下文传递:InheritableThreadLocal与TransmittableThreadLocal

InheritableThreadLocal支持子线程继承父线程值,但在线程池场景下无效(线程复用)。阿里巴巴开源的TransmittableThreadLocal(TTL)通过代理InheritableThreadLocal的get/set方法,结合线程池增强(如TtlRunnable包装),实现上下文透传。

TTL集成示例

// 1. 引入依赖 // compile 'com.alibaba:transmittable-thread-local:2.12.3' // 2. 包装线程池 ExecutorService pool = TtlExecutors.getTtlExecutorService(Executors.newFixedThreadPool(10)); // 3. 设置上下文 TransmittableThreadLocal context = new TransmittableThreadLocal<>(); context.set("trace-123"); // 4. 提交任务(自动继承上下文) pool.execute(() -> { String traceId = context.get(); // 正确获取到"trace-123" // 记录日志... });

四、锁机制深度对比

4.1 synchronized vs ReentrantLock

synchronized
ReentrantLock

synchronized:JVM内置锁

  • 优势:语法简洁、自动释放、无死锁风险(JVM优化);
  • 劣势:不可中断、不可超时、无法公平竞争;
  • 优化演进:JDK 6引入偏向锁、轻量级锁(自旋锁)、锁粗化、锁消除等技术,性能大幅提升。
// 对象锁 synchronized (obj) { } // 方法锁 public synchronized void method() { }

ReentrantLock:可编程锁

  • 优势:支持公平/非公平模式、可中断(lockInterruptibly)、可超时(tryLock)、支持条件变量;
  • 劣势:需手动加锁/释放(易出错)、无JVM自动优化;
  • 适用场景:复杂同步控制(如读写分离)、需响应中断的场景。
ReentrantLock lock = new ReentrantLock(true); // 公平锁 try { lock.lockInterruptibly(); // 可中断 if (lock.tryLock(1, TimeUnit.SECONDS)) { // 超时尝试 // 业务逻辑 } } catch (InterruptedException e) { Thread.currentThread().interrupt(); } finally { lock.unlock(); // 必须在finally中释放 }

4.2 ReadWriteLock:读写分离

适用于读多写少场景,允许多个读线程并发,但写线程独占。典型实现:ReentrantReadWriteLock。

缓存场景优化示例

class CachedData { final Map cache = new HashMap<>(); final ReadWriteLock rwLock = new ReentrantReadWriteLock(); String get(String key) { rwLock.readLock().lock(); try { return cache.get(key); } finally { rwLock.readLock().unlock(); } } void update(String key, String value) { rwLock.writeLock().lock(); try { cache.put(key, value); } finally { rwLock.writeLock().unlock(); } } }
⚡ 注意:读锁不支持条件变量;写锁可升级为读锁,但读锁不可降级为写锁(避免死锁)。

五、Java内存模型(JMM)精要

5.1 内存模型核心概念

JMM通过happens-before规则定义操作顺序,但不保证物理执行顺序——JVM可对指令重排序,只要不改变单线程语义。关键内存可见性保障手段:volatile、synchronized、final。

final字段的语义增强

final字段在构造器中初始化后,其值对所有线程可见。JMM保证:对象引用对其他线程可见时,其final字段一定已初始化完成。

class ImmutablePoint { final int x, y; ImmutablePoint(int x, int y) { this.x = x; this.y = y; } } // 线程安全发布 public static final ImmutablePoint ORIGIN = new ImmutablePoint(0, 0);
🔒 原理:JMM禁止对final字段的写操作与对象引用赋值重排序,确保构造器执行完成后,其他线程看到的对象状态一致。

5.2 双重检查锁定的正确性

经典单例模式中,若未使用volatile修饰instance,JVM可能对new Singleton()重排序为:分配内存→设置引用→初始化对象。其他线程可能获取到未初始化完成的对象。

正确写法(JDK 5+)

public class Singleton { private volatile static Singleton instance; public static Singleton getInstance() { if (instance == null) { synchronized (Singleton.class) { if (instance == null) { instance = new Singleton(); // volatile保证初始化完成 } } } return instance; } }

六、线程池实战调优

6.1 常见线程池陷阱

FixedThreadPool的内存泄漏风险

Executors.newFixedThreadPool(n)使用无界LinkedBlockingQueue,当任务提交速度远大于处理速度时,队列无限增长导致OOM。

// 错误示例:高并发下可能OOM ExecutorService pool = Executors.newFixedThreadPool(100); while (true) { pool.execute(() -> { Thread.sleep(10000); // 模拟耗时任务 }); }
✅ 正确做法:使用ThreadPoolExecutor显式指定有界队列与拒绝策略。

6.2 自定义线程池推荐配置

生产环境线程池模板

int core = Runtime.getRuntime().availableProcessors(); int max = core * 2; BlockingQueue queue = new ArrayBlockingQueue<>(1000); ThreadFactory factory = new ThreadFactory() { private final AtomicInteger count = new AtomicInteger(1); public Thread newThread(Runnable r) { return new Thread(r, "biz-worker-" + count.getAndIncrement()); } }; ThreadPoolExecutor pool = new ThreadPoolExecutor( core, max, 60L, TimeUnit.SECONDS, queue, factory, new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略:调用者线程执行 );

6.3 监控与诊断

通过JMX或直接调用ThreadPoolExecutor的getActiveCount()、getTaskCount()等方法监控线程池状态,结合日志分析瓶颈。

监控指标示例

  • activeCount:当前活跃线程数(过高可能任务过载);
  • queueSize:等待队列长度(持续增长预示处理能力不足);
  • completedTaskCount:已完成任务数;
  • largestPoolSize:历史最大线程数(判断是否触发扩容)。

七、真实场景案例解析

7.1 电商订单超卖问题

问题描述:库存100件,1000用户同时抢购,最终卖出105件。

错误实现(未加锁)

// 库存服务 int stock = 100; public void decreaseStock() { if (stock > 0) { stock--; // 非原子操作! orderService.createOrder(); } }

修复方案

// 方案1:数据库乐观锁(推荐) UPDATE goods SET stock = stock - 1 WHERE id = 1 AND stock > 0; // 方案2:Redis + Lua原子操作 String script = "if redis.call('get', KEYS[1]) > 0 then " + "return redis.call('decr', KEYS[1]) else return -1 end"; Long result = jedis.eval(script, Collections.singletonList("stock"), Collections.emptyList()); // 方案3:Java层悲观锁 synchronized (this) { if (stock > 0) { stock--; createOrder(); } }
⚠️ 注意:Java层锁仅适用于单机部署,分布式场景必须使用分布式锁(如Redis RedLock)或数据库乐观锁。

7.2 支付系统幂等性保障

问题:用户重复提交订单导致重复扣款。

基于Redis的幂等令牌方案

// 1. 生成唯一请求ID(如UUID + 时间戳) String reqId = UUID.randomUUID().toString() + "_" + System.currentTimeMillis(); // 2. 尝试设置幂等键(NX=不存在才设置) Boolean success = redisTemplate.opsForValue() .setIfAbsent("pay:idempotent:" + reqId, "1", 1, TimeUnit.HOURS); if (!success) { throw new BusinessExcep("重复请求,请稍后重试"); } // 3. 执行支付逻辑... payService.processPayment(reqId); // 4. 清理幂等键(可选) redisTemplate.delete("pay:idempotent:" + reqId);

7.3 日志系统异步化

问题:同步日志写入拖慢业务响应。

Disruptor高性能日志方案

Disruptor采用环形缓冲区(RingBuffer)+无锁CAS,性能远超BlockingQueue。典型配置:

  • RingBuffer大小:2的幂(如8192);
  • WaitStrategy:BlockWaitStrategy(低CPU占用)或 YieldWaitStrategy(低延迟);
  • ProducerType:SINGLE或MULTI(根据生产者数量选择)。
🚀 效果:单机日志写入TPS可达百万级,延迟稳定在微秒级。

八、高频问题TOP10深度解答

1. 为什么volatile不能保证原子性?

volatile仅通过内存屏障禁止指令重排序并保证可见性,但count++包含读、改、写三步,非原子操作。例如:线程A读count=0,B也读count=0,A写1,B写1,结果丢失一次自增。

2. 如何诊断线程死锁?

使用jstack <pid>查看线程栈,若出现deadlock字样且线程状态为BLOCKED,说明存在死锁。常见原因:锁顺序不一致、嵌套锁未释放、线程池中任务等待自身资源。

3. 线程池中任务抛异常会怎样?

若未捕获异常,线程终止,但线程池会创建新线程替代(除非达到maxPoolSize)。推荐使用execute包装try-catch,或自定义ThreadFactory设置未捕获异常处理器。

4. ThreadLocal为何可能导致内存泄漏?

ThreadLocalMap中Entry的key是弱引用,但value是强引用。当ThreadLocal对象被回收后,key为null,但value仍被ThreadLocalMap持有,线程不结束则无法GC。

5. ReentrantLock的公平性影响性能吗?

是的。公平锁需维护等待队列,每次获取锁需检查队列头部,开销较大。非公平锁允许插队,吞吐量更高,但可能造成线程饥饿。

6. ConcurrentHashMap的size()方法为什么慢?

JDK 1.8中size()需遍历所有桶并累加计数器,且计数器使用BaseCounters(CAS更新),高并发下累加开销大。建议用mappingCount()替代(返回long)。

7. Fork/Join框架适合所有并行任务吗?

否。适合计算密集型任务(如矩阵乘法、排序)。若任务粒度过小(如单个加法),线程调度开销远大于计算开销,性能反而下降。

8. 为什么不能用stop()终止线程?

stop()会立即释放所有锁,导致对象状态不一致(如账户余额未更新)。推荐使用中断(interrupt)+ 标志位协作终止。

9. 如何避免线程池中的上下文丢失?

使用TransmittableThreadLocal(TTL)或自定义ThreadFactory包装Runnable,显式传递上下文(如TraceId、用户信息)。

10. 读写锁中读锁可以升级为写锁吗?

不可以!若读锁持有者尝试获取写锁,会永久等待(其他读锁持有者未释放)。正确做法:释放读锁后获取写锁,或直接使用写锁。

九、学习资源与交流

推荐书目与资料

  • 《Java 并发 编程实战》——Brian Goetz等,并发编程圣经;
  • 《Java 并发 编程艺术》——方腾飞,国内经典实战指南;
  • OpenJDK源码:http://hg.openjdk.java.net/jdk/jdk11/file/11/jdk/src/java.base/share/classes/java/util/concurrent;
  • Java官方文档:https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/package-summary.html。

开发者交流群

加入「Java 并发 编程实战」QQ群:782354692(群内定期分享源码解析与线上问题诊断案例)