Hotspot synchronized与volatile关键字实现（一） 源码解析

最新推荐文章于 2022-05-11 02:14:28 发布
最新推荐文章于 2022-05-11 02:14:28 发布
阅读量2k 收藏 4
点赞数 3
分类专栏： Hotspot和Linux内核 文章标签： synchronized monitorenter monitorexit
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31865983/article/details/104875342
版权

 目录

一、synchronized用法

1、修饰实例方法

2、修饰静态方法

3、修饰代码块

二、synchronized底层实现

1、修改代码块的字节码分析

2、monitorenter 指令实现

3、InterpreterRuntime::monitorenter

4、monitorexit 指令实现

5、InterpreterRuntime::monitorexit

6、monitorenter/ monitorexit 指令的编译执行 

本篇博客来从字节码实现层面详细探讨synchronized与volatile关键字的实现细节。

一、synchronized用法

1、修饰实例方法

     修饰实例方法时，执行该方法时必须获取某个实例关联的锁，即并发调用同一实例的多个被修饰的实例方法时只能执行其中的某一个，测试用例如下：

public class AddTest {
    private int a;

    synchronized int add(){
        a++;
        return a;
    }

    synchronized int add2(){
        a+=2;
        return a;
    }
}
    private final long NUM=100000000;    
   @Test
    public void test() throws Exception {
        AddTest a=new AddTest();
        Thread t=new Thread(new Runnable() {
            @Override
            public void run() {
                long startTime= System.currentTimeMillis();
                for(int i=0;i<NUM;i++) {
                    a.add();
                }
                long time=System.currentTimeMillis()-startTime;
                System.out.println("t run end,time->"+time);
            }
        });
        t.start();
        Thread t2=new Thread(new Runnable() {
            @Override
            public void run() {
                long startTime= System.currentTimeMillis();
                for(int i=0;i<NUM;i++) {
                    a.add2();
                }
                long time=System.currentTimeMillis()-startTime;
                System.out.println("t2 run end,time->"+time);
            }
        });
        t2.start();
        t.join();
        t2.join();
        System.out.println("job end");
    }

    @Test
    public void test2() throws Exception {
        Thread t=new Thread(new Runnable() {
            @Override
            public void run() {
                AddTest a=new AddTest();
                long startTime= System.currentTimeMillis();
                for(int i=0;i<NUM;i++) {
                    a.add();
                }
                long time=System.currentTimeMillis()-startTime;
                System.out.println("t run end,time->"+time);
            }
        });
        t.start();
        Thread t2=new Thread(new Runnable() {
            @Override
            public void run() {
                AddTest a=new AddTest();
                long startTime= System.currentTimeMillis();
                for(int i=0;i<NUM;i++) {
                    a.add2();
                }
                long time=System.currentTimeMillis()-startTime;
                System.out.println("t2 run end,time->"+time);
            }
        });
        t2.start();
        t.join();
        t2.join();
        System.out.println("job end");
    }

 第一个测试用例就是并发调用同一个实例的两个被修饰的实例方法，其执行结果如下：

第二个测试用例是并发调用不同实例的两个被修饰的实例方法，其执行结果如下： 

第一个测试用例因为两个方法在同一时间只能执行其中一个，而第二个测试用例是两个方法在并行执行互不影响，因此第一个的耗时是第二个的两倍多，超过两倍的耗时是获取锁释放锁等同步操作的损耗。 

2、修饰静态方法

    修饰静态方法时，执行该方法时必须获取该类的class如String.class实例关联的锁，即同一时间多个不同实例并发调用不同的静态方法时只能执行其中的一个方法，测试用例如下：

public class AddTest {
    private int a;

    private static int b;

    synchronized int add(){
        a++;
        return a;
    }

    synchronized int add2(){
        a+=2;
        return a;
    }

    synchronized static int add3(){
        b++;
        return b;
    }

    synchronized static int add4(){
        b+=2;
        return b;
    }
}

 @Test
    public void test2() throws Exception {
        Thread t=new Thread(new Runnable() {
            @Override
            public void run() {
                AddTest a=new AddTest();
                long startTime= System.currentTimeMillis();
                for(int i=0;i<NUM;i++) {
                    a.add();
                }
                long time=System.currentTimeMillis()-startTime;
                System.out.println("t run end,time->"+time);
            }
        });
        t.start();
        Thread t2=new Thread(new Runnable() {
            @Override
            public void run() {
                AddTest a=new AddTest();
                long startTime= System.currentTimeMillis();
                for(int i=0;i<NUM;i++) {
                    a.add2();
                }
                long time=System.currentTimeMillis()-startTime;
                System.out.println("t2 run end,time->"+time);
            }
        });
        t2.start();
        t.join();
        t2.join();
        System.out.println("job end");
    }

    @Test
    public void test3() throws Exception {
        Thread t=new Thread(new Runnable() {
            @Override
            public void run() {
                AddTest a=new AddTest();
                long startTime= System.currentTimeMillis();
                for(int i=0;i<NUM;i++) {
                    a.add3();
                }
                long time=System.currentTimeMillis()-startTime;
                System.out.println("t run end,time->"+time);
            }
        });
        t.start();
        Thread t2=new Thread(new Runnable() {
            @Override
            public void run() {
                AddTest a=new AddTest();
                long startTime= System.currentTimeMillis();
                for(int i=0;i<NUM;i++) {
                    a.add4();
                }
                long time=System.currentTimeMillis()-startTime;
                System.out.println("t2 run end,time->"+time);
            }
        });
        t2.start();
        t.join();
        t2.join();
        System.out.println("job end");
    }

test2的耗时不变，如下图：

test3的耗时跟test1差不过了，如下图：

这是因为他们都是同一时间只能执行其中的某一个方法，不同的是test1是获取某个实例关联的锁，test3是获取类的class实例关联的锁。

3、修饰代码块

     修饰代码块时需要指定在哪个实例上同步，如果该实例是某个类的class实例或者静态属性时，则同样的，该类的多个不同实例并发调用该代码块时同一时间只能其中一个能执行；如果该实例是某个实例属性或者this时，则同样的，并发调用同一实例的该代码块时只能执行其中一个；如果该实例是局部变量，因为局部变量是执行该方法时私有的，其他线程不会访问到该变量，也就不会去获取该实例关联的锁了，所以实际相当于没有加锁，JVM优化时会将该锁自动消除。

测试用例如下：

public class AddTest {
    private int a;

    private static int b;

    int add(){
        synchronized (this) {
            a++;
        }
        return a;
    }

    int add2(){
        synchronized (this) {
            a+=2;
        }
        return a;
    }

    static int add3(){
        synchronized (AddTest.class) {
            b++;
        }
        return b;
    }

    static int add4(){
        synchronized (AddTest.class) {
            b+=2;
        }
        return b;
    }
}

public class AddTest {
    private int a;

    private s
最低0.47元/天 解锁文章
孙大圣666
关注
专栏目录
Hotspot synchronized与volatile关键字实现（二） 源码解析
菜鸟进阶之路
03-20 1270
目录 一、synchronized底层实现 1、修饰代码块字节码分析 2、InterpreterGenerator::lock_method 3、执行本地方法synchronized解锁 4、解释执行普通Java方法synchronized解锁 二、jni_MonitorEnter /jni_MonitorExit 1、jni_MonitorEnter 2、jni_Moni...
HotSpot volatile原理
Sherlock的博客
10-20 595
关于HotSpot中volatile的实现之前，需要先探讨一下Java的内存模型。为了提高程序的执行性能，编译器和处理器常常会对一段指令做重排序。在单线程环境下指令重排序可以显著提高程序的执行性能，但在多线程下便会出现一致性问题。Java通过统一的内存模型，锁，内存屏障等手段来处理这种一致性问题。 一.Java内存模型 在Java中，堆内存在线程之间共享，局部变量不在线程间共享。JMM决定一个线程堆共享变量的写入何时对另一个线程可见，JMM定义了线程私有本地内存与主内存的抽象关系，提供统一的编程模型。线程间
深析Synchronized关键字（小白慎入，深入jvm源码，两万字长文）
12-21
目录一、synchronized基础1.1synchronized的使用1.1示例1.2验证1.2.1 普通方法和代码块中使用this是同一个监视器（锁），即某个具体调用该代码的对象1.2.2 静态方法和代码块中使用该类的class对象是同一个监视器，任何该类的对象调用该段代码时都是在争夺同一个监视器的锁定1.2、synchronized的特点二、synchronized进阶2.1对象头2.2synchronized实现原理2.3锁升级2.3.1《java并发编程的艺术》的描述(引用)1.偏向锁（1）偏向锁的撤销（2）关闭偏向锁2.轻量级锁（1）轻量级锁加锁（2）轻量级锁解锁2.3.2一些补充
Java并发-volatile
Dave的博客
07-01 227
volatile自身特性 可见性：对一个volatile变量的读，总是能看到（任意线程）对这个volatile变量最后的写入。 原子性：对任意单个volatile变量的读/写具有原子性，单类似于volatile++这种复合操作不具有原子性 等同于 volatile写和锁的释放有相同的内存语义；volatile读和锁的获取有相同的内存语义 volatile写内存语义 当写一个...
【JUC并发编程】synchronized原理分析（中）（JVM对象头/ HotSpot源码分析/ 字节码文件分析）
记录各种Bug解决案例及日常学习内容
05-05 676
目录一、JVM对象头1. Klass Pointer2. 实例属性3. 对齐填充4. 查看Java对象布局5. 基本数据类型占多少字节5. 论证压缩效果6. New 一个对象占用多少字节二、HotSpot源码分析1. 对象头详解2. 获取HashCode3. 对象状态3.1 偏向锁3.2 轻量锁3.3 重量锁三、字节码文件分析1.1 Monitor1.2 Monitorenter（获取锁）1.3 monitorexit1.4 ACC_SYNCHRONIZED 一、JVM对象头 在JVM中，对象在内存中的布
Java中多线程的同步方法——synchronized关键词（附源代码）
shiyuan0的专栏
12-11 721
synchronized关键词是Java中由于实现多线程同步的一个方法，这个关键字用于修饰方法。它的原理是：被sychronized关键词修饰的方法，在调用对象的时候，会独占该对象，在方法执行结束之前，不允许其它方法使用该对象。下面是一个关于synchronized关键词的测试程序：         其输出结果如下图所示，注意线程 Thread-0 运行结束后，线程Thread-1 才能够使
深入HotSpot虚拟机源码探究synchronized底层实现原理【万字总结synchronized】
Kevinnsm的博客
05-11 655
一、synchronized原理 synchronized是Java中的关键字，无法通过JDK源码查看它的实现，它是由JVM提供支持的，所以如果想要了解具体的实现需要查看JVM源码 （1）首先准备好HotSpot源码 jdk8 hotspot源码下载地址：http://hg.openjdk.java.net/jdk8u/jdk8u/hotspot/ 选择zip或者gz格式下载即可 （2）解压，使用vscode或者其他编辑器打开 src是hotspot的源码目录 cpu：和cpu相关的一些操作 os
Synchronized关键字的底层实现原理解析
Synchronized关键字是Java中用来实现同步的关键字，它可以应用于方法和代码块，用来确保多个线程在并发执行时，能够正确地同步访问共享资源，避免出现数据不一致的情况。 ```java public synchronized void ...
JDK10（JDK10底层C++源码及hotspot虚拟机源码）
最新发布
12-14
5. **线程与同步（Threads and Synchronization）**：HotSpot实现了Java的线程模型和同步原语，如`synchronized`关键字和`volatile`变量。 通过研究JDK10的源码，开发者可以了解到Java运行时的内部工作原理，包括...
从Hotsport源码和操作系统级别深入理解volatile关键字与内存屏障（Lock前缀）
沮丧的南瓜
11-01 921
文章目录一、volatile的内存语义1.2 volatile的特性1.2 volatile写-读的内存语义1.3 volatile可见性实现原理1.3.1 JMM内存交互层面实现1.3.2 汇编层面volatile的实现 (java代码中的使用和验证)1.3.3 硬件层面实现二、volatile在hotspot的实现2.1 字节码解释器实现2.2 模板解释器实现三、volatile在linux系统x86中的实现lock前缀指令的作用四、从硬件层面分析Lock前缀指令五、总结与疑问 一、volatile的内
深入Hotspot源码与X86操作系统分析Valitaile变量与Lock前缀
沮丧的南瓜
10-27 489
一、JMM内存交互层面实现 volatile修饰的变量的read、load、use操作和assign、store、write必须是连续的，即修改后必须立即同步回主内存，使用时必须从主内存刷新，由此保证volatile变量操作对多线程的可见性。 二、Volatile在hotspot的实现 在JVM层面，使用storeLoader内存屏障保证可见性。 我们知道Java中有两种解释器：字节码解释器和模板解释器。接下来我们从这两种解释器层面来看看： 字节码解释器实现 JVM中的字节码解释器(bytecodeInte
彻底理解volatile关键字
热门推荐
fumitzuki的博客
09-27 2万+
彻底理解volatile关键字 volatile关键字是由JVM提供的最轻量级同步机制。与被滥用的synchronized不同，我们并不习惯使用它。想要正确且完全的理解它并不容易。 Java内存模型 使用volatile关键字的特性 被volatile修饰的变量 Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和图片上传 LaTex数学公式 UML序列图和...
HotSpot JVM虚拟机：JAVA内存模型与volatile变量
varyall的专栏
09-17 220
JAVA虚拟机规范中试图通过“JAVA内存模型”来屏蔽掉各种硬件和各种操作系统队内存访问的差异，让JAVA程序在各种系统平台下都能有一致的并发效果，“一次书写，处处运行”。         JAVA内存模型的主要目标：定义程序中各个变量的访问规则，就是在JVM中如何将变量存储到内存和如何从内存中取出变量。这里的变量专指可以被多个线程共享的、存在竞争可能的的实例字段、静态变量和构成数组对象的元素，不...
JAVA锁分析之synchronized
zxz1580977728的博客
11-10 276
123
HotSpot synchronized原理
Sherlock的博客
09-30 584
Java通过对synchronize关键字来支持多线程同步。在字节码层面synchronize表现为monitorenter, monitorexit， 同时外加一个flags标志区分synchronize的同步作用域。synchronized用的锁是存在Java对象头里的，虚拟机的对象头主要包括两部分数据：Mark Word(标记字段)和Klass Pointer(类元数据指针)，其中Klass Point是是对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例，Mark Wor
Java Synchronized实现互斥之应用与源码初探
09-12 581
前言 上篇文章从无到有分析了如何实现"锁"，虽然仅仅实现了最简单的锁，但"锁"的精华已经提取出来了，有了这些知识，本篇将分析系统提供的锁-synchronized关键字的使用与实现。 通过本篇文章，你将了解到： 1、synchronized 如何使用 2、synchronized 源码初探 3、总结 1、synchronized 如何使用 多线程访问临界区 由上篇文章可知，多线程访问临界区需要锁： 临界区可以是一段代码，也可以是某个方法。 synchronized 各种使用方式 按锁作用区域划分，可分
java check word lock_Java中synchronized与ReentrantLock性能对比
weixin_33897085的博客
03-04 168
前两天逛博客的时候看到有个人写了一篇博客说ReentrantLock比synchronized慢，这就很违反我的认知了，详细看了他的博客和测试代码，发现了他测试的不严谨，并在评论中友好地指出了他的问题，结果他直接把博客给删了 删了 了……很多老一辈的程序猿对有synchronized有个 性能差 的刻板印象，然后极力推崇使用java.util.concurrent包中的lock类，如果你追问他们s...
解析java第3章答案,一线开发大牛带你深度解析探讨模板解释器，解释器的生成...
weixin_32349699的博客
03-11 240
解释器生成解释器的机器代码片段都是在TemplateInterpreterGenerator::generate_all()中生成的，下面将分小节详细展示该函数的具体细节，以及解释器某个组件的机器代码生成过程与逻辑。与第4章不同的是，本节中的各部分出现的顺序与它们在代码中的顺序不一致。在研究解释器前了解调试手段是有必要的。由于运行时生成的机器代码是人类不可读的二进制形式，要想阅读它们，可以下载hs...
Java的wait和notify学习三部曲之一：JVM源码分析，保洁阿姨看完都会了
m0_64867152的博客
12-29 274
线程C启动后，由于此时线程B持有锁，那么线程C此时在干啥？ 线程B在notify()的时候做了什么？ 线程B释放锁的时候做了什么？ 源码中最重要的注释信息 在源码中有段注释堪称是整篇文章最重要的说明，请大家始终记住这段信息，处处都用得上： ObjectWaiter对象存在于WaitSet、EntryList、cxq等集合中，或者正在这些集合中移动 原文如下： 请务必记住这三个集合：WaitSet、EntryList、cxq 好了，接下来看源码分析问题吧： 线程A在wait()的时候做了什么..
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值