synchronized用法、底层原理、锁升级过程及实现原理

红太狼 2023-01-20 13:49 13阅读 0赞

本文摘自：[https://blog.csdn.net/weixin\_45605368/article/details/108535458][https_blog.csdn.net_weixin_45605368_article_details_108535458]和[https://blog.csdn.net/zzti\_erlie/article/details/103997713][https_blog.csdn.net_zzti_erlie_article_details_103997713]

## synchronized用法 ##

1.  **修饰实例方法，对当前实例对象this加锁**
2.  **修饰静态方法，对当前类的Class对象加锁**
3.  **修饰代码块，指定加锁对象，对给定对象加锁**

public class SynchronizedDemo {
         //同步实例方法，对当前实例对象加锁
        public synchronized void doSth(){
            System.out.println("Hello World");
        }
         //修饰静态方法，对当前类的class对象加锁
         public static synchronized void doSth1() {
            System.out.println("Hello World");
        }
    
        //同步代码块，给指定的对象(并非是当前类)加锁
        public void doSth2(){
            synchronized (SynchronizedDemo.class){
                System.out.println("Hello World");
            }
        }
        //同步代码块，给指定的对象(this指当前类)加锁
        public void doSth3(){
            synchronized (this){
                System.out.println("Hello World");
            }
        }
    }

## synchronized底层原理 ##

在了解synchronized底层原理之前，需要先了解**java对象结构**和**montor(监听器)**

我们要先了解下Java对象结构-->[https://blog.csdn.net/qq\_35044419/article/details/116748097][https_blog.csdn.net_qq_35044419_article_details_116748097]

java的对象结构，对象是放在**堆内存**中的，对象大致可以分为三个部分，分别是**对象头，实例变量和填充字节**

![在这里插入图片描述][20210212204438565.png]

假如有如下的类，a=100这个信息就存储在实例变量中

public class Test {
        int a = 100;
    }

**填充数据**主要是为了方便内存管理，如你想要10字节的内存，但是会给你分配16字节的内存，多出来的字节就是填充数据

synchronized不论是修饰方法还是代码块，都是通过持有修饰对象的锁来实现同步，那么synchronized锁对象是存在哪里的呢？答案是存在锁对象的**对象头Mark Word**，来看一下Mark Word存储了哪些内容？

由于对象头的信息是与对象自身定义的数据没有关系的额外存储成本，因此考虑到JVM的空间效率，Mark Word 被设计成为一个非固定的数据结构，以便存储更多有效的数据，它会根据对象本身的状态复用自己的存储空间，也就是说，Mark Word会随着程序的运行发生变化，变化状态如下 (32位虚拟机)：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p6dGlfZXJsaWU_size_16_color_FFFFFF_t_70]

64位虚拟机：

java对象头其余信息基本不变，只是中间有关于对象hashcode值和之后加锁信息的位数加大以外，其他基本不变。  
64位虚拟机系统下java对象头在不同锁状态下的状态变化如下表所示：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmd5eTEzMA_size_16_color_FFFFFF_t_70][]

其中轻量级锁和偏向锁是Java 6 对 synchronized 锁进行优化后新增加的，这个在锁升级的过程中再聊。

上面谈到java对象结构，除了对java对象结构简单了解之外，主要分析一下**重量级锁**也就是通常说synchronized的对象锁，锁标识位为10，其中指针指向的是**monitor对象（也称为管程或监视器锁）**的起始地址。每个对象都存在着一个 monitor 与之关联(此时先不要纠结monitor是个什么东西，继续先往下看)。在Java虚拟机(HotSpot)中，monitor是由**ObjectMonitor**实现的，其主要数据结构如下（位于HotSpot虚拟机源码ObjectMonitor.hpp文件，C++实现的），省略部分属性

ObjectMonitor() {
        _count        = 0; //记录数
        _recursions   = 0; //锁的重入次数
        _owner        = NULL; //指向持有ObjectMonitor对象的线程 
        _WaitSet      = NULL; //调用wait后，线程会被加入到_WaitSet
        _EntryList    = NULL ; //等待获取锁的线程，会被加入到该列表
    }

![在这里插入图片描述][20200206232455228.png]

结合线程状态解释一下执行过程。

1.  新建（New），新建后尚未启动的线程
2.  运行（Runable），Runnable包括了操作系统线程状态中的Running和Ready
3.  无限期等待（Waiting），不会被分配CPU执行时间，要等待被其他线程显式的唤醒。例如调用没有设置Timeout参数的Object.wait()方法
4.  限期等待（Timed Waiting），不会被分配CPU执行时间，不过无需等待其他线程显示的唤醒，在一定时间之后会由系统自动唤醒。例如调用Thread.sleep()方法
5.  阻塞（Blocked），线程被阻塞了，“阻塞状态”与“等待状态”的区别是：“阻塞状态”在等待获取着一个排他锁，这个事件将在另外一个线程放弃这个锁的时候发生，而“等待状态”则是在等待一段时间，或者唤醒动作的发生。在程序等待进入同步区域的时候，线程将进入这种状态
6.  结束（Terminated）：线程结束执行

对于一个synchronized修饰的方法(代码块)来说

>        monitor对象可以暂时理解为锁标记，只有得到锁标记的线程才可以有就绪状态进入运行状态(个人看了下面的讲解理解的)

*  当多个线程同时访问该方法，那么这些线程会先被**放进\_EntryList**队列，此时线程处于blocked状态
 *  当一个线程获取到了对象的monitor后，那么就可以进入running状态，执行方法，此时，ObjectMonitor对象的**\_owner**指向当前线程，**\_count加1**表示当前对象锁被一个线程获取
 *  当running状态的线程调用wait()方法，那么当前线程释放monitor对象，进入waiting状态，ObjectMonitor对象的**\_owner**变为null，**\_count**减1，同时线程进入**\_WaitSet**队列，直到有线程调用notify()方法唤醒该线程，则该线程进入**\_EntryList**队列，竞争到锁再进入**\_Owner**区
 *  如果当前线程执行完毕，那么也释放monitor对象，ObjectMonitor对象的/\_owner变为null，\_count减1
 *  由此看来，monitor对象存在于每个Java对象的对象头中(存储的是指针)，synchronized锁便是通过这种方式获取锁的，也是为什么Java中任意对象可以作为锁的原因，同时**也是notify/notifyAll/wait等方法存在于顶级对象Object中的原因**

在上面列举的synchronized的用法中，其中dosth()、dosth2经过[Javap][]反编译后，得到如下代码：

public synchronized void doSth();
        descriptor: ()V
        flags: ACC_PUBLIC, ACC_SYNCHRONIZED
        Code:
          stack=2, locals=1, args_size=1
             0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
             3: ldc           #3                  // String Hello World
             5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
             8: return
    
      public void doSth2();
        descriptor: ()V
        flags: ACC_PUBLIC
        Code:
          stack=2, locals=3, args_size=1
             0: ldc           #5                  // class com/hollis/SynchronizedTest
             2: dup
             3: astore_1
             4: monitorenter
             5: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
             8: ldc           #3                  // String Hello World
            10: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
            13: aload_1
            14: monitorexit
            15: goto          23
            18: astore_2
            19: aload_1
            20: monitorexit
            21: aload_2
            22: athrow
            23: return

通过反编译后代码可以看出：对于**同步方法，JVM采用`ACC_SYNCHRONIZED`标记符来实现同步**。 对于**同步代码块。JVM采用`monitorenter`、`monitorexit`两个指令来实现同步**。

在 [The Java® Virtual Machine Specification][The Java_ Virtual Machine Specification]中有关于同步方法和同步代码块的实现原理的介绍，我翻译成中文如下：

> 方法级的同步是隐式的。同步方法的常量池中会有一个**`ACC_SYNCHRONIZED`**标志。当某个线程要访问某个方法的时候，会检查是否有**`ACC_SYNCHRONIZED`**，如果有设置，则需要先获得监视器锁，然后开始执行方法，方法执行之后再释放监视器锁。这时如果其他线程来请求执行方法，会因为无法获得监视器锁而被阻断住。值得注意的是，如果在方法执行过程中，发生了异常，并且方法内部并没有处理该异常，那么在异常被抛到方法外面之前监视器锁会被自动释放。  
> 同步代码块使用**`monitorenter`**和**`monitorexit`**两个指令实现。可以把执行`monitorenter`指令理解为加锁，执行`monitorexit`理解为释放锁。 每个对象维护着一个记录着被锁次数的计数器。未被锁定的对象的该计数器为0，当一个线程获得锁（执行`monitorenter`）后，该计数器自增变为 1 ，当同一个线程再次获得该对象的锁的时候，计数器再次自增。当同一个线程释放锁（执行`monitorexit`指令）的时候，计数器再自减。当计数器为0的时候。锁将被释放，其他线程便可以获得锁。

无论是`ACC_SYNCHRONIZED`还是`monitorenter`、`monitorexit`都是基于**Monitor**实现的，在Java虚拟机(HotSpot)中，Monitor是基于C++实现的，由ObjectMonitor实现。

ObjectMonitor类中提供了几个方法，如**`enter`、`exit`、`wait`、`notify`、`notifyAll`**等。`sychronized`加锁的时候，会调用objectMonitor的`enter`方法，解锁的时候会调用`exit`方法。（关于Monitor详解:[https://blog.csdn.net/qq\_35044419/article/details/116756409][https_blog.csdn.net_qq_35044419_article_details_116756409]）

## synchronized锁升级过程及原理 ##

synchronized锁升级过程及实现原理：[https://blog.csdn.net/qq\_35044419/article/details/116789021][https_blog.csdn.net_qq_35044419_article_details_116789021]

## synchronized与原子性 ##

原子性是指一个操作是不可中断的，要全部执行完成，要不就都不执行。

线程是CPU调度的基本单位。CPU有时间片的概念，会根据不同的调度算法进行线程调度。当一个线程获得时间片之后开始执行，在时间片耗尽之后，就会失去CPU使用权。所以在多线程场景下，由于时间片在线程间轮换，就会发生原子性问题。

在Java中，为了保证原子性，提供了两个高级的字节码指令**`monitorenter`**和**`monitorexit`**。前面中，介绍过，这两个字节码指令，在Java中对应的关键字就是**`synchronized`**。

通过**`monitorenter`**和**`monitorexit`**指令，可以保证被`synchronized`修饰的代码在同一时间只能被一个线程访问，在锁未释放之前，无法被其他线程访问到。因此，在Java中可以使用`synchronized`来保证方法和代码块内的操作是原子性的。

> 线程1在执行**`monitorenter`**指令的时候，会对Monitor进行加锁，加锁后其他线程无法获得锁，除非线程1主动解锁。即使在执行过程中，由于某种原因，比如CPU时间片用完，线程1放弃了CPU，但是，他并没有进行解锁。而由于`synchronized`的锁是可重入的，下一个时间片还是只能被他自己获取到，还是会继续执行代码。直到所有代码执行完。这就保证了原子性。

## synchronized与可见性 ##

可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。

> Java内存模型规定了所有的变量都存储在主内存中，每条线程还有自己的工作内存，线程的工作内存中保存了该线程中是用到的变量的主内存副本拷贝，线程对变量的所有操作都必须在工作内存中进行，而不能直接读写主内存。不同的线程之间也无法直接访问对方工作内存中的变量，线程间变量的传递均需要自己的工作内存和主存之间进行数据同步进行。所以，就可能出现线程1改了某个变量的值，但是线程2不可见的情况。

> 前面我们介绍过，被`synchronized`修饰的代码，在开始执行时会加锁，执行完成后会进行解锁。而为了保证可见性，有一条规则是这样的：对一个变量解锁之前，必须先把此变量同步回主存中。这样解锁后，后续线程就可以访问到被修改后的值。

所以，synchronized关键字锁住的对象，其值是具有可见性的。

## synchronized与有序性 ##

有序性即程序执行的顺序按照代码的先后顺序执行。

我们在[再有人问你Java内存模型是什么，就把这篇文章发给他。][Java]中分析过：除了引入了时间片以外，由于处理器优化和指令重排等，CPU还可能对输入代码进行乱序执行，比如load->add->save 有可能被优化成load->save->add 。这就是可能存在有序性问题。

这里需要注意的是，`synchronized`是无法禁止指令重排和处理器优化的。也就是说，`synchronized`无法避免上述提到的问题。

那么，为什么还说synchronized也提供了有序性保证呢？

这就要再把有序性的概念扩展一下了。Java程序中天然的有序性可以总结为一句话：如果在本线程内观察，所有操作都是天然有序的。如果在一个线程中观察另一个线程，所有操作都是无序的。

以上这句话也是《深入理解Java虚拟机》中的原句，但是怎么理解呢？周志明并没有详细的解释。这里我简单扩展一下，这其实和`as-if-serial`语义有关。

`as-if-serial`语义的意思指：不管怎么重排序（编译器和处理器为了提高并行度），单线程程序的执行结果都不能被改变。编译器和处理器无论如何优化，都必须遵守`as-if-serial`语义。

这里不对`as-if-serial`语义详细展开了，简单说就是，`as-if-serial`语义保证了单线程中，指令重排是有一定的限制的，而只要编译器和处理器都遵守了这个语义，那么就可以认为单线程程序是按照顺序执行的。当然，实际上还是有重排的，只不过我们无须关心这种重排的干扰。

所以呢，由于`synchronized`修饰的代码，同一时间只能被同一线程访问。那么也就是单线程执行的。所以，可以保证其有序性。

##  ##

## ##

[https_blog.csdn.net_weixin_45605368_article_details_108535458]: https://blog.csdn.net/weixin_45605368/article/details/108535458
[https_blog.csdn.net_zzti_erlie_article_details_103997713]: https://blog.csdn.net/zzti_erlie/article/details/103997713
[https_blog.csdn.net_qq_35044419_article_details_116748097]: https://blog.csdn.net/qq_35044419/article/details/116748097
[20210212204438565.png]: /images/20221021/97eb075134344e3e874d4e57dbb863fb.png?
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p6dGlfZXJsaWU_size_16_color_FFFFFF_t_70]: /images/20221021/d35370ec56d64ca09b306090f8b6de6b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmd5eTEzMA_size_16_color_FFFFFF_t_70]: /images/20221021/2069847201784453ba5feae4151623d1.png
[20200206232455228.png]: /images/20221021/01c0ad460ce54f648ddd48e81059c453.png?
[Javap]: http://www.hollischuang.com/archives/1107
[The Java_ Virtual Machine Specification]: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-2.html#jvms-2.11.10
[https_blog.csdn.net_qq_35044419_article_details_116756409]: https://blog.csdn.net/qq_35044419/article/details/116756409
[https_blog.csdn.net_qq_35044419_article_details_116789021]: https://blog.csdn.net/qq_35044419/article/details/116789021
[Java]: http://47.103.216.138/archives/2550