JVM学习笔记之八（JMM）

最新推荐文章于 2024-08-10 10:38:35 发布
最新推荐文章于 2024-08-10 10:38:35 发布
阅读量151 收藏
点赞数
分类专栏： java JVM JMM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44737877/article/details/105757794
版权
java 同时被 3 个专栏收录
34 篇文章 2 订阅
订阅专栏
JVM
13 篇文章 0 订阅
订阅专栏
JMM
1 篇文章 0 订阅
订阅专栏

内存模型（JMM）

VM 和 JMM 的区别

  • java虚拟机模型( JVM )
    jvm的内部结构如下图所示，这张图很清楚形象的描绘了整个JVM的内部结构，以及各个部分之间的交互和作用。
    在这里插入图片描述
  • Java内存模型(Java Memory Model，JMM)JMM主要是为了规定了线程和内存之间的一些关系。根据JMM的设计，系统存在一个主内存(Main Memory)，Java中所有变量都储存在主存中，对于所有线程都是共享的。每条线程都有自己的工作内存(Working Memory)，工作内存中保存的是主存中某些变量的拷贝，线程对所有变量的操作都是在工作内存中进行，线程之间无法相互直接访问，变量传递均需要通过主存完成。
    在这里插入图片描述

1.1 原子性

  • 原子性在学习线程时讲过，下面看一个例子
  • 问题提出，两个线程对初始值为 0 的静态的变量一个自增、一个自减，各做 50000 次 结果是 0 吗？（不一定，实验需要做多次，有可能是 0 ）
public class JMM {
     private static int i = 0;
 
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            for (int j = 0; j < 50000; j++) {
                i++;
            }
        });

        Thread t2 = new Thread(()->{
            for (int j = 0; j <50000; j++) {
                i--;
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(i);
    }
}

1.2 问题分析

  • 以上结果可能为正、负、0，什么呢？因为 Java 中对静态变量的自增、自减并不是原子操作。
  • 例如对于 i++ 而言（i 为静态变量），实际会产生如下的 JVM 字节码指令：
 0: getstatic     #2                // Field i:I
 3: iconst_1						// 准备常量1
 4: iadd							// 加法
 5: putstatic     #2                // Field i:I
  • i-- 而言
 0: getstatic     #2                  // Field i:I
 3: iconst_1
 4: isub
 5: putstatic     #2
  • JVM 内存模型如下，完成静态变量的自增、自减需要在主存和线程内存中进行数据交换：
    在这里插入图片描述

如果单线程以下 8 行代码是顺序执行的不会储问题

 0: getstatic     #2                // Field i:I
 3: iconst_1						// 准备常量1
 4: iadd							// 加法
 5: putstatic     #2                // Field i:I
 =================================
 0: getstatic     #2                  // Field i:I
 3: iconst_1
 4: isub
 5: putstatic     #2

但是，多线程就会出现交错运行，就会出现正负数的问题了

1.3 解决问题

  • synchronized （同步关键字）
synchronized (对象){
	代码块
}

2. 可见性

2.1 退不出的循环

  • 先看一个现象，main 线程对 run 变量的修改对于 t 线程不可见，导致了 t 线程无法停止
public class Main2 {

    private static boolean run = true;
    public static void main(String[] args) throws InterruptedException {
        Thread t= new Thread(()->{
            while (run){
                //System.out.println("run..."); // 加了这一句就不会有效果了，因为缓存原因
            }
        });
        t.start();

        Thread.sleep(1000);

        run = false;
    }
}

为什么呢？分析：

  1. 初始状态，t 线程刚开始从主存读取了 run 的值到工作内存
    在这里插入图片描述
  2. 因为 t 线程要频繁从主内存读取 run 的值，JIT 编译器会将 run 的值缓存至自己工作内存中的高速缓存中，减少对主存 run 的访问，提高效率
    在这里插入图片描述
  3. 1 秒后，main 线程修改了 run 的值，并同步至主存，而 t 是从自己工作内存的高速缓存中读取这个变量的值，结果永远是旧的值
    在这里插入图片描述

2.2 解决方法

volatile（易变关键字）
它可以用来修饰成员变量和静态变量，他可以避免线程从自己的工作缓存查找变量的值，必须到主存中获取它的值，线程操作 volatile 变量都是直接操作主存的

2.3 可见性

  • 前面例子体现了可见性，它保证的是在多少线程之间，一个线程对 volatile 变量的修改对另一个线程可见，不能保证原子性，仅用在一个写线程，多个读线程情况（不能用在之前的 i++ 跟 i-- 情况）：
    从字节码层面看：
getstatic	run		// t 获取 run
getstatic	run		// t 获取 run
getstatic	run		// t 获取 run
getstatic	run		// t 获取 run
putstatic	run		// main 修改 run  仅一次
getstatic	run		// t 获取 run

public class Main2 {

    private static volatile boolean run = true;
    public static void main(String[] args) throws InterruptedException {
        Thread t= new Thread(()->{
            while (run){
                //System.out.println("run..."); // 加了这一句就不会有效果了，因为缓存原因
            }
        });
        t.start();

        Thread.sleep(1000);

        run = false;
    }
}

注意
synchronized 语句块既可以保证原子性也可以保证可见性，但是缺点是属于重量级操作，性能相对低
上面代码中 **System.out.println(“run…”)**为什么就能保证可见性呢？看看源码

public void println(String x) {
        synchronized (this) {  // 使用了 synchronized 关键字
            print(x);
            newLine();
        }
    }

3. 有序性

3.1 诡异的结果

public class Main {
    private static int num = 0;
    private static boolean ready = false;
    // 线程 1 执行
    public static void actor1(IResult result){
        if (ready){
            result.setR1(num + num);
        }else {
            result.setR1(1);
        }
    }

    // 线程 2 执行
    public static void actor2(){
        num = 2;
        ready = true;
    }

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 100; i++) {
            IResult iResult = new IResult();
            Thread t1 = new Thread(()->{
                actor1(iResult);
            });
            Thread t2 = new Thread(Main::actor2);
            t1.start();
            t2.start();
            t1.join();
            t2.join();
            num = 0;
            System.out.println(iResult.getR1());
        }
    }
}
class IResult {
    private int r1;

    public int getR1() {
        return r1;
    }

    public void setR1(int r1) {
        this.r1 = r1;
    }
}
==============结果=========================
有 0 4 1

$ mvn archetype:generate \
 -DinteractiveMode=false \
 -DarchetypeGroupId=org.openjdk.jcstress \
 -DarchetypeArtifactId=jcstress-java-test-archetype \
 -DgroupId=org.sample \
 -DartifactId=test \
 -Dversion=1.0

测试代码下载

3.2 解决

使用 volatile 修饰变量，可以禁止指令重排

3.3 有序性理解

  • 同一个线程内，JVM 会在不影响正确性的前提下，可以调整语句的执行顺序，思考下面一段代码：
static int i;
static int j;

// 在某个线程内执行如下赋值操作
i = ...; // 较为耗时操作
j = ...;
  • 可以看到，至于是先执行 i 还是先执行 j，对最终结果不会产生影响。所以，上面代码真正执行时，可以是：
i = ...; // 较为耗时操作
j = ...;
================================
j = ...;
i = ...; // 较为耗时操作
  • 这种特性称之为【指令重排】，多线程下【指令重排】会影响正确性，例如著名的 double-check-locking 模式实现单例
public class Singleton {
    private Singleton(){}
    public static Singleton INSTANCE = null;
    public static Singleton getInstance(){
        // 实例没创建，才会进入内部的 synchronized 代码块
        if (INSTANCE == null){
            synchronized (Singleton.class){
                // 也许其他线程已经创建实例
                if (INSTANCE == null){
                    INSTANCE = new Singleton();
                }
            }
        }
        return INSTANCE;
    }
}

以上实现的特点：

  • 懒惰实例化

  • 首次使用 getInstance() 才使用 synchronized 加锁，后续使用时无需加锁

  • 但在多线程环境下，上面的代码是有问题的， INSTANCE = new Singleton() 对应的字节码为：

0: new #2 				// class cn/itcast/jvm/t4/Singleton
3: dup
4: invokespecial #3 	// Method "<init>":()V
7: putstatic #4 		// Field INSTANCE:Lcn/itcast/jvm/t4/Singleton;
  • 其中 4 7 两步的顺序不是固定的，也许 JVM 会优化为：先将引用地址赋值给 INSTANCE 变量后，再执行构造方法，如果两个线程 t1、t2 按如下时间执行
时间1 t1 线程执行到 INSTANCE = new Singleton();
时间2 t1 线程分配空间，为Singleton对象生成了引用地址（0 处）
时间3 t1 线程将引用地址赋值给 INSTANCE，这时 INSTANCE != null（7 处）
时间4 t2 线程进入getInstance() 方法，发现 INSTANCE != null（synchronized块外），直接
返回 INSTANCE
时间5 t1 线程执行Singleton的构造方法（4 处）
  • 这时 t1 还没完全将构造方法下执行完毕，如果在构造方法中执行很多初始化操作，那么 t2 拿到的将是一个未初始化完毕的单例
  • 对 INSTANCE 使用 volatile 修饰即可，可以禁用指令重排，但要注意在 JDK 5 以上的版本的 volatile 才
    会真正有效

3.4 happens-before

  • happens-before 规定了哪些写操作对其它线程的读操作可见，它是可见性与有序性的一套规则总结，
    抛开以下 happens-before 规则，JMM 并不能保证一个线程对共享变量的写，对于其它线程对该共享变
    量的读可见
  • 线程解锁 m 之前对变量的写，对于接下来对 m 加锁的其它线程对该变量的读可见
public class Main {
    static int x;
    static Object m = new Object();
    public static void main(String[] args) {
        new Thread(()->{
            synchronized(m) {
                x = 10;
            }
        },"t1").start();
        new Thread(()->{
            synchronized(m) {
                System.out.println(x);
            }
        },"t2").start();
    }
}
  • 线程对 volatile 变量的写，对接下来其它线程对该变量的读可见
public class Main {
    private volatile static int x;
    public static void main(String[] args) {
        new Thread(()->{
            x = 10;
        },"t1").start();
        new Thread(()->{
            System.out.println(x);
        },"t2").start();
    }
}
  • 线程 start 前对变量的写，对该线程开始后对该变量的读可见
public class Main {
    private static int x;
    public static void main(String[] args) {
        x = 10;
        new Thread(()->{
            System.out.println(x);
        },"t2").start();
    }
}
  • 线程结束前对变量的写，对其它线程得知它结束后的读可见（比如其它线程调用 t1.isAlive() 或
    t1.join() 等待它结束）
public class Main3 {
    private static int x;
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            x = 10;
        },"t1");
        t1.start();
        t1.join();
        System.out.println(x);
    }
}
  • 线程 t1 打断 t2（interrupt）前对变量的写，对于其他线程得知 t2 被打断后对变量的读可见（通
    过t2.interrupted 或 t2.isInterrupted）
public class Main {
    private static int x;
    public static void main(String[] args) throws InterruptedException {
            Thread t2 = new Thread(()->{
                while(true) {
                    if(Thread.currentThread().isInterrupted()) {
                        System.out.println(x);
                        break;
                    }
                }
            },"t2");
            t2.start();
            new Thread(()->{
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                x = 10;
                t2.interrupt();
            },"t1").start();
            while(!t2.isInterrupted()) {
                Thread.yield();
            }
            System.out.println(x);
    }
}
  • 对变量默认值（0，false，null）的写，对其它线程对该变量的读可见
  • 具有传递性，如果 x hb-> y 并且 y hb-> z 那么有 x hb-> z

变量都是指成员变量或静态成员变量

17号技师
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JVM学习笔记
04-28
### JVM学习笔记 #### JVM内存模型 (JMM) JVM内存模型主要分为以下几个部分： - **Java堆**：这是所有线程共享的一块区域，在虚拟机启动时创建。主要用于存放对象实例，几乎所有的对象实例都在这里分配内存。 - *...
JVM 虚拟机.md
09-05
JVM 学习，包含运行数据区域，GC,JMM 等常见问题
JVM学习笔记 05 - JMM简述
Jomly Kellenda的博客
03-24 482
JVM 试图定义一种统一的内存模型，能将各种底层硬件，以及操作系统的内存访问差异进行封装，使 Java 程序在不同硬件及操作系统上都能达到相同的并发效果。
JVM学习笔记（六）JMM和Volatile
一点莹的博客
03-09 118
JMM JMM（Java Memory Model的缩写）是一种java内存模型。它类似于缓存一致性协议，用于定义数据读写的规则。 JMM定义了线程工作内存和主内存的一种抽象关系，线程中的共享对象存在于主内存中，每个线程都有一块私有的本地内存。 解决共享对象可见性问题，即线程中修改数据立马同步到主线程中，其它线程复制时可以得到最新的数据：volilate和synchronize关键词。 JMM数据同步模型如下图。 ...
B站狂神说JVM学习笔记
jacknoe的博客
11-11 637
JVM
狂神JVM学习笔记
qq_46541289的博客
08-01 185
- 谈谈对JVM的理解？Java8虚拟机和之前的更新变化？ - 什么是OOM，什么是栈溢出StackOverFlowError？怎么分析？ - JVM的常用调优参数有哪些？ - 内存快照如何抓取？怎么分析Dump文件？ - 谈谈JVM中，类加载器，你的认识？ ...
JVM学习笔记整理
指尖上的革新
07-20 612
文章目录前言一、JVM是什么二、创建对象是具体的，类是抽象的1.代码2.输出结果三类加载器 一、JVM是什么 Java平台可分为两部分，即Java虚拟机（Java virtual machine，JVM）和Java API类库。 JVM是Java Virtual Machine（Java虚拟机）的缩写，JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。 Java虚拟机主要分为五大模块：类装载器子系统、运行时数据区、执行
B站学习笔记之初探JVM学习笔记
从零开始的异世界JAVA学习
10-23 328
写在前面 本次笔记整理学习来源–>B站传送门–>【狂神说Java】JVM快速入门篇 感谢狂神❤ 还有这位up的短视频知识点教学也很棒–>B站up主较真的度 [程序员5分钟] 白话JVM内存结构，死也忘不了; [程序员5分钟] 带你认识java中jvm虚拟机栈; [程序员5分钟]理解了1+1的过程，你才算真正理解了虚拟机栈 感谢较真的度❤ 知乎博主写的这篇关于类加载机制的博文也不错,学习时可以参考参考–> 老大难的 Java ClassLoader 再不理解就老了 ml1.
【学习笔记】jvm
最新发布
liu1251303815的博客
08-10 438
3：类加载-初始化 加载过程 Loading 双亲委派，主要出于安全来考虑 LazyLoading 五种情况 –new get static put static invoke static指令，访问final变量除外 –java.lang.reflect对类进行反射调用时 –初始化子类的时候，父类首先初始化 –虚拟机启动时，被执行的主类必须初始化 –动态语言支持java.lang.invoke.MethodHandle解析的结果为REF_getstatic REF_putstatic
JVM完整笔记
guye
03-28 613
本文章是一篇学习笔记，记录了整个JVM相关的知识。
Java,JVM相关笔记的代码知识
09-16
这份JVM相关的笔记包含了深入理解JVM内部工作机制的关键代码资源，是学习和优化Java应用程序的重要参考资料。下面，我们将深入探讨Java与JVM的相关知识点。 1. **类加载机制**：JVM通过类加载器（ClassLoader）将...
Java并发编程与高并发解决方案-学习笔记.pdf
03-16
并发编程学习笔记，来源于 itmuch整理，是学习并发的不错的学习资料，有大神的个人感悟。介绍了一些概念，比如并发，高并发，并行，锁。
Java重要的基础知识/高级特性/工作经验170页笔记
02-21
精心制作的170页Java学习笔记 这本笔记要讨论的主题范围大概有： 1 . JMM: Java Concurrency Java运行的基础之一 2 . Java Concurrency: Java Java最重要的高级特性之一 3 . JVM:即Java Virtual Machine.我们都...
禁止延迟开启偏向锁jvm参数
weixin_44737877的博客
03-14 3342
jdk6默认开启偏向锁，但是是输入延时开启，也就是说，程序刚启动创建的对象是不会开启偏向锁的，几秒后后创建的对象才会开启偏向锁的 -XX:BiasedLockingStartupDelay=0 验证 引入依赖包 <!--可以查看mark word--> <!-- https://mvnrepository.com/artifact/org.openjdk.j...
Gson
weixin_44737877的博客
04-22 2586
这是我使用的Gson包版本 下面是官方介绍 Gson Gson is a Java library that can be used to convert Java Objects into their JSON representation. It can also be used to convert a JSON string to an equivalent Java object. ...
java中Pair
weixin_44737877的博客
12-16 2067
java中Pair 参考博客 https://blog.csdn.net/yaomingyang/article/details/79304840 https://blog.csdn.net/neweastsun/article/details/80294811 在这篇文章中，我们讨论了一个非常有用的编程概念，配对(Pair)。配对提供了一种方便方式来处理简单的键值关联，当我们想从方法返回两个值...
springboot REST client（携带token）请求头转发
weixin_44737877的博客
08-18 2017
官方文档 import feign.Logger; import feign.RequestInterceptor; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration
宋红康jvm学习笔记 逃逸分析
05-19
逃逸分析是JVM在运行时对对象的分析，用于确定对象的作用域。如果对象只在方法内部使用，那么它就不会逃逸出该方法，否则就会逃逸。逃逸分析可以优化程序的性能，因为当对象不逃逸时，JVM可以将它们放在线程栈上分配...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值