Synchronized详解

已于 2022-05-04 15:19:37 修改
阅读量399 收藏
点赞数
分类专栏： 多线程系列 文章标签： java 开发语言
于 2022-05-03 10:49:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sdgames/article/details/124550633
版权
本文详细解析了在Java中synchronized关键字的底层实现，通过实例和汇编指令探讨了synchronized如何触发monitorenter和monitorexit指令，以及为何同步代码会包含两次monitorexit。
摘要由CSDN通过智能技术生成

1：如果在普通方法上加上Synchronized 当前this锁。

2：如果在静态方法上加上Synchronized 当前calss字节码

3：也可以自定义锁对象

我们站在汇编的角度去分析Synchronized关键字原理

public class Demo2 extends Thread{
    //定义一个锁对象
    private Object lockObject = new Object();

    @Override
    public void run() {
         metho1();
    }

    private void metho1() {
             synchronized (lockObject){
                 System.out.println("我是metho1调用metho2");
                 metho2();
             }
    }

    private void metho2() {
        synchronized (lockObject){
            System.out.println("我是etho2");
        }
    }

    public static void main(String[] args) {


    }
}

我们把class文件转换成汇编指令：

 Last modified 2022-5-3; size 1138 bytes
  MD5 checksum 0a5d5bbf204fef0b1f49ad1d420327cc
  Compiled from "Demo2.java"
public class com.zigao.com.utils.Demo2 extends java.lang.Thread
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #12.#36        // java/lang/Thread."<init>":()V
   #2 = Class              #37            // java/lang/Object
   #3 = Methodref          #2.#36         // java/lang/Object."<init>":()V
   #4 = Fieldref           #11.#38        // com/zigao/com/utils/Demo2.lockObject:Ljava/lang/Object;
   #5 = Methodref          #11.#39        // com/zigao/com/utils/Demo2.metho1:()V
   #6 = Fieldref           #40.#41        // java/lang/System.out:Ljava/io/PrintStream;
   #7 = String             #42            // 我是metho1调用metho2
   #8 = Methodref          #43.#44        // java/io/PrintStream.println:(Ljava/lang/String;)V
   #9 = Methodref          #11.#45        // com/zigao/com/utils/Demo2.metho2:()V
  #10 = String             #46            // 我是etho2
  #11 = Class              #47            // com/zigao/com/utils/Demo2
  #12 = Class              #48            // java/lang/Thread
  #13 = Utf8               lockObject
  #14 = Utf8               Ljava/lang/Object;
  #15 = Utf8               <init>
  #16 = Utf8               ()V
  #17 = Utf8               Code
  #18 = Utf8               LineNumberTable
  #19 = Utf8               LocalVariableTable
  #20 = Utf8               this
  #21 = Utf8               Lcom/zigao/com/utils/Demo2;
  #22 = Utf8               run
  #23 = Utf8               metho1
  #24 = Utf8               StackMapTable
  #25 = Class              #47            // com/zigao/com/utils/Demo2
  #26 = Class              #37            // java/lang/Object
  #27 = Class              #49            // java/lang/Throwable
  #28 = Utf8               metho2
  #29 = Utf8               main
  #30 = Utf8               ([Ljava/lang/String;)V
  #31 = Utf8               args
  #32 = Utf8               [Ljava/lang/String;
  #33 = Utf8               MethodParameters
  #34 = Utf8               SourceFile
  #35 = Utf8               Demo2.java
  #36 = NameAndType        #15:#16        // "<init>":()V
  #37 = Utf8               java/lang/Object
  #38 = NameAndType        #13:#14        // lockObject:Ljava/lang/Object;
  #39 = NameAndType        #23:#16        // metho1:()V
  #40 = Class              #50            // java/lang/System
  #41 = NameAndType        #51:#52        // out:Ljava/io/PrintStream;
  #42 = Utf8               我是metho1调用metho2
  #43 = Class              #53            // java/io/PrintStream
  #44 = NameAndType        #54:#55        // println:(Ljava/lang/String;)V
  #45 = NameAndType        #28:#16        // metho2:()V
  #46 = Utf8               我是etho2
  #47 = Utf8               com/zigao/com/utils/Demo2
  #48 = Utf8               java/lang/Thread
  #49 = Utf8               java/lang/Throwable
  #50 = Utf8               java/lang/System
  #51 = Utf8               out
  #52 = Utf8               Ljava/io/PrintStream;
  #53 = Utf8               java/io/PrintStream
  #54 = Utf8               println
  #55 = Utf8               (Ljava/lang/String;)V
{
  private java.lang.Object lockObject;
    descriptor: Ljava/lang/Object;
    flags: ACC_PRIVATE

  public com.zigao.com.utils.Demo2();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=3, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Thread."<init>":()V
         4: aload_0
         5: new           #2                  // class java/lang/Object
         8: dup
         9: invokespecial #3                  // Method java/lang/Object."<init>":()V
        12: putfield      #4                  // Field lockObject:Ljava/lang/Object;
        15: return
      LineNumberTable:
        line 3: 0
        line 5: 4
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      16     0  this   Lcom/zigao/com/utils/Demo2;

  public void run();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #5                  // Method metho1:()V
         4: return
      LineNumberTable:
        line 9: 0
        line 10: 4
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcom/zigao/com/utils/Demo2;

  private void metho1();
    descriptor: ()V
    flags: ACC_PRIVATE
    Code:
      stack=2, locals=3, args_size=1
         0: aload_0
         1: getfield      #4                  // Field lockObject:Ljava/lang/Object;
         4: dup
         5: astore_1
         6: monitorenter
         7: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
        10: ldc           #7                  // String 我是metho1调用metho2
        12: invokevirtual #8                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        15: aload_0
        16: invokespecial #9                  // Method metho2:()V
        19: aload_1
        20: monitorexit
        21: goto          29
        24: astore_2
        25: aload_1
        26: monitorexit
        27: aload_2
        28: athrow
        29: return
      Exception table:
         from    to  target type
             7    21    24   any
            24    27    24   any
      LineNumberTable:
        line 13: 0
        line 14: 7
        line 15: 15
        line 16: 19
        line 17: 29
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      30     0  this   Lcom/zigao/com/utils/Demo2;
      StackMapTable: number_of_entries = 2
        frame_type = 255 /* full_frame */
          offset_delta = 24
          locals = [ class com/zigao/com/utils/Demo2, class java/lang/Object ]
          stack = [ class java/lang/Throwable ]
        frame_type = 250 /* chop */
          offset_delta = 4

  private void metho2();
    descriptor: ()V
    flags: ACC_PRIVATE
    Code:
      stack=2, locals=3, args_size=1
         0: aload_0
         1: getfield      #4                  // Field lockObject:Ljava/lang/Object;
         4: dup
         5: astore_1
         6: monitorenter
         7: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
        10: ldc           #10                 // String 我是etho2
        12: invokevirtual #8                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        15: aload_1
        16: monitorexit
        17: goto          25
        20: astore_2
        21: aload_1
        22: monitorexit
        23: aload_2
        24: athrow
        25: return
      Exception table:
         from    to  target type
             7    17    20   any
            20    23    20   any
      LineNumberTable:
        line 20: 0
        line 21: 7
        line 22: 15
        line 23: 25
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      26     0  this   Lcom/zigao/com/utils/Demo2;
      StackMapTable: number_of_entries = 2
        frame_type = 255 /* full_frame */
          offset_delta = 20
          locals = [ class com/zigao/com/utils/Demo2, class java/lang/Object ]
          stack = [ class java/lang/Throwable ]
        frame_type = 250 /* chop */
          offset_delta = 4

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=0, locals=1, args_size=1
         0: return
      LineNumberTable:
        line 28: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       1     0  args   [Ljava/lang/String;
    MethodParameters:
      Name                           Flags
      args
}
SourceFile: "Demo2.java"

通过汇编指令我们可以查看到synchronized底层是个monitorenter和monitorexit指令

我们发现一个synchronized有两个退出退出指令monitorexit

 

 当加上synchronized之后代码中会有两次monitorexit。

为什么会有两次了，因为在使用Sychronized同步代码的时候，一个正常的代码结束monitorexit 还有一个异常的monitorexit退出，其中两个里面只能走一个。

synchronized原理实际上是触发monitorenter和monitorexit指令

因努力 果随缘
关注
专栏目录
synchronized详解
rockvine的博客
07-18 3726
一、基本使用1.1、对象锁1.2、类锁二、原理解析2.1、对象头规范2.1.1、对象头内容2.1.2、对象头布局2.1.3、 大小端模式2.2、锁状态2.2.1、无锁2.2.2、偏向锁2.2.2.1、偏向锁加锁2.2.2.2、偏向锁升级2.2.2.3、批量重偏向2.2.2.4、批量撤销2.2.3、轻量锁2.2.3.1、轻量锁的加锁2.2.3.2、轻量锁的释放2.2.4、自旋锁2.2.4.1、适应性自旋2.2.5、重量锁2.3、锁升级一、基本使用synchronized是Java并发编程中的同步机制关键字，它
Java-synchronized实现详解（从Java到汇编）
最新发布
小海编码日记
04-28 895
synchronized作为java语言中的并发关键词，其在代码中出现的频率相当高频，大多数开发者在涉及到并发场景时，一般都会下意识得选取synchronized。
Java并发编程----synchronized
四叶草的博客
01-10 205
Synchronized： 解决多线程访问时，资源的同步性，可以保证⽅法、代码块在任意时刻只有⼀个线程执⾏。 三种使⽤⽅式： 修饰实例⽅法: 给对象实例加锁，进⼊同步代码前，要获得对象实例的锁 修饰静态⽅法: 给类加锁，作⽤于类的所有对象实例， 修饰代码块: 对指定代码块加锁，进⼊同步代码库前要获得 给定对象的锁。 synchronized底层实现原理 修饰同步语句块的实现使⽤的是 monitorenter 和 monitorexit 指令，其中 monitorenter 指令指向同步代码块的开始位置，
Synchronized的用法
哎呀妈呀脑壳疼脑壳疼
10-06 326
一、可重入性 synchronized是具有可重入性的，在秋招阶段有两个公司问到这个问题，一个公司是直接问synchronized是否是可重入的，我当时的回答是“根据底层monitorenter和monitorexit原理，应该是可重入的”。另一家公司（可能是小米，难怪几个星期都没有收到二面通知）是给我出了一个题目：A（）用synchronized修饰，B()用synchronized修饰，那么A...
Java中Synchronized的用法
热门推荐
阳光日志
06-24 50万+
synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种： 1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象； 2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 3.修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象； 4..
Java 中 synchronized的用法详解(四种用法)
SimpleGZW的博客
08-23 3444
Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。本文给大家介绍java中 synchronized的用法，对本文感兴趣的朋友一起看看吧 Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。 1.方法声明时使用,放在范围操作符(public等)之后,返回类型声明(void等)之前.这时,线程获得的是成员锁,即一次只能有一个线程进入该方法,其他线程要想在此时调用该方法,只能排队等候,当
Java中的关键字synchronized 详解
08-26
Java中的关键字synchronized 详解 Java中的关键字synchronized是Java语言中用于线程同步的关键字。它可以修饰方法或代码块，以便在多线程环境中保护共享资源的安全。 1、修饰普通方法 synchronized关键字可以修饰...
并发synchronized详解.pdf
01-18
并发synchronized详解 在 Java 中，synchronized 是一种非常重要的关键字，用于解决多线程编程中的线程安全问题。线程安全问题是指多个线程同时访问同一个共享、可变资源时可能出现的错误或不一致情况。为了解决这...
Java-synchronized详解.docx
11-20
Java synchronized 详解 Java 中的同步机制是多线程编程中最重要的概念之一。它允许开发者控制多个线程对共享资源的访问，以避免数据不一致和race condition。这篇文章将详细介绍 Java 中的 synchronized 机制，...
『Java』synchronized 详解
七秒钟的记忆
07-24 360
详解 synchronized 关键字
synchronized关键字的实质及用法
03-31
NULL 博文链接：https://seandsky-boyy-163-com.iteye.com/blog/1340783
Java并发编程之synchronized知识整理
拥抱大数据的专栏
01-16 285
Java并发编程之synchronized知识
由浅到深分析Synchronized,彻底理解Synchronized底层实现原理
weixin_34143774的博客
06-12 401
这篇文章会记录Synchronized的常用使用场景与Synchronized的底层实现原理。虽然我们平时经常会在多线程中使用Synchronized关键字，但可能对于这个我们很熟悉的关键字的底层到底是怎样实现的没有过多关注。作为开发者，既然使用到了，可以试着去一步一步揭开下它的底层面纱。 为什么要使用Synchronized？ 首先我们来看下这段代码 public class Demo { ...
@synchronized 递归锁详解
gcs的博客
08-10 1万+
如果你已经使用 Objective-C 编写过任何并发程序，那么想必是见过@synchronized这货了。@synchronized结构所做的事情跟锁（NSLock, 更准确的说法应该是NSRecursiveLock）类似：它可以防止不同的线程同时执行同一段代码。但在某些情况下，相比于使用NSLock创建锁对象、加锁和解锁来说，@synchronized用着更方便，可读性更高。 下面是SDWebImage中的代码, 给一个线程不安全的NSMapTable加递归锁, 保证NSMapTable的...
多线程环境中，让Java开发者又爱又恨的synchronized-到底该不该用？
m0_64867802的博客
12-07 161
*/ public synchronized void methodLock() { System.out.println(Thread.currentThread().getName()); } /** 在代码块上加关键字，锁住当前实例 */ public void codeBlockLock() { synchronized (this) { System.out.println(Thread.currentThread().getName()); } } /** 在代码块上加关键字,锁住一个变量
Synchronized用法彻底详解
lovemylife1234的博客
10-24 412
synchronized关键字，synchronized具有“线程的互斥处理”和“同步处理”两种功能。 如果程序中有synchronized关键字，线程就会进行lock/unlock操作。线程会在synchronized开始时获取锁，在synchronized终止时释放锁（注意：当线程在wait方法内部等待的时候会释放锁。此外，当线程从wait方法中出来的时候还必须先重新获取锁后才能继续运行）。...
Java线程生命周期、Synchronized同步、互斥锁、死锁、释放锁基本入门
安逸
03-04 863
Java线程生命周期、Synchronized同步、互斥锁、死锁、释放锁基本入门
并发编程2 -线程安全问题及Synchronized
weixin_39505091的博客
07-12 167
文章目录一. 线程安全问题1. 共享带来的问题2. synchronized 解决方案3. 变量的线程安全分析4. 转账线程实例二. Monitor概念1. 概念2. synchronized 优化 一. 线程安全问题 1. 共享带来的问题 上下文切换使得指令（一行代码对应多条指令）交错，导致多线程访问共享资源出现线程安全问题： 例： public class ThreadTest { static int counter = 0; public static void main(Strin
深入理解Synchronized关键字
Jaychan的博客
07-02 211
SynChronized 官方定义 防止线程看绕和内存一致性的错误，如果一个对象对多个线程课件，则该对象的变量的所有读取或写入方法都是通过同步方法来完成的。 作用 能保证在同一时刻最多只有一个线程执行该段代码，以达到并发安全的效果。 地位  ◆ Java的关键字，被Java原生支持  ◆ 最基本的互斥同步手段  ◆ 并发编程中元老级别角色 不使用的后果 通过一个小Demo体现 public class Threadtest implements Runnable{ static Thre
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值