面试官，别挂电话，Synchronized，我还能说上半小时。

偏执的太偏执、 2023-05-22 04:41 20阅读 0赞

## 面试官，别挂电话，Synchronized，我还能说上半小时。 ##

> Synchronized关键字，经常被用于线程同步。执行Synchronized修饰的同步代码块的线程，首先会获得“对象的锁”，如果有其他线程尝试执行同步代码块，会阻塞，直到该线程执行完同步代码，释放“对象锁”。上面的概念，肯定不陌生，但是**对象锁**具体是什么，或许你不太清楚，本文从其底层原理出发，详细解读Synchronized关键字

### Synchronized关键字概念 ###

synchronized是Java中关键字，是利用锁机制来实现同步，锁机制有如下两种特性

*  **互斥性（也叫原子性)**：同一时刻只允许一个线程获取对象锁
 *  **可见性**：线程获取对象锁后，会清空线程工作内存中的同步代码块使用到的共享变量
    
    对象释放锁前，会将线程工作内存中对共享变量的修改刷新回主内存

### 对象锁与类锁 ###

在Java中，每个对象都会有一个`monitor`对象，monitor对象其实就是经常说的，**对象锁**或者称为

**监视器锁**。而类锁(类似使用Synchronized(Object.class)), 其实是通过对象锁实现，如果熟悉类加载机制，肯定知道，类加载的同时，会在堆中，new一个Class对象。此Class对象的monitor对象就是类锁，由此可知，每个类只有一个类锁

### 对象头 ###

Java对象在内存中存储的布局可以分为三块区域: 对象头、实例数据、对齐填充。  
对象头,分为两个部分,第一个部分存储对象自身的运行时数据，又称为Mark Word,32位虚拟机占32bit，64位虚拟机占64bit。如图所示，不同锁状态下，Mark Word的结构.第二部分存储类指针

![format_png][]

### 对象锁原理(Monitor) ###

Java虚拟机中,monitor是由ObjectMonitor实现的,主要数据结构如下

1 ObjectMonitor() { 
     2     _header       = NULL;//markOop对象头
     3     _count        = 0;
     4     _waiters      = 0,//等待线程数
     5     _recursions   = 0; //重入次数
     6     _object       = NULL;
     7     _owner        = NULL;//指向获得ObjectMonitor对象的线程
     8     _WaitSet      = NULL;//处于wait状态的线程，会被加入到wait set；
     9     _WaitSetLock  = 0 ;
    10     _Responsible  = NULL ;
    11     _succ         = NULL ;
    12     _cxq          = NULL ;
    13     FreeNext      = NULL ;
    14     _EntryList    = NULL ;//处于等待锁block状态的线程，会被加入到entry set；
    15     _SpinFreq     = 0 ;
    16     _SpinClock    = 0 ;
    17     OwnerIsThread = 0 ;// _owner is (Thread *) vs SP/BasicLock
    18     _previous_owner_tid = 0;// 监视器前一个拥有者线程的ID
    19   }

ObjectMonitor主要有几个需要关注的成员变量

*  \_owner:指向获得ObjectMonitor对象的线程
 *  \_EntryList: 处于等待锁block状态的线程，会被加入到entry set
 *  \_WiatSet: 处于wait状态的线程，会被加入到wait set(调用同步对象wait方法)

多个线程同时访问一段同步代码时,首先会进入`_EntryList`集合,进行阻塞等待, 当线程获取到对象的`monitor`后进入owner区域,并把`monitor`中的`_owner`变量指向该线程,同时`monitor`中的计数器`count`自加一,若线程调用同步对象的`wait()`方法将释放当前持有的`monitor`,`_owner`变量重置为`null`,`count`自减一,同时该线程进入`_WaitSet`中等待唤醒,线程执行完同步代码块后,也将`_Owner`和`count`变量重置.  
**可重入原理**：线程第一次获取对象锁后，会将\_owner变量指向自己，并将count设置为1.下一次线程尝试去获取对象锁后，发现\_owner是指向自己的，就直接将count自加1，进入同步代码块。线程每一次退出同步代码块时，会将count自减1，直到count为0时，才释放对象锁，即将\_owner设置为null  
![format_png 1][]

### 代码块锁解锁过程 ###

public class SyncCodeBlock{ 
        public int i;
        public void syncTask(){ 
            synchronized(this) { 
                i++;
            }
        }
    }

反编译后,得到上述代码的字节码

public void syncTask();
        Code:
           0: aload_0
           1: dup
           2: astore_1
           3: monitorenter
           4: aload_0
           5: dup
           6: getfield      #2                  // Field i:I
           9: iconst_1
          10: iadd
          11: putfield      #2                  // Field i:I
          14: aload_1
          15: monitorexit
          16: goto          24
          19: astore_2
          20: aload_1
          21: monitorexit
          22: aload_2
          23: athrow
          24: return

从字节码中可以看出,Synchronized底层是使用`monitorenter`,`monitorexit`指令实现线程同步.

*  执行`monitorenter`指令时,线程将尝试获取同步对象的锁(即monitor对象),若monitor的count变量(记录线程进入次数)为0, 则将count设置为1,\_owner设置为当前线程,\`\`.取锁成功.如果线程已拥有该对象锁,则可以重入该锁.重入时count计算器的值也会加一
 *  指向`monitorexit`指令时,执行器将count计数器减一,当计数器为0时,其他线程将有机会持有
    
    monitor.值得注意的是,编译器会确保无论方法通过何种方式完成,方法中调用过的每条`monitorenter`指令都会执行相应的`monitorexit`指令.无论此方法是正常结束还是异常结束.
    
    如果方法异常完成,编译器会自动产生一个异常处理器,异常处理器的目的就是用来执行`monitorexit`指令.**从字节码中也可以看出多了一个`monitorexit`指令**.它就是异常结束时被执行的释放monitor指令.

### 方法体加锁解锁过程 ###

public class Main{ 
        public int i;
        public synchronized void syncTask(){ 
            i++;
        }
    }

反编译上述代码后,得到如下字节码

public synchronized void syncTask();
        descriptor: ()V
        flags: ACC_PUBLIC, ACC_SYNCHRONIZED
        Code:
          stack=3, locals=1, args_size=1
             0: aload_0
             1: dup
             2: getfield      #2                  // Field i:I
             5: iconst_1
             6: iadd
             7: putfield      #2                  // Field i:I
            10: return

方法体的同步时隐式,即无需字节码指令来控制.JVM可以从方法常量池中的方法表结构(method\_info structure)中的`ACC_SYNCHRONIZED`访问标志来区分一个方法是否同步方法.

当调用方法时,检测方法的`ACC_SYNCHRONIZED`是否被设置,如果设置了,线程需先持有该对象的monitor,然后执行方法,最后方法完成时释放monitor.

如果一个同步方法执行期间抛出了异常,并且方法内部无法处理此异常,那这个同步方法所持有的monitor将在异常抛到同步方法之外时自动释放.

[format_png]: /images/20230521/926214792c7e4724acbf0ea1598e8b8f.png
[format_png 1]: /images/20230521/5e0cfbeaf80e47c4a99fc4e50b907af5.png