synchronized实现原理

synchronized作为java语言中的并发关键词，其在代码中出现的频率相当高频，大多数开发者在涉及到并发场景时，一般都会下意识得选取synchronized。

synchronized在代码中主要有三类用法，根据其用法不同，所获取的锁对象也不同，如下所示：

• 
  
• 修饰代码块：这种用法通常叫做同步代码块，获取的锁对象是在synchronized中显式指定的
  
• 修饰实例方法：这种用法通常叫做同步方法，获取的锁对象是当前的类对象
  
• 修饰静态方法：这种用法通常叫做静态同步方法，获取的锁对象是当前类的类对象
  

下面我们一起来测试下三种方式下，对象锁的归属及锁升级过程，SynchronizedTestClass类代码如下：

 import org.openjdk.jol.info.ClassLayout;

 

 public class SynchronizedTestClass {

     private Object mLock = new Object();

     public void testSynchronizedBlock(){

         System.out.println("before get Lock in thread:"+Thread.currentThread().getName()+">>>"+ ClassLayout.parseInstance(mLock).toPrintable());

         synchronized (mLock) {

             System.out.println("testSynchronizedBlock start:"+Thread.currentThread().getName());

             System.out.println("after get Lock in thread:"+Thread.currentThread().getName()+">>>"+ ClassLayout.parseInstance(mLock).toPrintable());

             try {

                 Thread.sleep(10000);

             } catch (InterruptedException e) {

                 throw new RuntimeException(e);

             }

             System.out.println("testSynchronizedBlock end:"+Thread.currentThread().getName());

         }

     }

 

     public synchronized void testSynchronizedMethod() {

         System.out.println("after get Lock in thread:"+Thread.currentThread().getName()+">>>"+ ClassLayout.parseInstance(this).toPrintable());

         System.out.println("testSynchronizedMethod start:"+Thread.currentThread().getName());

         try {

             Thread.sleep(10000);

         } catch (InterruptedException e) {

             throw new RuntimeException(e);

         }

         System.out.println("testSynchronizedMethod end:"+Thread.currentThread().getName());

     }

 

     public static synchronized void testSynchronizedStaticMethod() {

         System.out.println("after get Lock in thread:"+Thread.currentThread().getName()+">>>"+ ClassLayout.parseInstance(SynchronizedTestClass.class).toPrintable());

         System.out.println("testSynchronizedStaticMethod start:"+Thread.currentThread().getName());

         try {

             Thread.sleep(10000);

         } catch (InterruptedException e) {

             throw new RuntimeException(e);

         }

         System.out.println("testSynchronizedStaticMethod end:"+Thread.currentThread().getName());

     }

 }

同步代码块

在main函数编写如下代码，调用SynchronizedTestClass类中包含同步代码块的测试方法，如下所示：

 public static void main(String[] args) {

     SynchronizedTestClass synchronizedTestClass = new SynchronizedTestClass();

     ExecutorService testSynchronizedBlock = Executors.newCachedThreadPool();

     testSynchronizedBlock.execute(new Runnable() {

         @Override

         public void run() {

             synchronizedTestClass.testSynchronizedBlock();

         }

     });

     testSynchronizedBlock.execute(new Runnable() {

         @Override

         public void run() {

             synchronizedTestClass.testSynchronizedBlock();

         }

     });

 }

运行结果如下：

从上图可以看出在线程2获取锁前，mLock处于无锁状态，等线程2获取锁后，mLock对象升级为轻量级锁，等线程1获取锁后升级为重量级锁，有同学要问了，你在多线程与锁中不是说了synchronized锁升级有四个吗？你是不是写BUG了，当然没有啊，现在我们来看看偏向锁去哪儿了？

偏向锁

对于不同版本的JDK而言，其针对偏向锁的开关和配置均有所不同，我们可以通过执行java -XX:+PrintFlagsFinal -version | grep BiasedLocking来获取偏向锁相关配置，执行命令输出如下：

从上图可以看出在JDK 1.8上，偏向锁默认开启，具有4秒延时，那么我们修改main内容，延时5秒开始执行，看看现象如何，代码如下：

 public static void main(String[] args) {

     try {

         Thread.sleep(5000);

     } catch (InterruptedException e) {

         throw new RuntimeException(e);

     }

     SynchronizedTestClass synchronizedTestClass = new SynchronizedTestClass();

 

     ExecutorService testSynchronizedBlock = Executors.newCachedThreadPool();

     testSynchronizedBlock.execute(new Runnable() {

         @Override

         public void run() {

             synchronizedTestClass.testSynchronizedBlock();

         }

     });

 

     testSynchronizedBlock.execute(new Runnable() {

         @Override

         public void run() {

             synchronizedTestClass.testSynchronizedBlock();

         }

     });

 }

输出如下：

从上图可以看出在延迟5s执行后，mLock锁变成了无锁可偏向状态，结合上面两个示例，我们可以看出，在轻量级锁和偏向锁阶段均有可能直接升级成重量级锁，是否升级依赖于当时的锁竞争关系，据此我们可以得到synchronized锁升级的常见过程，如下图所示：

可以看出，我们遇到的两种情况分别对应升级路线1和升级路线4。

同步方法

使用线程池调用SynchronizedTestClass类中的同步方法，代码如下：

 public static void main(String[] args) {

     SynchronizedTestClass synchronizedTestClass = new SynchronizedTestClass();

 

     ExecutorService testSynchronizedBlock = Executors.newCachedThreadPool();

     testSynchronizedBlock.execute(new Runnable() {

         @Override

         public void run() {

             synchronizedTestClass.testSynchronizedMethod();

         }

     });

 

     testSynchronizedBlock.execute(new Runnable() {

         @Override

         public void run() {

             synchronizedTestClass.testSynchronizedMethod();

         }

     });

 }

运行结果如下：

可以看出，在调用同步方法时，直接升级为重量级锁，同一时刻，有且仅有一个线程在同步方法中执行，其他函数在同步方法入口处阻塞等待。

静态同步方法

使用线程池调用SynchronizedTestClass类中的静态同步方法，代码如下

     public static void main(String[] args) {

         ExecutorService testSynchronizedBlock = Executors.newCachedThreadPool();

         testSynchronizedBlock.execute(new Runnable() {

             @Override

             public void run() {

                 SynchronizedTestClass.testSynchronizedStaticMethod();

             }

         });

         testSynchronizedBlock.execute(new Runnable() {

             @Override

             public void run() {

                 SynchronizedTestClass.testSynchronizedStaticMethod();

             }

         });

     }

运行结果如下：

可以看出，在调用静态同步方法时，直接升级为重量级锁，同一时刻，有且仅有一个线程在静态同步方法中执行，其他函数在同步方法入口处阻塞等待。

前面我们看的是多个线程竞争同一个锁对象，那么假设我们有三个线程分别执行这三个函数，又会怎样呢？代码如下：

 public static void main(String[] args) {

     SynchronizedTestClass synchronizedTestClass = new SynchronizedTestClass();

 

     ExecutorService testSynchronizedBlock = Executors.newCachedThreadPool();

     testSynchronizedBlock.execute(new Runnable() {

         @Override

         public void run() {

             SynchronizedTestClass.testSynchronizedStaticMethod();

         }

     });

     testSynchronizedBlock.execute(new Runnable() {

         @Override

         public void run() {

             synchronizedTestClass.testSynchronizedMethod();

         }

     });

     testSynchronizedBlock.execute(new Runnable() {

         @Override

         public void run() {

             synchronizedTestClass.testSynchronizedBlock();

         }

     });

 }

运行结果：

可以看到，3个线程各自运行，互不影响，这也进一步印证了前文所说的锁对象以及MarkWord中标记锁状态的概念。

synchronized实现原理

上面已经学习了synchronized的常见用法，关联的锁对象以及锁升级的过程，接下来我们来看下synchronized实现原理，仍然以上面的SynchronizedTestClass为例，查看其生成的字节码来了解synchronized关键字的实现。

同步代码块

testSynchronizedBlock其所对应的字节码如下图所示：

从上图代码和字节码对应关系可以看出，在同步代码块中获取锁时使用monitorenter指令，释放锁时使用monitorexit指令，且会有两个monitorexit，确保在当前线程异常时，锁正常释放，避免其他线程等待死锁。

所以synchronized的同步机制是依赖monitorenter和monitorexit指令实现的，而这两个指令操作的就是mLock对象的monitor锁，monitorenter尝试获取mLock的monitor锁，如果获取成功，则monitor中的计数器+1，同时记录相关线程信息，如果获取失败，则当前线程阻塞。

Monitor锁就是存储在MarkWord中的指向重量级锁的指针所指向的对象，每个对象在构造时都会创建一个Monitor锁，用于监视当前对象的锁状态以及持锁线程信息，

同步方法

testSynchronizedMethod其所对应的字节码如下图所示：

可以看到同步方法依赖在函数声明时添加ACC_SYNCHRONIZED标记实现，在函数被ACC_SYNCHRONIZED修饰时，调用该函数会申请对象的Monitor锁，申请成功则进入函数，申请失败则阻塞当前线程。

静态同步方法

testSynchronizedStaticMethod其所对应的字节码如下图所示：

和同步方法相同，同步静态方法也是在函数声明部分添加了ACC_SYNCHRONIZED标记，也同步方法不同的是，此时申请的是该类的类对象的Monitor锁。

扩展

上文中针对synchronized的java使用以及字节码做了说明，我们可以看出synchronized是依赖显式的monitorenter，monitorexit指令和ACC_SYNCHRONIZED实现，但是字节码并不是最靠近机器的一层，相对字节码，汇编又是怎么处理synchronized相关的字节码指令的呢？

我们可以通过获取java代码的汇编代码来查看，查看Java类的汇编代码需要依赖hsdis工具，该工具可以从chriswhocodes.com/hsdis/下载(科学上网)，下载完成后，在Intellij Idea中配置Main类的编译参数如下图所示：

其中vm options详细参数如下：

-XX:+UnlockDiagnosticVMOptions -XX:+PrintAssembly -Xcomp -XX:CompileCommand=compileonly,*SynchronizedTestClass.testSynchronizedBlock -XX:CompileCommand=compileonly,*SynchronizedTestClass.testSynchronizedMethod -XX:+LogCompilation -XX:LogFile=/Volumes/Storage/hotspot.log

其中“compileOnly，”后面跟的是你要抓取的函数名称，格式为：*类名.函数名，LogFile=后指向的是存储汇编代码的文件。

环境变量配置如下：

LIBRARY_PATH=/Volumes/Storage/hsdis

这里的写法是：hsdis存储路径+/hsdis

随后再次运行Main.main即可看到相关汇编代码输出在运行窗口，通过分析运行窗口输出的内容，我们可以看到如下截图：

可以看出在运行时调用SynchronizedTestClass::testSynchronizedMethod时，进入synchronized需要执行lock cmpxchg以确保多线程安全，故synchronized的汇编实现为lock cmpxchg指令。