Java 并发编程synchornized和volatile的实现原理

雨点打透心脏的1/2处 2023-01-17 07:48 207阅读 0赞

**目录**

1. volatile的定义与实现原理

2.synchronized的实现原理与应用

3.锁的升级与对比

3.1.偏向锁

3.2.轻量级锁

3.3重量级锁

4.锁的优缺点对比

5.volatile跟Synchronize的区别

6.参考文章

--------------------

在并发编程过程中 经常要处理一些：可见性 、 原子性 、 有序性的问题。

“ 本文主要介绍synchronized和volatile到实现原理”    synchronized和volatile几乎是java面试基础部分必会，不会你就吃亏了，这一篇文章摘抄《Java并发编程的艺术》对于初学者来说看懂这篇可能有点困难，应该先弄明白synchronized和volatile后再看原理，看不会就多看几遍，免得出了BAT的办公大楼后后悔哦。

Java代码在编译后会变成Java字节码，字节码被类加载器加载到JVM里，JVM执行字节码，最终需要转化为汇编指令在CPU上执行，Java中所使用的并发机制依赖于JVM的实现和CPU的指令。本章我们将深入底层一起探索下Java并发机制的底层实现原理。

在多线程并发编程中synchronized和volatile都扮演着重要的角色，volatile是轻量级的synchronized，它在多处理器开发中保证了共享变量的“可见性”。可见性的意思是当一个线程修改一个共享变量时，另外一个线程能读到这个修改的值。如果volatile变量修饰符使用恰当的话，它比synchronized的使用和执行成本更低，因为它不会引起线程上下文的切换和调度。本文将深入分析在硬件层面上Intel处理器是如何实现volatile的，通过深入分析帮助我们正确地使用volatile变量。

我们先从了解volatile的定义开始。

# 1. volatile的定义与实现原理 #

Java语言规范第3版中对volatile的定义如下：Java编程语言允许线程访问共享变量，为了确保共享变量能被准确和一致地更新，线程应该确保通过排他锁单独获得这个变量。Java语言提供了volatile，在某些情况下比锁要更加方便。如果一个字段被声明成volatile，Java线程内存模型确保所有线程看到这个变量的值是一致的。

在了解volatile实现原理之前，我们先来看下与其实现原理相关的CPU术语与说明

如果对声明了volatile的变量进行写操作，JVM就会向处理器发送一条Lock前缀的指令，将这个变量所在缓存行的数据写回到系统内存。但是，就算写回到内存，如果其他处理器缓存的值还是旧的，再执行计算操作就会有问题。所以，在多处理器下，为了保证各个处理器的缓存是一致的，就会实现缓存一致性协议，每个处理器通过嗅探在总线上传播的数据来检查自己缓存的值是不是过期了，当处理器发现自己缓存行对应的内存地址被修改，就会将当前处理器的缓存行设置成无效状态，当处理器对这个数据进行修改操作的时候，会重新从系统内存中把数据读到处理器缓存里。

下面来具体讲解volatile的两条实现原则。

1）Lock前缀指令会引起处理器缓存回写到内存。Lock前缀指令导致在执行指令期间，声言处理器的LOCK\#信号。在多处理器环境中，LOCK\#信号确保在声言该信号期间，处理器可以独占任何共享内存。但是，在最近的处理器里，LOCK \#信号一般不锁总线，而是锁缓存，毕竟锁总线开销的比较大。在8.1.4节有详细说明锁定操作对处理器缓存的影响，对于Intel486和Pentium处理器，在锁操作时，总是在总线上声言LOCK\#信号。但在P6和目前的处理器中，如果访问的内存区域已经缓存在处理器内部，则不会声言LOCK\#信号。相反，它会锁定这块内存区域的缓存并回写到内存，并使用缓存一致性机制来确保修改的原子性，此操作被称为“缓存锁定”，缓存一致性机制会阻止同时修改由两个以上处理器缓存的内存区域数据。

2）一个处理器的缓存回写到内存会导致其他处理器的缓存无效。IA-32处理器和Intel 64处理器使用MESI（修改、独占、共享、无效）控制协议去维护内部缓存和其他处理器缓存的一致性。在多核处理器系统中进行操作的时候，IA-32和Intel 64处理器能嗅探其他处理器访问系统内存和它们的内部缓存。处理器使用嗅探技术保证它的内部缓存、系统内存和其他处理器的缓存的数据在总线上保持一致。例如，在Pentium和P6 family处理器中，如果通过嗅探一个处理器来检测其他处理器打算写内存地址，而这个地址当前处于共享状态，那么正在嗅探的处理器将使它的缓存行无效，在下次访问相同内存地址时，强制执行缓存行填充。

# 2.synchronized的实现原理与应用 #

在多线程并发编程中synchronized一直是元老级角色，很多人都会称呼它为重量级锁。但是，随着Java SE 1.6对synchronized进行了各种优化之后，有些情况下它就并不那么重了。本文详细介绍Java SE 1.6中为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级锁，以及锁的存储结构和升级过程。

先来看下利用synchronized实现同步的基础：Java中的每一个对象都可以作为锁。具体表现为以下3种形式。

*  普通同步方法，锁是当前实例对象。
 *  静态同步方法，锁是当前类的Class对象。
 *  同步方法块，锁是Synchonized括号里配置的对象。

synchronized是用java的monitor机制来实现的，就是synchronized代码块或者方法进入及退出的时候会生成monitorenter跟monitorexit两条命令。线程执行到monitorenter时会尝试获取对象所对应的monitor所有权，即尝试获取的对象的锁；monitorexit即为释放锁。

以javap 反编译一个带有sychronized关键字的方法，输出如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Jvb255YQ_size_16_color_FFFFFF_t_70][]

关于这两条指令的作用，我们直接参考JVM规范中描述：

monitorenter ：
    
    Each object is associated with a monitor. A monitor is locked if and only if it has an owner. The thread that executes monitorenter attempts to gain ownership of the monitor associated with objectref, as follows:
    • If the entry count of the monitor associated with objectref is zero, the thread enters the monitor and sets its entry count to one. The thread is then the owner of the monitor.
    • If the thread already owns the monitor associated with objectref, it reenters the monitor, incrementing its entry count.
    • If another thread already owns the monitor associated with objectref, the thread blocks until the monitor's entry count is zero, then tries again to gain ownership.

这段话的大概意思为：

每个对象有一个监视器锁（monitor）。当monitor被占用时就会处于锁定状态，线程执行monitorenter指令时尝试获取monitor的所有权，过程如下：

1、如果monitor的进入数为0，则该线程进入monitor，然后将进入数设置为1，该线程即为monitor的所有者。

2、如果线程已经占有该monitor，只是重新进入，则进入monitor的进入数加1.

3.如果其他线程已经占用了monitor，则该线程进入阻塞状态，直到monitor的进入数为0，再重新尝试获取monitor的所有权。

monitorexit：　
    
    The thread that executes monitorexit must be the owner of the monitor associated with the instance referenced by objectref.
    The thread decrements the entry count of the monitor associated with objectref. If as a result the value of the entry count is zero, the thread exits the monitor and is no longer its owner. Other threads that are blocking to enter the monitor are allowed to attempt to do so.

这段话的大概意思为：

执行monitorexit的线程必须是objectref所对应的monitor的所有者。

指令执行时，monitor的进入数减1，如果减1后进入数为0，那线程退出monitor，不再是这个monitor的所有者。其他被这个monitor阻塞的线程可以尝试去获取这个 monitor 的所有权。

#    3.锁的升级与对比 #

Java SE 1.6为了减少获得锁和释放锁带来的性能消耗，引入了“偏向锁”和“轻量级锁”，在Java SE 1.6中，锁一共有4种状态，级别从低到高依次是：无锁状态、偏向锁状态、轻量级锁状态和重量级锁状态，这几个状态会随着竞争情况逐渐升级。锁可以升级但不能降级，意味着偏向锁升级成轻量级锁后不能降级成偏向锁。这种锁升级却不能降级的策略，目的是为了提高获得锁和释放锁的效率，下文会详细分析。

## 3.1.偏向锁 ##

HotSpot 的作者经过研究发现，大多数情况下，锁不仅不存在多线程竞争，而且总是由同一线程多次获得，为了让线程获得锁的代价更低而引入了偏向锁。当一个线程访问同步块并获取锁时，会在对象头和栈帧中的锁记录里存储锁偏向的线程ID，以后该线程在进入和退出同步块时不需要进行CAS操作来加锁和解锁，只需简单地测试一下对象头的Mark Word里是否存储着指向当前线程的偏向锁。如果测试成功，表示线程已经获得了锁。如果测试失败，则需要再测试一下Mark Word中偏向锁的标识是否设置成1（表示当前是偏向锁）：如果没有设置，则使用CAS竞争锁；如果设置了，则尝试使用CAS将对象头的偏向锁指向当前线程。

## 3.2.轻量级锁 ##

（1）轻量级锁加锁

线程在执行同步块之前，JVM会先在当前线程的栈桢中创建用于存储锁记录的空间，并将对象头中的Mark Word复制到锁记录中，官方称为Displaced Mark Word。然后线程尝试使用CAS将对象头中的Mark Word替换为指向锁记录的指针。如果成功，当前线程获得锁，如果失败，表示其他线程竞争锁，当前线程便尝试使用自旋来获取锁。

（2）轻量级锁解锁

轻量级解锁时，会使用原子的CAS操作将Displaced Mark Word替换回到对象头，如果成功，则表示没有竞争发生。如果失败，表示当前锁存在竞争，锁就会膨胀成重量级锁。

两个线程同时争夺锁，导致锁膨胀的流程图。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlaWxlaTEwNw_size_16_color_FFFFFF_t_70][]

因为自旋会消耗CPU，为了避免无用的自旋（比如获得锁的线程被阻塞住了），一旦锁升级成重量级锁，就不会再恢复到轻量级锁状态。当锁处于这个状态下，其他线程试图获取锁时，都会被阻塞住，当持有锁的线程释放锁之后会唤醒这些线程，被唤醒的线程就会进行新一轮的夺锁之争。

##  3.3**重量级锁** ##

这个就是我们平常说的synchronized锁，如果抢占不到，则线程阻塞，等待正在执行的线程结束后唤醒自己，然后重新开始竞争。之所以说是重量级，是因为线程阻塞会让出cpu资源，从内核态转换为用户态，然后执行的时候再次转换为内核态，这个过程中，cpu要切换线程，看这个线程上次执行到哪儿了，这次应该从哪儿开始，相关的变量有哪些之类的，这就是所谓的执行上下文，这个上下文的切换对宝贵的cpu资源来说是“无用功”，因为这是在为执行做准备条件，如果cpu大量的时间用在这些“无用功”上，当然也就出活儿少，也就影响执行效率了。

synchronized就是这样，默认开始是偏向锁，有竞争就逐渐升级，最终可能是重量级锁的一个过程。锁定的区域就是对象的Mark Word的内容。

# 4.锁的优缺点对比 #

![2019062118145826.png][]

# 5.volatile跟Synchronize的区别 #

1.  volatile只能作用域变量，Synchronize可作用域变量、方法、类、同步代码块等；
2.  volatile只能保证可见性和有序性，不能保证原子性，Synchronize三者都可以保证。
3.  volatile不会造成线程阻塞，Synchronize可能会造成线程阻塞。
4.  在性能方面synchronized关键字是防止多个线程同时执行一段代码，会影响程序执行效率，而volatile关键字在某些情况下性能要优于synchronized。

# 6.参考文章 #

[synchronized的底层原理？][synchronized]

[synchronized底层实现原理及锁优化][synchronized 1]

[Java并发编程：Synchronized及其实现原理][Java_Synchronized]

[Synchronized关键字使用、底层原理、底层优化、ReenTrantLock的对比][Synchronized_ReenTrantLock]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Jvb255YQ_size_16_color_FFFFFF_t_70]: /images/20221021/ae7da44dfcbb492f9939e61d493b0f03.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlaWxlaTEwNw_size_16_color_FFFFFF_t_70]: /images/20221021/2d4f38db7bf84218b519490e1696bc9b.png
[2019062118145826.png]: /images/20221021/908a666f5ced4559b2c3d4136ef49b95.png
[synchronized]: https://www.cnblogs.com/niceyoo/p/12549327.html
[synchronized 1]: https://blog.csdn.net/weixin_38481963/article/details/88384493
[Java_Synchronized]: https://www.cnblogs.com/paddix/p/5367116.html
[Synchronized_ReenTrantLock]: https://blog.csdn.net/l18848956739/article/details/88846194