synchronized学习

最新推荐文章于 2022-10-13 16:49:32 发布

란 단 용

最新推荐文章于 2022-10-13 16:49:32 发布

阅读量102

点赞数

分类专栏：多线程文章标签：多线程 synchronized 锁

本文链接：https://blog.csdn.net/myloveinnocence/article/details/111665598

版权

多线程专栏收录该内容

12 篇文章 0 订阅

订阅专栏

文章目录

前言
一、使用
二、monitor介绍
总结

前言

提示：分析synchronized的实现原理。
概括：Java 虚拟机中的同步(Synchronization)基于进入和退出管程(Monitor)对象实现，无论是显式同步(有明确的 monitorenter 和 monitorexit 指令,即同步代码块)还是隐式同步都是如此。

一、使用

代码块
实例方法
静态方法

使用比较简单，略，自行百度。

二、monitor介绍

1.对象头

参考

2.monitor

每个对象都存在着一个 monitor ，对象与 monitor 之间的关系存在多种实现方式，如monitor可以与对象一起创建销毁或当线程试图获取对象锁时自动生成，但当一个 monitor 被某个线程持有后，它便处于锁定状态。在Java虚拟机(HotSpot)中，monitor是由ObjectMonitor实现的，其主要数据结构如下（位于HotSpot虚拟机源码ObjectMonitor.hpp文件，C++实现的）

代码如下（示例）：
hotspot

ObjectMonitor() {
    _header       = NULL;
    _count        = 0; //记录个数
    _waiters      = 0,
    _recursions   = 0;
    _object       = NULL;
    _owner        = NULL;
    _WaitSet      = NULL; //处于wait状态的线程，会被加入到_WaitSet
    _WaitSetLock  = 0 ;
    _Responsible  = NULL ;
    _succ         = NULL ;
    _cxq          = NULL ;
    FreeNext      = NULL ;
    _EntryList    = NULL ; //处于等待锁的线程，会被加入到该列表
    _SpinFreq     = 0 ;
    _SpinClock    = 0 ;
    OwnerIsThread = 0 ;
  }

ObjectMonitor中有两个队列，_WaitSet 和 _EntryList，用来保存ObjectWaiter对象列表( 每个等待锁的线程都会被封装成ObjectWaiter对象)，_owner指向持有ObjectMonitor对象的线程，当多个线程同时访问一段同步代码时，首先会进入 _EntryList 集合，当线程获取到对象的monitor 后进入 _owner 区域并把monitor中的owner变量设置为当前线程同时monitor中的计数器count加1，而如果monitor的owner已经是当前线程，则再次尝试获取monitor时，count +1 ，这就是锁的重入。若线程调用 wait() 方法，将释放当前持有的monitor，owner变量恢复为null，count自减1，同时该线程进入 WaitSet集合中等待被唤醒。若当前线程执行完毕也将释放monitor(锁)并复位变量的值，以便其他线程进入获取monitor(锁)。

2.原理剖析

1.同步代码块

1. 代码准备：

public class SynchronizedDemo {

    public void method() {
        synchronized (this) {
            System.out.println("Method 1 start");
        }
    }

}

2. 翻译成字节码指令：

// 编译
javac SynchronizedDemo.java 
// 生成指令
javap -c SynchronizedDemo.class > SynchronizedDemo指令.txt

2.1 JVM字节码指令手册

JVM字节码指令手册

3. 指令解析

Compiled from "SynchronizedDemo.java"
public class com.example.demo.primary.sync.SynchronizedDemo {
  public com.example.demo.primary.sync.SynchronizedDemo();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public void method();
    Code:
       0: aload_0
       1: dup
       2: astore_1
       // 指令指向同步代码的开始位置
       // 从这里开始，本线程开始尝试获取对象的monitor所有权
       3: monitorenter
       4: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       7: ldc           #3                  // String Method 1 start
       9: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      12: aload_1
      // monitorexit指令则指明同步代码块的结束位置
      13: monitorexit
      14: goto          22
      17: astore_2
      18: aload_1
      // 这是为了保证即便方法异常退出也能正确的释放锁
      19: monitorexit
      20: aload_2
      21: athrow
      22: return
    Exception table:
       from    to  target type
           4    14    17   any
          17    20    17   any
}

4. 小结：

从字节码中可知同步语句块的实现使用的是monitorenter 和 monitorexit 指令，其中monitorenter指令指向同步代码块的开始位置，monitorexit指令则指明同步代码块的结束位置，当执行monitorenter指令时，当前线程将试图获取 objectref(即对象锁) 所对应的 monitor 的持有权，当 objectref 的 monitor 的进入计数器为 0，那线程可以成功取得 monitor，并将计数器值设置为 1，取锁成功。如果当前线程已经拥有 objectref 的 monitor 的持有权，那它可以重入这个 monitor (关于重入性稍后会分析)，重入时计数器的值也会加 1。倘若其他线程已经拥有 objectref 的 monitor 的所有权，那当前线程将被阻塞，直到正在执行线程执行完毕，即monitorexit指令被执行，执行线程将释放 monitor(锁)并设置计数器值为0 ，其他线程将有机会持有 monitor 。值得注意的是编译器将会确保无论方法通过何种方式完成，方法中调用过的每条 monitorenter 指令都有执行其对应 monitorexit 指令，而无论这个方法是正常结束还是异常结束。为了保证在方法异常完成时 monitorenter 和 monitorexit 指令依然可以正确配对执行，编译器会自动产生一个异常处理器，这个异常处理器声明可处理所有的异常，它的目的就是用来执行 monitorexit 指令。从字节码中也可以看出多了一个monitorexit指令，它就是异常结束时被执行的释放monitor 的指令。

2.同步代码方法

代码准备：

public class 同步方法 {

    /**
     * 公共资源
     */
    public int i;

    /**
     * 同步方法
     */
    public synchronized void syncTask(){
        i++;
    }
}

翻译成字节码指令：

// 编译
javac 同步方法.java 
// 生成指令
javap -verbose -c  同步方法.class > 同步方法字节码指令.txt

-c : 生成字节码指令
-verbose: 生成参数数量和堆栈信息，包含常量池信息

指令解析

Classfile /Users/innocence/study/thread-study/src/main/java/com/example/demo/primary/sync/同步方法.class
  Last modified 2020-12-25; size 318 bytes
  MD5 checksum 110091ad5c2052fcadb1dfeedf2c6104
  Compiled from "同步方法.java"
public class com.example.demo.primary.sync.同步方法
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #4.#14         // java/lang/Object."<init>":()V
   #2 = Fieldref           #3.#15         // com/example/demo/primary/sync/同步方法.i:I
   #3 = Class              #16            // com/example/demo/primary/sync/同步方法
   #4 = Class              #17            // java/lang/Object
   #5 = Utf8               i
   #6 = Utf8               I
   #7 = Utf8               <init>
   #8 = Utf8               ()V
   #9 = Utf8               Code
  #10 = Utf8               LineNumberTable
  #11 = Utf8               syncTask
  #12 = Utf8               SourceFile
  #13 = Utf8               同步方法.java
  #14 = NameAndType        #7:#8          // "<init>":()V
  #15 = NameAndType        #5:#6          // i:I
  #16 = Utf8               com/example/demo/primary/sync/同步方法
  #17 = Utf8               java/lang/Object
{
  public int i;
    descriptor: I
    flags: ACC_PUBLIC

  public com.example.demo.primary.sync.同步方法();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 8: 0

  public synchronized void syncTask();
    descriptor: ()V
    // 通过访问标识来表明方法是同步方法，jvm来处理
    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
      LineNumberTable:
        line 19: 0
        line 20: 10
}
SourceFile: "同步方法.java"

小结：

方法级的同步是隐式，即无需通过字节码指令来控制的，它实现在方法调用和返回操作之中。JVM可以从方法常量池中的方法表结构(method_info Structure) 中的 ACC_SYNCHRONIZED 访问标志区分一个方法是否同步方法。当方法调用时，调用指令将会检查方法的 ACC_SYNCHRONIZED 访问标志是否被设置，如果设置了，执行线程将先持有monitor（虚拟机规范中用的是管程一词），然后再执行方法，最后再方法完成(无论是正常完成还是非正常完成)时释放monitor。在方法执行期间，执行线程持有了monitor，其他任何线程都无法再获得同一个monitor。如果一个同步方法执行期间抛出了异常，并且在方法内部无法处理此异常，那这个同步方法所持有的monitor将在异常抛到同步方法之外时自动释放。

3. JVM对synchronized优化

为什么要优化？
我们还必须注意到的是在Java早期版本中，synchronized属于重量级锁，效率低下，因为监视器锁（monitor）是依赖于底层的操作系统的Mutex Lock来实现的，而操作系统实现线程之间的切换时需要从用户态转换到核心态，这个状态之间的转换需要相对比较长的时间，时间成本相对较高，这也是为什么早期的synchronized效率低的原因。庆幸的是在Java 6之后Java官方对从JVM层面对synchronized较大优化，所以现在的synchronized锁效率也优化得很不错了，Java 6之后，为了减少获得锁和释放锁所带来的性能消耗，引入了轻量级锁和偏向锁
锁升级过程：

总结

提示：锁的思路都一样，变成串行，可以对比Inodb存储引擎对于事务的锁

란 단 용

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
synchronized学习

文章目录前言一、使用二、monitor介绍1.对象头2.monitor2.原理剖析1.同步代码块1. 数据准备总结前言提示：分析synchronized的实现原理。概括：Java 虚拟机中的同步(Synchronization)基于进入和退出管程(Monitor)对象实现，无论是显式同步(有明确的 monitorenter 和 monitorexit 指令,即同步代码块)还是隐式同步都是如此。一、使用代码块实例方法静态方法使用比较简单，略，自行百度。二、monitor介绍1.对
复制链接

扫一扫