Java内存模型

于 2022-11-20 10:07:47 发布
阅读量235 收藏
点赞数
文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43374578/article/details/127945715
版权

内存模型

1. 可见性

1.1 问题引发

  • 一个线程对主存中数据写操作，对其他线程的读操作不可见
package com.erick.multithread.d4;

import java.util.concurrent.TimeUnit;

public class Demo01 {
    private static boolean flag = true;

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            while (flag) {
                /*中间不要打印任何东西，避免出现错误*/
            }
        }, "t1").start();

        TimeUnit.SECONDS.sleep(3);
        /*3秒后主线程修改了flag，但是上面线程没有如期停下来*/
        flag = false;
    }
}

1.2 原理分析

# 初始状态
- 初始状态，静态变量run被加载到主存中
- t线程从主存中读取到了run
- t线程要频繁从主存中读取数据，
  JIT编译器会将run的值缓存到自己的工作内存中的高速缓存中，减少对主存的访问，提高性能
 
 # 3秒后
- 主存中的数据被修改了，但是t线程还是读取自己工作内存的数据，并不会去主存中去拿

image-20221005104014090

1.3 解决方案

volatile
- 修饰成员变量或者静态成员变量
- 线程获取该变量时，不会从自己的工作内存中去读取，每次都是去主存中读取
- 牺牲了性能，保证了一个线程改变主存中某个值时，对于其他线程不可见的问题

package com.erick.multithread.d4;

import java.util.concurrent.TimeUnit;

public class Demo01 {
    private static volatile boolean flag = true;

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            while (flag) {
            }
        }, "t1").start();

        TimeUnit.SECONDS.sleep(3);
        flag = false;
    }
}
synchronized
- 解决不可见性：重量级锁
- java内存模式中，synchronized规定，线程在加锁时

1. 先清空工作内存
2. 在主存中拷贝最新变量到工作内存中
3. 执行代码
4. 将更改后的共享变量的值刷新到主存中
5. 释放互斥锁

package com.erick.multithread.d4;

import java.util.concurrent.TimeUnit;

public class Demo02 {
    private static boolean flag = true;
    private static final Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            while (true){
                synchronized (lock){
                    if (!flag) {
                        break;
                    }
                }
            }
        }).start();

        TimeUnit.SECONDS.sleep(3);
        flag = false;
    }
}

1.4 犹豫模式–Balking

  • 一个线程发现另一个线程已经做好了某个事，那么该线程就无需再做
  • 类比单例模式
重复做
package com.erick.multithread.d4;

import lombok.Getter;

import java.util.concurrent.TimeUnit;

public class Demo03 {
    public static void main(String[] args) throws InterruptedException {
        Balking balking = new Balking();
        for (int i = 0; i < 5; i++) {
            new Thread(() -> balking.operation()).start();
        }

        TimeUnit.SECONDS.sleep(3);
        System.out.println(balking.getJobDoneTimes());
    }
}

class Balking {
    private boolean isJobDone;
    @Getter
    private int jobDoneTimes;

    public void operation() {
        if (isJobDone) {
            return;
        }
        /*大概为5*/
        jobDoneTimes++;

        try {
            System.out.println(Thread.currentThread().getName() + " execute job");
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        isJobDone = true;
    }
}
synchronized
package com.erick.multithread.d4;

import lombok.Getter;

import java.util.concurrent.TimeUnit;

public class Demo04 {
    public static void main(String[] args) throws InterruptedException {
        BalkingJob balkingJob = new BalkingJob();
        for (int i = 0; i < 5; i++) {
            new Thread(() -> balkingJob.operation()).start();
        }

        TimeUnit.SECONDS.sleep(2);
        System.out.println(balkingJob.getJobDoneTimes());
    }
}

class BalkingJob {
    private boolean isJobDone;
    @Getter
    private int jobDoneTimes;

    public synchronized void operation() {
        if (isJobDone){
            return;
        }
        jobDoneTimes++;
        System.out.println(Thread.currentThread().getName() + " execute job");
        isJobDone = true;
    }
}

2. 有序性

2.1 计组思想

- 每条指令划分为    取指令 --- 指令译码 --- 执行指令 --- 内存访问 --- 数据回写
- 计组思想 并不能提高单个指令的执行时间，但是变相的提高了吞吐量

在这里插入图片描述
在这里插入图片描述

2.2 指令重排

  • 一条代码，可能被字节码执行分为若干个指令
  • JVM在不影响性能的情况下，会对代码的执行顺序进行重排
正常重排
  • 即使重排序，不会对结果产生影响
private int i;
private int j;

i=0;
j=2;
异常重排
  • 不可重排，重排后就会发生错误
  • 这种JVM层面的指令重排，就会引发莫名其妙的错误
private int i = 0;
private int j = 2;

i = 10;
j = i-1;
禁止重排
  • volatile修饰成员变量或者静态成员变量，该变量上面的所有指令都不会重排
private int i = 0;
private volatile int j = 1;

// 只需要在j上加，这样代码中j的上面的所有代码，就不会被放到j后实现
i = 10;
j = i - 1;

Volatile 原理

- Memory Barrier(Memory Fence):     底层实现是内存屏障
- 写屏障：                           在写操作后，加上写屏障
- 读屏障：                           在读操作前，加上读屏障

1. 可见性

1.1 写屏障

  • voliate修饰的变量，会在写操作后，加上写屏障( 代码执行处)
  • 在该屏障之前的所有代码的改动，同步到主存中去
package com.dreamer.multithread.day02;

public class Demo03 {

    private static int number = 0;

    private static volatile int age = 0;

    public static void main(String[] args) {

        new Thread(() -> {
            number++;
            age=10;
            // JVM  会加上写屏障
        }).start();

    }
}

1.2 读屏障

  • volatile修饰的变量，会在读取到该变量的前面，加上读屏障
  • 读屏障后面的数据，都会在主存中获取
package com.dreamer.multithread.day02;

public class Demo03 {

    private static int number = 0;

    private static volatile int age = 0;

    public static void main(String[] args) {
        
        new Thread(() -> {
            int ageResult = age;
            int numberResult = number;
        }).start();

    }
}

2. 有序性-指令重排

- 只能保证   本线程内   不会发生指令重排

2.1 写屏障

  • 确保指令重排时，写屏障之前的代码，不会重排到写屏障后面
private  int number = 0;
private volatile boolean flag = true;

public void method(){
     number ++;
     flag = false;   // 写屏障，不会将写屏障前面的代码，重排到写屏障后面
}

2.2 读屏障

  • 确保指令重排时，读屏障后的代码，不会重排到读屏障之前

3. 指令交错

- volatile不能保证不同线程在执行的时候的指令交错引发的问题(不能保证线程安全)
- 只是保证各个线程在执行的时候都从主存中去加载

4. synchronized/volatile

synchronizedvolatile
锁级别重量级锁轻量级锁
可见性可解决可解决
原子性(多线程指令交错)可解决不保证
指令重排可以重排，但不会出错可以禁止重排
场景一个线程修改，其他线程读多线程并发修改

Happen-Before原则

- 对共享变量的读写操作，代码的可见性和有序性的一套总结

1. synchronized

  • 线程解锁之前对变量的写，对于接下来的用加锁的其他线程的读，改变是可见的
  • 线程解锁前，会将写操作的变量，从工作内存会同步到主内存中
package com.dreamer.multithread.day02;

public class Demo04 {
    private static int x = 0;

    private static Object lock = new Object();

    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (lock) {
                x = 10;
            }
        }).start();

        new Thread(() -> {
            synchronized (lock) {
                System.out.println(x);
            }
        }).start();
    }
}

2. volatile

  • 变量用volatile修饰，一个线程对其的写操作，对于其他线程来说是可见的
  • 写屏障结合读屏障，保证是从主存中读取变量
package com.dreamer.multithread.day02;

public class Demo05 {
    private static volatile int x = 0;

    public static void main(String[] args) {
        new Thread(() -> x = 10).start();

        new Thread(() -> System.out.println(x)).start();
    }
}

3. 先写先得

  • 线程start前对变量的写操作，对该线程开始后的读操作是可见的
package com.dreamer.multithread.day02;

public class Demo06 {
    private static int x = 0;

    public static void main(String[] args) {

        x = 10;

        new Thread(() -> System.out.println(x)).start();
    }
}

4. 通知准则

  • 线程结束前对变量的写操作，对其他线程得知它结束后的读操作可见性
  • 如调用join方法
package com.dreamer.multithread.day02;

public class Demo07 {

    private static int x = 0;

    public static void main(String[] args) throws InterruptedException {

        Thread thread = new Thread(() -> x = 10);
        thread.start();

        thread.join();

        System.out.println(x);
    }
}

5. 打断规则

  • 线程t1 打断t2前，t1对变量的写，对于其他线程得知得知t2被打断后，对变量的读可见
package com.dreamer.multithread.day06;

public class Demo07 {
    private static int x = 0;

    public static void main(String[] args) {
        Thread t2 = new Thread("t2") {
            @Override
            public void run() {
                while (true) {
                    if (Thread.currentThread().isInterrupted()) {
                        break;
                    }
                }
            }
        };

        Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                x = 5;
                t2.interrupt();
            }
        };

        t1.start();
        t2.start();

        while (t2.isInterrupted()) {
            Thread.yield();
        }

        System.out.println(x);
        
    }
}

6. 默认值

  • 对变量默认值的写，0，false，null，其他线程对该变量可见

7. 传递性

  • 其实就是volatile的读屏障和写屏障问题
package com.dreamer.multithread.day02;

public class Demo08 {
    private static int x = 0;

    private static volatile int y = 0;

    public static void main(String[] args) {
        new Thread(() -> {
            x = 10;
            y = 20;
            // 写屏障，会将上面的操作全部赋值到主存中去
        }).start();

        new Thread(() -> {
            System.out.println(x);
            System.out.println(y);
        }).start();
    }
}
飞翔荷兰号
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java 内存模型
07-23
深入理解 java 内存模型是 java 程序员的必修课，看看原汁原味正宗的内存模型吧
Java内存模型——可见性
TKD03072010的专栏
01-15 3353
/**  * 可见性问题  * @author Snway  *  */ public class Visibility {          private static boolean stop;          public static void main(String[] args) throws Exception {         Thread t1 = new Thread(n
Java内存模型之可见性(填坑之路)
gt9000的博客
03-09 363
前几天路过一个经常负责面试的同事附近，看到几个人在讨论volatile的可见性问题，当时第一感觉是 ：“可见性还不简单吗？volatile修饰一个变量时，那么在一个线程都对这个变量的更改，其他线程都立即可见。” 后面听到这样一句话：“实际运行结果能刷新你的三观，网上的例子很多都是有问题的”，让我瞬间产生了兴趣。凑近一看，果然跟我的很多认知都产生了偏差。 为了解决其中的疑惑，查阅的不少文章，拨开了...
java 内存模型 - 可见性 有序性
01-17 155
可见性： 一个线程的操作，对另外一个线程来说是可见的。 上一段代码，没有可见性。 public class TestJMM { private static boolean flag = true; private static int i = 0; public static void main(String[] args) throws Interrupte...
Volatile
weixin_43374578的博客
10-09 153
一、可见性 一个线程对主存中数据的修改，对于另外的线程不可见 1. 引发 package com.dreamer.multithread.day02; import java.util.concurrent.TimeUnit; public class Demo01 { private static boolean flag = true; public static void main(String[] args) throws InterruptedException {
关于volatile关键字与内存可见性的一点理解
WK_SDU的博客
08-06 907
在日常写java代码的环境下（不是研究计算机理论的情况）是会观测到内存可见性所带来的一些问题，比如下面这段代码： public class ReorderingDemo { static boolean flag = false; public static void main(String[] args) throws Exception { new T...
深入理解 Java 内存模型_程晓明_InfoQ_java_内存模型_
09-30
Java内存模型，简称JMM（Java Memory Model），是Java编程语言规范的一部分，它定义了线程如何共享和访问内存，以及在多线程环境中如何保证数据一致性。理解JMM对于编写高效、正确且线程安全的Java代码至关重要。 ...
Java内存模型知识详解
08-18
"Java内存模型知识详解" Java内存模型是Java虚拟机（JVM）中的一种抽象概念，定义了Java程序中变量的访问规则和内存模型的交互关系。 Java内存模型的主要目标是定义程序中各个变量的访问规则，即在虚拟机中将变量...
volatile 原理
最新发布
小鲁蛋的博客
10-14 2264
volatile 是 Java 提供的一种轻量级的同步机制。Java 语言包含两种内在的同步机制：同步块（或方法）和 volatile 变量，相比于synchronized（synchronized通常称为重量级锁），volatile更轻量级，因为它不会引起线程上下文的切换和调度。但是volatile 变量的同步性较差（有时它更简单并且开销更低），而且其使用也更容易出错。
多线程(二) -- 管程(一) -- Synchronized详解
weixin_39724194的博客
07-16 321
多线程引发的问题： 脏读：一个常见的概念。在多线程中，难免会出现在多个线程中对同一个对象的实例变量进行并发访问的情况，如果不做正确的同步处理，那么产生的后果就是"脏读"，也就是取到的数据其实是被更改过的。 代码示例： public class ThreadDomain13 { private int num = 0; public void addNum(String userName) { try { if ("a".equals(userName)
java 线程学习（五）
qq_43680142的博客
09-14 159
Java 多线程指令交错 两个线程对初始值为 0 的静态变量一个做自增，一个做自减，各做 5000 次，结果有可能不为0 private static int count = 0; public static void main(String[] args) throws InterruptedException { Thread t1 = new Thread(() -> { for (int i = 0; i < 5000; i++) {
指令重排序测试&volatile原理学习
fengxiandada的博客
05-14 554
文章目录1. 从CPU层面理解指令重排序1.1 鱼罐头加工的故事1.2 指令重排序优化1.3 支持流水线的处理器1.4 指令重排序导致的异常2. volatile原理2.1 保证可见性2.2 保证有序性2.3 指令交错2.4 double-checked locking 问题2.5 double-checked locking 解决2.6 happens-before3. final3.1 设置 final 变量的原理3.2 获取 final 变量的原理附录：流水线期末考试计算大题流水线技术（必考流水线的相
多线程安全
weixin_43374578的博客
07-20 503
1. 共享变量 多个线程 读 共享资源 没问题 多个线程 写 共享资源 可能线程不安全 临界区： 一段代码如果 存在 对共享资源的多线程 读写操作，称这段代码块 为临界区 竞态条件： 多个线程在在临界区内，对共享变量资源的争抢 package com.nike.multi; import java.util.concurrent.TimeUnit; public class Demo01 { private static int num = 0; /**
Java并发学习笔记（四）：Java内存模型（JMM）、可见性、有序性、volatile使用、volatile原理、线程安全单例、Happens-Before
Miracle42的博客
05-30 1215
Java内存模型 一、简介 Java内存模型的主要目的是定义程序中各种变量的访问规则，即关注在虚拟机中把变量值存储到内存和从内存中取出变量值这样的底层细节。其中所指的变量包括了实例字段、静态字段和构成数组对象的元素，但是不包括局部变量与方法参数，因为后者是线程私有的。 工作原理：Java内存模型规定了所有变量都存储在主内存（Main Memory）中，每条线程还有自己的工作内存（Work Memory，可以与高速缓存类比），现成的工作内存保存了该线程使用的变量的主内存副本，线程对变量的所有操作（读取、赋值等
指令重排详解
wangbuji的博客
07-30 3383
指令重排： 编译器指令重排，cpu指令重排，内存指令重排。 编译器可能会调整顺序，如下图，左边是c++源码，右边是优化后顺序 一条汇编指令的执行是可以分为很多步骤的, 分为不同的硬件执行 取指 IF 译码和取寄存器操作数 ID 执行或者有效地址计算 EX (ALU逻辑计算单元) 存储器访问 MEM 写回 WB (寄存器) 指令重排只可能发生在毫无关系的指令之间, 如果指令之间存在依赖关系, 则不会重排。单线程内程序的执行结果不能被改变。 1 原子性是指一个操作是不可中断的.
多线程的安全问题
myjess’s blog
03-04 438
1、共享带来的问题 多个线程在临界区内执行，由于代码的执行序列不同而导致结果无法预测。 临界区 一个程序运行多个线程本身是没有问题的 问题出在多个线程访问共享资源。在多个线程对共享资源读写操作时发生指令交错，就会出现问题。一段代码块内如果存在对共享资源的多线程读写操作，称这段代码块为临界区。 static int counter = 0; static void increment() // 临界区 { counter++; } static void decrement() // 临界区 { coun
【多线程学习三】线程安全
Jennifer29的博客
06-16 232
当多线程同时对共享资源执行操作时，产生的线程安全怎么解决
JMM八大操作 voliate可见性原理
lichangpeng1988的专栏
05-07 1497
知识储备： 计算机CPU缓存 计算机多核处理过程 计算机主存知识 线程概念 计算机指令优化重排序 内存模型-同步八种操作 1：lock： 把主内存变量标识为一条线程独占，此时不允许其他线程对此变量进行读写。 2：unlock：解锁一个主内存变量。 3：read： 把一个主内存变量值读入到线程的工作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值