【JVM深度解析】第25篇：volatile与synchronized深度原理

摘要volatile 和 synchronized 是 Java 并发编程中最常用的两个关键字但它们的底层原理却大不相同。volatile 通过内存屏障保证可见性和有序性无原子性synchronized 通过监视器锁保证原子性、可见性和有序性。本文深入解析两者的底层实现volatile 的写屏障/读屏障、CAS 与 volatile 的关系、以及 synchronized 的锁升级机制偏向锁 → 轻量级锁 → 重量级锁。理解这些你才能真正用好并发工具写出高效安全的多线程代码。一、volatile 深度解析1.1 volatile 的作用volatile 的三大作用 ┌──────────────────────────────────────────────────────────────────┐ │ │ │ 1. 可见性Visibility │ │ - 每次读取都从主内存读取 │ │ - 每次写入都立即刷新到主内存 │ │ │ │ 2. 有序性Ordering │ │ - 防止指令重排序 │ │ - 写操作前插入 StoreStore 屏障 │ │ - 读操作后插入 LoadLoad LoadStore 屏障 │ │ │ │ 3. 无原子性 │ │ - volatile long/counter 仍然不是线程安全的 │ │ │ └──────────────────────────────────────────────────────────────────┘1.2 volatile 写屏障// volatile 写入的语义publicclassVolatileWrite{privatevolatileintvalue;publicvoidwrite(intnewValue){valuenewValue;// volatile 写}}// 等价于publicvoidwrite(intnewValue){// StoreStore 屏障 - 确保之前的 store 都刷新到主内存__asm__volatile(sfence);valuenewValue;// StoreLoad 屏障 - 确保之前的 store 对后续的 load 可见__asm__volatile(mfence);}1.3 volatile 读屏障// volatile 读取的语义publicclassVolatileRead{privatevolatileintvalue;publicintread(){intresultvalue;// volatile 读returnresult;}}// 等价于publicintread(){// LoadLoad 屏障 - 确保之前 load 完成__asm__volatile(lfence);intresultvalue;// LoadStore 屏障 - 确保 load 之后不会发生 store 重排序// 隐含在大多数架构中returnresult;}1.4 volatile 的使用场景// 正确使用 volatile 的场景// 场景 1状态标志publicclassService{privatevolatilebooleanrunningtrue;publicvoidstop(){runningfalse;// 其他线程立即看到变化}publicvoidrun(){while(running){// 正确volatile 保证可见性}}}// 场景 2单例模式双重检查publicclassSingleton{privatestaticvolatileSingletoninstance;publicstaticSingletongetInstance(){if(instancenull){synchronized(Singleton.class){if(instancenull){instancenewSingleton();// volatile 防止重排序}}}returninstance;}}// 场景 3发布安全不可变对象publicclassHolder{privatestaticvolatileHolderinstance;// 注意value 本身是不可变对象publicstaticHoldergetInstance(){if(instancenull){instancenewHolder();}returninstance;}}二、synchronized 深度解析2.1 synchronized 的三大特性synchronized 保证的三大事物 ┌──────────────────────────────────────────────────────────────────┐ │ │ │ 1. 原子性Atomicity │ │ - 同一时刻只有一个线程能持有锁 │ │ - 其他线程阻塞等待 │ │ │ │ 2. 可见性Visibility │ │ - unlock 前必须刷新所有共享变量到主内存 │ │ - lock 时清空工作内存从主内存重新加载 │ │ │ │ 3. 有序性Ordering │ │ - 持有锁后保证代码块内部不发生重排序 │ │ │ └──────────────────────────────────────────────────────────────────┘2.2 锁升级机制┌──────────────────────────────────────────────────────────────────┐ │ synchronized 锁升级过程 │ ├──────────────────────────────────────────────────────────────────┤ │ │ │ ┌──────────────────────────────────────────────────────────┐ │ │ │ 偏向锁Biased Lock │ │ │ │ │ │ │ │ 场景只有一个线程反复进入同步块 │ │ │ │ 原理记录线程 ID下次直接进入 │ │ │ │ 开销无无需 CAS │ │ │ │ 撤销其他线程竞争 → 批量撤销 / 偏向锁撤销 │ │ │ └──────────────────────────────────────────────────────────┘ │ │ ↓ 其他线程竞争 │ │ ┌──────────────────────────────────────────────────────────┐ │ │ │ 轻量级锁Lightweight Lock │ │ │ │ │ │ │ │ 场景少量线程交替进入同步块 │ │ │ │ 原理CAS 替换 Mark Word竞争失败自旋等待 │ │ │ │ 开销自旋消耗 CPU │ │ │ │ 升级自旋超过阈值 → 膨胀为重量级锁 │ │ │ └──────────────────────────────────────────────────────────┘ │ │ ↓ 竞争激烈 │ │ ┌──────────────────────────────────────────────────────────┐ │ │ │ 重量级锁Heavyweight Lock │ │ │ │ │ │ │ │ 场景多线程竞争同一把锁 │ │ │ │ 原理OS Mutex线程阻塞挂起 │ │ │ │ 开销上下文切换毫秒级 │ │ │ │ 特点不再自旋释放时唤醒等待线程 │ │ │ └──────────────────────────────────────────────────────────┘ │ │ │ └──────────────────────────────────────────────────────────────────┘2.3 Mark Word 与锁状态Mark Word 的 64 位结构无锁状态 ┌──────────────────────────────────────────────────────────────────┐ │ │ │ ┌──────────────────────────────────────────────────────────┐ │ │ │ 25 bit │ 31 bit │ 1 bit │ 4 bit │ 1 bit │ │ │ │ unused │ 对象哈希码 │ GC age │ 偏向锁 │ 偏向 │ │ │ │ │ (hashcode) │ │ epoch │ 标志 │ │ │ └──────────────────────────────────────────────────────────┘ │ │ │ │ 偏向锁状态 │ │ ┌──────────────────────────────────────────────────────────┐ │ │ │ 54 bit │ 2 bit │ 1 bit │ 1 bit │ │ │ │ 线程指针Thread ID │ epoch │ 偏向锁 │ 偏向 │ │ │ │ │ │ 类型 │ 标志 │ │ │ └──────────────────────────────────────────────────────────┘ │ │ │ │ 轻量级锁状态 │ │ ┌──────────────────────────────────────────────────────────┐ │ │ │ 62 bit │ │ │ │ 指向栈中锁记录的指针 │ │ │ │ │ │ │ └──────────────────────────────────────────────────────────┘ │ │ │ │ 重量级锁状态 │ │ ┌──────────────────────────────────────────────────────────┐ │ │ │ 62 bit │ │ │ │ 指向互斥量Mutex的指针 │ │ │ │ │ │ │ └──────────────────────────────────────────────────────────┘ │ │ │ └──────────────────────────────────────────────────────────────────┘2.4 synchronized 实战// synchronized 最佳实践// 1. 锁范围最小化publicclassMinLock{privateintcounter0;// 好只锁必要部分publicvoidgoodIncrement(){// 前置逻辑不需要锁preLogic();synchronized(this){counter;// 只锁核心操作}// 后置逻辑不需要锁postLogic();}// 不好整个方法加锁publicsynchronizedvoidbadIncrement(){preLogic();// 不需要锁的操作也被锁住了counter;postLogic();}}// 2. 避免锁对象变化publicclassLockObjectProblem{privateStringlocklock;// 不好字符串常量池共享publicvoiddoSomething(){synchronized(lock){// 可能有其他代码也用同样的字符串// ...}}}// 3. 使用专门的锁对象publicclassLockObjectGood{privatefinalObjectlocknewObject();// 好私有专用对象publicvoiddoSomething(){synchronized(lock){// ...}}}// 4. 读写分离publicclassReadWriteLock{privatefinalReadWriteLockrwLocknewReentrantReadWriteLock();privatevolatileintvalue;publicintread(){rwLock.readLock().lock();try{returnvalue;}finally{rwLock.readLock().unlock();}}publicvoidwrite(intnewValue){rwLock.writeLock().lock();try{valuenewValue;}finally{rwLock.writeLock().unlock();}}}三、volatile vs synchronized┌──────────────────────────────────────────────────────────────────┐ │ volatile vs synchronized 对比 │ ├──────────────────────────────────────────────────────────────────┤ │ │ │ 特性 │ volatile │ synchronized │ │ ─────────────────┼────────────────────┼───────────────────── │ │ 原子性 │ 无 │ 有 │ │ 可见性 │ 有 │ 有 │ │ 有序性 │ 有部分 │ 有完全 │ │ 性能 │ 轻量读屏障 │ 较重系统调用 │ │ 使用场景 │ 状态标志/单例 │ 复杂同步逻辑 │ │ 底层实现 │ 内存屏障 │ Monitor Enter/Exit │ │ │ └──────────────────────────────────────────────────────────────────┘四、总结volatile 通过内存屏障保证可见性和有序性适合状态标志等简单场景synchronized 通过监视器锁保证三大事物但有偏向锁→轻量级锁→重量级锁的升级机制。理解两者的底层原理才能在并发编程中做出正确的选择。系列导航上一篇【JVM深度解析】第24篇JVM内存模型JMM核心原理下一篇【JVM深度解析】第26篇CAS、AQS与并发工具类原理系列目录JVM深度解析参考资料JVM Lock Synchronization - OracleBiased Locking in HotSpotJava Volatile Keyword