JVM系列之JMM内存模型

最新推荐文章于 2024-07-03 09:21:13 发布
最新推荐文章于 2024-07-03 09:21:13 发布
阅读量350 收藏 1
点赞数 1
分类专栏： JVM 文章标签： 多线程 java jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39294770/article/details/108586996
版权

JVM系列之JMM内存模型

      这篇博文之所以和“JVM系列之内存与垃圾回收篇”同期出，是因为我觉得如果单学习JVM的内存部分可能会让大部分人有点不知所云，毕竟不是“JVM系列之性能监控与调优篇”，所以我结合了线程安全和JVM数据运行区域下的变量去说明JMM内存模型的核心作用，结合“JVM系列之内存与垃圾回收篇”，可以让JVM更容易理解。

文章目录

前言

       “JVM系列之JMM内存模型”使用代码和实测的手法来说明知识点，内容是从用户请求到JVM去解析的，涉及变量，WEB服务器，多线程，JVM数据运行区域等知识点，如果有一些知识点有异议，欢迎指出！

第一章JMM的基本概要

# JMM是什么？

  • Java内存模型(即Java Memory Model，简称JMM)本身是一种抽象的概念，并不真实存在，它描述的是一组规则或规范，通过这组规范定义了程序中各个变量的访问方式，通过这组规则来决定一个线程对共享变量的写入何时对另一个线程可见，这组规则也称为Java内存模型（即JMM），简单来说，就是在并发环境下（用户并发访问或者程序使用多线程编程），你通过锁或者一些关键字（synchronized或者volatile）来解决并发问题时，实际上就是你通过的这些手段去触发JMM定义的规则（变量是否可见或者操作是否单一）去保证程序在并发环境下对变量操作的安全

# 什么环境下会有数据安全问题？

       也许你觉得这个问题放到这里有点不合适，但是上面提到JMM主要是与变量（数据）有关，所以知道什么环境会导致数据安全，而JMM是怎么控制这个问题的，是了解JMM的核心。

  • 数据安全问题可以由两个方面造成：①用户并发访问②程序使用多线程编程
           计算机或者服务器安装JDK其本质就是在计算机上配置一个JVM环境，而我们都知道JAVA程序的启动都需要依赖WEB服务器，原来的WEB项目是通过外置的WEB服务器启动，而现在的SpringBoot项目是通过打包成jar时内置一个WEB服务器的方式。
           WEB服务器主要有两大作用，第一就是接收用户请求，并把请求转到配置在自身服务器内的程序中；第二个就是线程池管理。
           ① 程序运行的实体是JVM进程中的线程，这个线程主要是对JVM进行变量操作，这个线程是通过WEB服务器去创建的，原来的WEB服务器内可以配置多个程序，然后共用一个JVM，而现在的SpringBoot项目通过内置的WEB服务器，只能一个WEB服务器对应一个程序，一个项目对应一个JVM。
    演示验证：一个WEB服务器对应一个JVM进程，一个WEB服务器内可以配置多个项目，共用一个JVM进程
    在这里插入图片描述
    在这里插入图片描述
    演示验证：SpringBoot项目一个项目对应一个JVM进程
    在这里插入图片描述
            ②用户访问程序的实质是通过WEB服务器创建线程去通过程序这个线程对JVM进行变量操作，这一结论就解释了①用户并发访问会造成多个线程同时对JVM的变量进行操作，如果操作的变量会有线程不安全问题（下面会介绍哪些变量会线程不安全）就会导致数据不安全问题。而程序使用多线程编程的实质是操作WEB服务器的线程池去创建线程去执行对应的逻辑代码，多线程的对JVM进行数据操作（存储或者取出）这一结论就解释了②程序使用多线程编程会造成数据不安全问题
    演示验证：用户访问程序会在JVM进程内创建线程的实质（线程有限，超过排队）
    在这里插入图片描述
  • 每个线程创建时JVM都会为其创建一个工作内存(因为JVM中可以存储变量，而又是线程独享的只有虚拟机栈，所以工作内存也可以称为栈空间)，用于存储线程私有的数据，而Java内存模型中规定所有变量（这里的变量指的是存储在堆和方法区的变量，虚拟机栈内也可以存储变量）都存储在主内存（堆和方法区），主内存是共享内存区域，所有线程都可以访问，但线程对变量的操作(读取赋值等)必须在工作内存中进行，首先要将变量从主内存拷贝到 自己的工作内存空间，然后对变量进行操作，操作完成后再将变量写回主内存（这就有一个时间差的问题导致的数据不安全），不能直接操作主内存中的变量，工作内存中存储着主内存中的变量副本拷贝，前面说过，工作内存是每个线程的私有数据区域，因此不同的线程间无法访问对方的工作内存，线程间的通信(传值)必须通过主内存来完成。

第二章JAVA变量与线程安全

# 变量

  • 变量的组成：①变量的数据类型 ②变量名
    变量的分类：按照数据类型分：①基本数据类型（值变量） ②引用类型（引用变量，注意区分引用变量和引用变量的对象的区别）
    按照在类中的声明的位置分：① 成员变量：在使用之前，都经历过默认初始化赋值
                                    类变量：linking的prepare阶段：给类变量默认赋值 ---->initial阶段：给类变量显示赋值，即静态代码块赋值
                                    实例变量：随着对象的创建，在堆空间分配实例变量空间，并进行默认赋值
                                    ② 局部变量：在使用前， 必须进行显式赋值！否则，编译不通过
package com.lzx.JVMObject;

/**
 * @author lzx
 * @version 1.0
 */
public class VariableAndObject {

    /**
     * 基本实例变量，存在堆空间（值），属于通过VariableAndObject创建的实例对象，不一定线程不安全
     */
    int baseInstanceVariable = 0;

    /**
     * 基本类变量，存在方法区，属于VariableAndObject类，一定线程不安全
     */
    static int baseClassVariable = 0;

    /**
     * 引用实例变量，存在堆空间（引用和值），属于通过VariableAndObject创建的实例对象，不一定线程不安全
     */
    Object referenceInstanceVariable = new Object();

    /**
     * 引用类变量，存在方法区（引用和值），属于VariableAndObject类，一定线程不安全
     */
    static Object referenceClassVariable = new Object();

    public void method() {
        /**
         * 基本局部变量，存在栈空间（值），属于method，一定线程安全
         */
        int baseLocalVariable = 0;
        /**
         * 引用局部变量，引用存在栈空间，实例对象存在堆（逃逸的情况下），属于method，一定线程安全
         */
        Object referenceLocalVariable = new Object();
    }

}

class Object {
    /**
     * 基本实例变量，存在堆空间（值），属于通过Object创建的实例对象，不一定线程不安全
     */
    int baseInstanceVariable = 0;

    /**
     * 基本类变量，存在方法区，属于Object类，一定线程不安全
     */
    static int baseClassVariable = 0;

    /**
     * 引用实例变量，存在堆空间（引用和值），属于通过Object创建的实例对象，不一定线程不安全
     */
    Object referenceInstanceVariable = new Object();

    /**
     * 引用类变量，存在方法区（引用和值），属于Object类，一定线程不安全
     */
    static Object referenceClassVariable = new Object();

    public void method() {
        /**
         * 基本局部变量，存在栈空间（值），属于method，一定线程安全
         */
        int baseLocalVariable = 0;
        /**
         * 引用局部变量，引用存在栈空间，实例对象存在堆（逃逸的情况下），属于method，一定线程安全
         */
        Object referenceLocalVariable = new Object();
    }
}
  • JVM中可以存储变量的有虚拟机栈，堆和方法区，而这其中只有虚拟机栈是线程独享的，代表虚拟机栈的变量是线程安全的

# 虚拟机栈存储的变量与线程安全

  • 虚拟机栈存储没有发生逃逸的局部变量的指针和实例对象，而发生逃逸的局部变量的指针存在栈上，实例对象（值）存在堆上。由于局部变量是每个线程独享的，所以多个线程操作同一块代码的局部变量时，每个线程的变量是不一样的，所以局部变量是没有线程安全问题的
    代码演示 
package com.lzx.JVMObjectThreadSafe;

import java.util.ArrayList;
import java.util.List;

/**
 * 局部变量线程安全测试,结果：局部变量一定线程安全
 *
 * @author lzx
 * @version 1.0
 */
public class LocalVariableThreadSafe {

    public static void main(String[] args) {
        LocalVariableThreadSafeByRunnable localVariableThreadSafeByRunnable = new LocalVariableThreadSafeByRunnable();
        for (int i = 0; i < 2; i++) {
            LocalVariableThreadSafeByThread localVariableThreadSafeByThread = new LocalVariableThreadSafeByThread();
            localVariableThreadSafeByThread.setName("资源不共享的线程" + i + "创建方式");
            localVariableThreadSafeByThread.start();
            Thread  thread = new Thread(localVariableThreadSafeByRunnable);
            thread.setName("资源共享的线程" + i + "创建方式");
            thread.start();
        }
    }
}

/**
 * 资源不共享的线程创建方式
 */
class LocalVariableThreadSafeByThread extends Thread {

    @Override
    public void run() {
        baseLocalVariableThreadSafeTest();
        referenceLocalVariableThreadSafeTest();
    }
    /**
     * 基本局部变量线程安全测试
     */
    public void baseLocalVariableThreadSafeTest() {
        int num = 0;
        for (int i = 1; i <= 10; i++) {
            num += i;
        }
        System.out.println(Thread.currentThread().getName() + "(extends Thread)的引用局部变量:" + num);
    }
    /**
     * 引用局部变量线程安全测试
     */
    public void referenceLocalVariableThreadSafeTest() {
        List<Integer> list = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            list.add(i);
        }
        System.out.println(Thread.currentThread().getName() + "(extends Thread)的引用局部变量:" + list.toString());
    }
}
/**
 * 资源共享的线程创建方式
 */
class LocalVariableThreadSafeByRunnable implements Runnable {

    @Override
    public void run() {
        baseLocalVariableThreadSafeTest();
        referenceLocalVariableThreadSafeTest();
    }
    /**
     * 基本局部变量线程安全测试
     */
    public void baseLocalVariableThreadSafeTest() {
        int num = 0;
        for (int i = 1; i <= 10; i++) {
            num += i;
        }
        System.out.println(Thread.currentThread().getName() + "(implements Runnable)的基本局部变量:" + num);
    }
    /**
     * 引用局部变量线程安全测试
     */
    public void referenceLocalVariableThreadSafeTest() {
        List<Integer> list = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            list.add(i);
        }
        System.out.println(Thread.currentThread().getName() + "(implements Runnable)的引用局部变量:" + list.toString());
    }

在这里插入图片描述

# 堆存储的变量与线程安全

  • 堆存储着实例变量（引用和实例对象），实例变量的线程安全问题需要分情况而定，如果该实例对象在共享的线程内（使用implements Runnable去创建的线程），那该实例对象是线程不安全的，如果该实例对象在不共享的线程内（使用extends Thread去创建的线程），那该实例对象是线程安全的，注意如果使用fianl修饰的实例变量是基本数据类型，那也可以保证线程安全
    代码演示 
package com.lzx.JVMObjectThreadSafe;

import java.util.ArrayList;
import java.util.List;

/**
 * 实例变量线程安全测试,结果：该实例对象在共享的线程内（使用implements Runnable去创建的线程），那该实例对象是线程不安全的，
 * 如果该实例对象在不共享的线程内（使用extends Thread去创建的线程），那该实例对象是线程安全的
 *
 * @author lzx
 * @version 1.0
 * @date 2020/9/14 15:40
 */
public class InstanceVariableThreadSafe {

    public static void main(String[] args) {

        InstanceVariableThreadSafeByRunnable instanceVariableThreadSafeByRunnable = new InstanceVariableThreadSafeByRunnable();
        for (int i = 0; i < 100; i++) {
            InstanceVariableThreadSafeByThread instanceVariableThreadSafeByThread = new InstanceVariableThreadSafeByThread();
            instanceVariableThreadSafeByThread.setName("资源不共享的线程" + i + "创建方式");
            instanceVariableThreadSafeByThread.start();
            Thread  thread = new Thread(instanceVariableThreadSafeByRunnable);
            thread.setName("资源共享的线程" + i + "创建方式");
            thread.start();
        }
    }
}

/**
 * 资源不共享的线程创建方式
 */
class InstanceVariableThreadSafeByThread extends Thread {

    int num = 0;
    List<Integer> list = new ArrayList<>();

    @Override
    public void run() {
        baseInstanceVariableThreadSafeTest();
        referenceInstanceVariableThreadSafeTest();
    }
    /**
     * 基本实例变量线程安全测试
     */
    public void baseInstanceVariableThreadSafeTest() {
        for (int i = 1; i <= 10; i++) {
            num += i;
        }
        System.out.println(Thread.currentThread().getName() + "(extends Thread)的引用实例变量:" + num);
    }
    /**
     * 引用实例变量线程安全测试
     */
    public void referenceInstanceVariableThreadSafeTest() {
        for (int i = 1; i <= 10; i++) {
            list.add(i);
        }
        System.out.println(Thread.currentThread().getName() + "(extends Thread)的引用实例变量:" + list.toString());
    }
}

/**
 * 资源共享的线程创建方式
 */
class InstanceVariableThreadSafeByRunnable implements Runnable {

    int num = 0;
    List<Integer> list = new ArrayList<>();

    @Override
    public void run() {
        baseInstanceVariableThreadSafeTest();
        referenceInstanceVariableThreadSafeTest();
    }
    /**
     * 基本实例变量线程安全测试
     */
    public void baseInstanceVariableThreadSafeTest() {
        for (int i = 1; i <= 10; i++) {
            num += i;
        }
        System.out.println(Thread.currentThread().getName() + "(implements Runnable)的基本实例变量:" + num);
    }
    /**
     * 引用实例变量线程安全测试
     */
    public void referenceInstanceVariableThreadSafeTest() {
        for (int i = 1; i <= 10; i++) {
            list.add(i);
        }
        System.out.println(Thread.currentThread().getName() + "(implements Runnable)的引用实例变量:" + list.toString());
    }
}

在这里插入图片描述

# 方法区存储的变量与线程安全

  • 方法区（元空间）存储着类变量（即使用static修饰的成员变量，这部分的变量是属于类的，由所有线程共享，会有线程安全问题）和静态常量，（这部分的常量是指final修饰的类变量，同理如果使用fianl修饰的类变量是基本数据类型，那可以保证线程安全）
    代码演示 
package com.lzx.JVMObjectThreadSafe;

import java.util.ArrayList;
import java.util.List;

/**
 * 类变量线程安全测试,结果：类变量是属于类的，在类创建的时候就已经存在，多个线程共享，所以类变量是线程不安全的
 *
 * @author lzx
 * @version 1.0
 * @date 2020/9/14 15:40
 */
public class ClassVariableThreadSafe {

    public static void main(String[] args) {

        ClassVariableThreadSafeByRunnable classVariableThreadSafeByRunnable = new ClassVariableThreadSafeByRunnable();
        for (int i = 0; i < 100; i++) {
            ClassVariableThreadSafeByThread classVariableThreadSafeByThread = new ClassVariableThreadSafeByThread();
            classVariableThreadSafeByThread.setName("资源不共享的线程" + i + "创建方式");
            classVariableThreadSafeByThread.start();
            Thread  thread = new Thread(classVariableThreadSafeByRunnable);
            thread.setName("资源共享的线程" + i + "创建方式");
            thread.start();
        }
    }
}

/**
 * 资源不共享的线程创建方式
 */
class ClassVariableThreadSafeByThread extends Thread {

    static int num = 0;
    static List<Integer> list = new ArrayList<>();

    @Override
    public void run() {
        baseClassVariableThreadSafeTest();
        referenceClassVariableThreadSafeTest();
    }
    /**
     * 基本类变量线程安全测试
     */
    public void baseClassVariableThreadSafeTest() {
        for (int i = 1; i <= 10; i++) {
            num += i;
        }
        System.out.println(Thread.currentThread().getName() + "(extends Thread)的引用类变量:" + num);
    }
    /**
     * 引用类变量线程安全测试
     */
    public void referenceClassVariableThreadSafeTest() {
        for (int i = 1; i <= 10; i++) {
            list.add(i);
        }
        System.out.println(Thread.currentThread().getName() + "(extends Thread)的引用类变量:" + list.toString());
    }
}

/**
 * 资源共享的线程创建方式
 */
class ClassVariableThreadSafeByRunnable implements Runnable {

    static int num = 0;
    static List<Integer> list = new ArrayList<>();

    @Override
    public void run() {
        baseClassVariableThreadSafeTest();
        referenceClassVariableThreadSafeTest();
    }
    /**
     * 基本类变量线程安全测试
     */
    public void baseClassVariableThreadSafeTest() {
        for (int i = 1; i <= 10; i++) {
            num += i;
        }
        System.out.println(Thread.currentThread().getName() + "(implements Runnable)的基本类变量:" + num);
    }
    /**
     * 引用类变量线程安全测试
     */
    public void referenceClassVariableThreadSafeTest() {
        for (int i = 1; i <= 10; i++) {
            list.add(i);
        }
        System.out.println(Thread.currentThread().getName() + "(implements Runnable)的引用类变量:" + list.toString());
    }
}

在这里插入图片描述

# final与线程安全

  • 粗略的来讲final修饰的变量的都可以叫做常量，但是如果严格来讲，final修饰的变量是基本数据类型的时候可以叫做常量，而是引用类型的时候叫做不可变变量（引用恒定不变），注意，当使用final修饰实例变量或者类变量，如果这个数据类型是基本数据类型，那这个不管是在堆或者方法区都是线程安全的，但是如果这个数据类型是引用类型，那这个就不是线程安全的，因为使用final修饰基本数据类型时可以保证值不变，但是修饰引用类型时，只能保证其引用恒定不变（无法让其指向一个新的对象），但是实例对象的内容却可以被修改
    例如
package com.lzx;

public class JVMObjectTest {

    private final static StringBuilder finalStaticSB = new StringBuilder("a");
    private final StringBuilder finalSB = new StringBuilder("a");

    public static void main(String[] args) {
        // finalStaticSB = new StringBuilder() //报错，无法指向新引用
        finalStaticSB.append("b"); //正常，可以改变值
        JVMObjectTest jvmObjectTest = new JVMObjectTest();
        //jvmObjectTest.finalSB = new StringBuilder() //报错，无法指向新引用
        jvmObjectTest.finalSB.append("b"); //正常，可以改变值
        System.out.println(finalStaticSB);
        System.out.println(jvmObjectTest.finalSB);
    }
}

第三章JMM与线程安全

# 原子性

  • 原子性指的是一个操作是不可中断的，即使是在多线程环境下，一个操作一旦开始就不会被其他线程影响。原子性问题，除了JVM自身提供的对基本数据类型读写操作的原子性外，对于方法级别或者代码块级别的原子性操作，可以使用synchronized关键字或者锁保证程序执行的原子性。

# 指令重排

  • 计算机在执行程序时，为了提高性能，编译器和处理器的常常会对指令做重排，一般分以下3种
  1. 编译器优化的重排
  • 编译器在不改变单线程程序语义的前提下，可以重新安排语句的执行顺序。
  1. 指令并行的重排
  • 现代处理器采用了指令级并行技术来将多条指令重叠执行。如果不存在数据依赖性(即后一个执行的语句无需依赖前面执行的语句的结果)，处理器可以改变语句对应的机器指令的执行顺序
  1. 内存系统的重排
  • 由于处理器使用缓存和读写缓存冲区，这使得加载(load)和存储(store)操作看上去可能是在乱序执行，因为三级缓存的存在，导致内存与缓存的数据同步存在时间差。
    其中编译器优化的重排属于编译期重排，指令并行的重排和内存系统的重排属于处理器重排，在多线程环境中，这些重排优化可能会导致程序出现内存可见性问题。

# 可见性

  • 理解了指令重排现象后，可见性容易了，可见性指的是当一个线程修改了某个共享变量的值，其他线程是否能够马上得知这个修改的值。对于串行程序来说，可见性是不存在的，因为我们在任何一个操作中修改了某个变量的值，后续的操作中都能读取这个变量值，并且是修改过的新值。但在多线程环境中可就不一定了，前面我们分析过，由于线程对共享变量的操作都是线程拷贝到各自的工作内存进行操作后才写回到主内存中的，这就可能存在一个线程A修改了共享变量x的值，还未写回主内存时，另外一个线程B又对主内存中同一个共享变量x进行操作，但此时A线程工作内存中共享变量x对线程B来说并不可见，这种工作内存与主内存同步延迟现象就造成了可见性问题，另外指令重排以及编译器优化也可能导致可见性问题，通过前面的分析，我们知道无论是编译器优化还是处理器优化的重排现象，在多线程环境下，确实会导致程序轮序执行的问题，从而也就导致可见性问题。
  • 工作内存与主内存同步延迟现象导致的可见性问题，可以使用synchronized关键字或者volatile关键字解决，它们都可以使一个线程修改后的变量立即对其他线程可见。

# 有序性

  • 有序性是指对于单线程的执行代码，我们总是认为代码的执行是按顺序依次执行的，这样的理解并没有毛病，毕竟对于单线程而言确实如此，但对于多线程环境，则可能出现乱序现象，因为程序编译成机器码指令后可能会出现指令重排现象，重排后的指令与原指令的顺序未必一致，要明白的是，在Java程序中，倘若在本线程内，所有操作都视为有序行为，如果是多线程环境下，一个线程中观察另外一个线程，所有操作都是无序的，前半句指的是单线程内保证串行语义执行的一致性，后半句则指指令重排现象和工作内存与主内存同步延迟现象。
  • 指令重排导致的可见性问题和有序性问题，则可以利用volatile关键字解决，因为volatile的另外一个作用就是禁止重排序优化

# JMM中的happens-before 原则

  • 除了靠sychronized和volatile关键字来保证原子性、可见性以及有序性外，JMM内部还定义一套happens-before 原则来保证多线程环境下两个操作间的原子性、可见性以及有序性。
  • happens-before是JMM的核心，在Java内存模型中，提供了happens-before 原则来辅助保证程序执行的原子性、可见性以及有序性的问题，它是判断数据是否存在竞争、线程是否安全的依据，happens-before 原则内容如下
  1. 程序顺序原则，即在一个线程内必须保证语义串行性，也就是说按照代码顺序执行。
  2. 锁规则 解锁(unlock)操作必然发生在后续的同一个锁的加锁(lock)之前，也就是说，如果对于一个锁解锁后，再加锁，那么加锁的动作必须在解锁动作之后(同一个锁)。
  3. volatile规则 volatile变量的写，先发生于读，这保证了volatile变量的可见性，简单的理解就是，volatile变量在每次被线程访问时，都强迫从主内存中读该变量的值，而当该变量发生变化时，又会强迫将最新的值刷新到主内存，任何时刻，不同的线程总是能够看到该变量的最新值。
  4. 线程启动规则 线程的start()方法先于它的每一个动作，即如果线程A在执行线程B的start方法之前修改了共享变量的值，那么当线程B执行start方法时，线程A对共享变量的修改对线程B可见
  5. 传递性 A先于B ，B先于C 那么A必然先于C
  6. 线程终止规则 线程的所有操作先于线程的终结，Thread.join()方法的作用是等待当前执行的线程终止。假设在线程B终止之前，修改了共享变量，线程A从线程B的join方法成功返回后，线程B对共享变量的修改将对线程A可见。
  7. 线程中断规则 对线程 interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生，可以通过Thread.interrupted()方法检测线程是否中断。
  8. 对象终结规则 对象的构造函数执行，结束先于finalize()方法
    案例演示这8条原则如何判断线程是否安全：
class MixedOrder{
    int a = 0;
    boolean flag = false;
    public void writer(){
        a = 1;
        flag = true;
    }

    public void read(){
        if(flag){
            int i = a + 1；
        }
    }
}

      解析：存在两条线程A和B，线程A调用实例对象的writer()方法，而线程B调用实例对象的read()方法，线程A先启动而线程B后启动，那么线程B读取到的i值是多少呢？现在依据8条原则，由于存在两条线程同时调用，因此程序次序原则不合适。writer()方法和read()方法都没有使用同步手段，锁规则也不合适。没有使用volatile关键字，volatile变量原则不适应。线程启动规则、线程终止规则、线程中断规则、对象终结规则、传递性和本次测试案例也不合适。线程A和线程B的启动时间虽然有先后，但线程B执行结果却是不确定，也是说上述代码没有适合8条原则中的任意一条，也没有使用任何同步手段，所以上述的操作是线程不安全的，因此线程B读取的值自然也是不确定的。修复这个问题的方式很简单，要么给writer()方法和read()方法添加同步手段，如synchronized或者给变量flag添加volatile关键字，确保线程A修改的值对线程B总是可见。

# volatile内存语义

  • volatile是Java虚拟机提供的轻量级的同步机制。volatile关键字有如下两个作用
  1. 保证被volatile修饰的共享变量对所有线程总数可见的，也就是当一个线程修改了一个被volatile修饰共享变量的值，新值总数可以被其他线程立即得知。
  2. volatile的另一个功能是：禁止指令重排序优化。

# volatile的可见性

关于volatile的可见性作用，我们必须意识到被volatile修饰的变量对所有线程总是立即可见的，对volatile变量的所有写操作总是能立刻反应到其他线程中，但是对于volatile变量运算操作在多线程环境并不保证安全性（不能保证原子性），原因是可能会有两个线程同时读到同一个数值，如下

package com.lzx.KeywordThreadSafe.Volatile;


/**
 * Volatile不安全测试，结果：Volatile并不能保证原子性
 * @author lzx
 * @version 1.0
 */
public class VolatileVisibilityThreadUnSafe {
    public static void main(String[] args) {

        VolatileVisibilityByRunnable volatileVisibilityByRunnable = new VolatileVisibilityByRunnable();
        for (int i = 0; i < 100; i++) {
            Thread  thread = new Thread(volatileVisibilityByRunnable);
            thread.setName("资源共享的线程" + i + "创建方式");
            thread.start();
        }
    }

}

/**
 * 资源共享的线程创建方式
 */
class VolatileVisibilityByRunnable implements Runnable {

    volatile static int num = 0;

    @Override
    public void run() {
        volatileVisibilityThreadUnSafeTest();
    }
    /**
     * volatile原子性线程不安全测试
     */
    public void volatileVisibilityThreadUnSafeTest() {
        for (int i = 1; i <= 10; i++) {
            num += i;
        }
        System.out.println(Thread.currentThread().getName() + "(implements Runnable)的volatile变量:" + num);
    }
}

在这里插入图片描述
      解析: 虽然num变量的任何改变都会立马反应到其他线程中，如果有多条线程同时读到一个值，并对同一个值进行操作，就会出现线程安全问题，毕竟num += i;操作并不具备原子性，该操作是先读取值，然后写回一个新值，分两步完成，如果第二个线程在第一个线程读取旧值和写回新值期间读取i的域值，那么第二个线程就会与第一个线程一起看到同一个值，并执行相同值操作，这也就造成了线程安全失败，因此对于volatileVisibilityThreadSafeTest方法必须使用synchronized修饰，以便保证线程安全，需要注意的是一旦使用synchronized修饰方法后，由于synchronized本身也具备与volatile相同的特性，即可见性，因此在这样种情况下就完全可以省去volatile修饰变量。
另外一种场景，可以使用volatile修饰变量达到线程安全的目的，如下

package com.lzx.KeywordThreadSafe.Volatile;


/**
 * Volatile安全测试，结果：Volatile可以保证可见性
 * @author lzx
 * @version 1.0
 */
public class VolatileVisibilityThreadSafe {
    public static void main(String[] args) {

        VolatileVisibilityByRunnable2 volatileVisibilityByRunnable2 = new VolatileVisibilityByRunnable2();
        for (int i = 0; i < 10; i++) {
            Thread  thread = new Thread(volatileVisibilityByRunnable2);
            thread.setName("资源共享的线程" + i + "创建方式");
            thread.start();
        }
    }

}

/**
 * 资源共享的线程创建方式
 */
class VolatileVisibilityByRunnable2 implements Runnable {

    volatile static boolean close;

    @Override
    public void run() {
        volatileVisibilityThreadSafeTest();
    }
    /**
     * volatile可见性安全测试
     */
    public void volatileVisibilityThreadSafeTest() {
            close();
            System.out.println(Thread.currentThread().getName() + "(implements Runnable)的volatile变量:" + close);
            open();
            System.out.println(Thread.currentThread().getName() + "(implements Runnable)的volatile变量:" + close);

    }
    public void close() {
        close = true;
    }
    public void open() {
        close = false;
    }
}

在这里插入图片描述
      解析：由于对于boolean变量close值的修改属于原子性操作，因此可以通过使用volatile修饰变量close，使用该变量对其他线程立即可见，从而达到线程安全的目的。那么JMM是如何实现让volatile变量对其他线程立即可见的呢？实际上，当写一个volatile变量时，JMM会把该线程对应的工作内存中的共享变量值刷新到主内存中，当读取一个volatile变量时，JMM会把该线程对应的工作内存置为无效，那么该线程将只能从主内存中重新读取共享变量。volatile变量正是通过这种写-读方式实现对其他线程可见。

# volatile禁止重排优化

  • volatile关键字另一个作用就是禁止指令重排优化，从而避免多线程环境下程序出现乱序执行的现象，关于指令重排优化前面已详细分析过，这里主要简单说明一下volatile是如何实现禁止指令重排优化的。先了解一个概念，内存屏障(Memory Barrier）。
          内存屏障，又称内存栅栏，是一个CPU指令，它的作用有两个，一是保证特定操作的执行顺序，二是保证某些变量的内存可见性（利用该特性实现volatile的内存可见性）。由于编译器和处理器都能执行指令重排优化。如果在指令间插入一条Memory Barrier则会告诉编译器和CPU，不管什么指令都不能和这条Memory Barrier指令重排序，也就是说通过插入内存屏障禁止在内存屏障前后的指令执行重排序优化。Memory Barrier的另外一个作用是强制刷出各种CPU的缓存数据，因此任何CPU上的线程都能读取到这些数据的最新版本。总之，volatile变量正是通过内存屏障实现其在内存中的语义，即可见性和禁止重排优化。下面看一个非常典型的禁止重排优化的例子，如下：
public class DoubleCheckLock {

    private static DoubleCheckLock instance;

    private DoubleCheckLock(){}

    public static DoubleCheckLock getInstance(){

        //第一次检测
        if (instance==null){
            //同步
            synchronized (DoubleCheckLock.class){
                if (instance == null){
                    //多线程环境下可能会出现问题的地方
                    instance = new DoubleCheckLock();
                }
            }
        }
        return instance;
    }
}

      上述代码一个经典的单例的双重检测的代码，这段代码在单线程环境下并没有什么问题，但如果在多线程环境下就可以出现线程安全问题。原因在于某一个线程执行到第一次检测，读取到的instance不为null时，instance的引用对象可能没有完成初始化。因为instance = new DoubleCheckLock();可以分为以下3步完成(伪代码)

memory = allocate(); //1.分配对象内存空间
instance(memory);    //2.初始化对象
instance = memory;   //3.设置instance指向刚分配的内存地址，此时instance！=null

由于步骤1和步骤2间可能会重排序，如下：

memory = allocate(); //1.分配对象内存空间
instance = memory;   //3.设置instance指向刚分配的内存地址，此时instance！=null，但是对象还没有初始化完成！
instance(memory);    //2.初始化对象

      由于步骤2和步骤3不存在数据依赖关系，而且无论重排前还是重排后程序的执行结果在单线程中并没有改变，因此这种重排优化是允许的。但是指令重排只会保证串行语义的执行的一致性(单线程)，但并不会关心多线程间的语义一致性。所以当一条线程访问instance不为null时，由于instance实例未必已初始化完成，也就造成了线程安全问题。那么该如何解决呢，很简单，我们使用volatile禁止instance变量被执行指令重排优化即可。

 //禁止指令重排优化
  private volatile static DoubleCheckLock instance;
技术都是浮云
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Java内存模型JMM浅析
02-25
并发编程有多种风格，除了CSP(通信顺序进程)、Actor等模型外，大家最熟悉的应该是基于线程和锁的共享内存模型了。在多线程编程中，需要注意三类并发问题:1.原子性2.可见性3.重排序原子性涉及到，一个线程执行一个...
JMM（Java 内存模型）详解
m0_51431003的博客
11-12 6488
所有线程创建的实例对象都存放在主内存中，不管该实例对象是成员变量还是方法中的本地变量(也称局部变量)每个线程都有一个私有的本地内存来存储共享变量的副本，并且，每个线程只能访问自己的本地内存，无法访问其他线程的本地内存。本地内存是 JMM 抽象出来的一个概念，存储了主内存中的共享变量副本。线程 A 把本地内存中修改过的共享变量副本的值同步到主内存中去。线程 B到主存中读取对应的共享变量的值。也就是说，JMM 为共享变量提供了可见性的保障。
JMM内存模型
yygr的博客
01-17 2996
Java内存模型即Java Memory Model，简称JMM。JMM定义了Java 虚拟机(JVM)在计算机内存(RAM)中的工作方式。JVM是整个计算机虚拟模型，所以JMM是隶属于JVM的。 如果我们要想深入了解Java并发编程，就要先理解好Java内存模型。Java内存模型定义了多线程之间共享变量的可见性以及如何在需要的时候对共享变量进行同步。原始的Java内存模型效率并不是很理想，因此Java1.5版本对其进行了重构，现在的Java8仍沿用了Java1.5的版本。 关于并发编程 在并发编程领域，有
JMM(Java内存模型)详解
最新发布
落日的博客
07-03 1450
为了对上面的问题进行更深入的探究，我有查了一些JIT相关的资料。简单总结下JIT然后再对上面的问题分析下。JIT（Just-In-Time）编译器是Java虚拟机（JVM）中的一个关键组件，它负责在程序运行过程中动态地将字节码（即Java编译后的.class文件中的代码）转换为特定于平台的机器代码。这一过程旨在提高程序的执行效率，因为它能够针对运行时的数据和实际使用模式进行优化，而不仅仅是基于静态代码分析。JIT工作原理加载与解释执行：当Java程序启动时，JVM首先加载类文件并由解释器执行字节码。
JVM 虚拟机 ----＞ Java 内存模型（JMM）
weixin_62587914的博客
09-12 2254
Heap堆区，用于存放对象实例和数组的内存区域Heap堆是JVM所管理的内存中最大的一块区域，被所有线程共享的一块内存区域。堆区中存放对象实例，“几乎”所有的对象实例以及数组都在这里分配内存Java世界中“几乎”所有的对象都在堆中分配，但是，随着JIT编译器的发展与逃逸分析技术逐渐成熟，栈上分配、标量替换优化技术将会导致一些微妙的变化，所有的对象都分配到堆上也渐渐变得不那么“绝对”了。从JDK 1.7。
JMM内存模型详解
全栈行动派的博客
04-11 901
JVM规范试图定义一种Java内存模型（JMM）来屏蔽各种硬件和操作系统的内存访问模型。关键技术点都是围绕多线程的原子性、可见性和有序性这三大特性展开的。
Java内存模型详解JMM.docx
05-03
Java内存模型（Java Memory Model，JMM）是Java虚拟机（JVM）中的一种内存模型，它描述了程序中各个变量之间的关系，以及在实际计算机系统中将变量存储到内存和从内存中取出变量这样的底层细节。JMM允许编译器和缓存...
jvm详细内存模型图1
09-03
查看《深入理解Java虚拟机》后，自己简单总结的jvm相关的简单模型图。
深入理解Java虚拟机（jvm性能调优+内存模型+虚拟机原理）.zip
09-27
《深入理解Java虚拟机》是一本深度探讨Java虚拟机（JVM）的著作，涵盖了JVM性能调优、内存模型以及虚拟机原理等多个关键领域。本文将基于这些主题，详细阐述其中的重要知识点。 首先，我们要了解Java虚拟机（JVM）...
JVM内存模型与JMM
w1061217723的博客
04-24 554
JVM是JAVA虚拟机，JMM是JAVA内存模型。 JVM内存模型 JVM内存模型主要指运行时的数据区，包括5个部分 线程私有： 栈也就方法栈，是线程私有的，线程在执行每个方法时都会同时创建一个栈帧，用来存储局部变量表、操作栈、动态链接、方法出口等信息。调用方法时执行入栈，方法返回时执行出栈。 本地方法栈与栈类似，也是用来保存线程执行方法时的信息，不同的是，执行java方法使用栈，而执行native方法使用本地方法栈。 程序计数器保存着当前线程所执行的字节码位置，每个线程工作时都有一个独立的计数器。程序计
【Java内存模型】Java内存模型（JMM）详解以及并发编程的三个重要特性（原子性，可见性，有序性）
小七的博客
02-14 3218
目录 1 Java内存模型（Java memory model JMM） 1.1 什么是JMM（JMM的作用） 1.2 JMM的组成 2 硬件内存架构与java内存模型 2.1 硬件架构 2.2 Java线程与硬件处理器 2.3 Java内存模型与硬件内存架构的关系 2.4 Java内存模型的必要性 3.并发编程的三个重要特性 3.1 原子性 3.2 可见性 3.3...
JMM JVM的区别
学亮编程手记
05-28 494
JMM是Java Memory Model的缩写，是Java内存模型的一部分。JVM是Java Virtual Machine的缩写，是Java虚拟机的缩写。JMM定义了线程和主内存之间的抽象关系，即JMM中定义了线程在JVM主内存中的工作方式。而JVM是Java整个计算虚拟模型，强调对内存空间的划分。
JVM内存模型（JMM）
weixin_61430914的博客
09-15 385
Java程序把内存控制权利交给JVM虚拟机，一旦出现内存泄漏和溢出方法的问题，如果不了解虚拟机是怎样使用内存的，那么排查错误将会是一个非常艰巨的任务，所以我们就需要来了解一下JVM内存模型。
一文带你深入了解JMM（Java内存模型）
xjx666666的博客
08-06 552
synchronized的特点获得同步锁；清空工作内存；从主内存拷贝对象副本到工作内存；执行代码(计算或者输出等)；刷新主内存数据；释放同步锁。所以，synchronized既保证了多线程的并发有序性和原子性，又保证了多线程的内存可见性。有序性和原子性都是通过同一时刻只有一个线程可以进入锁住的代码保证的（不被其他线程中断，避免了部分执行）。volatile是第二种Java多线程同步的手段。一个被volatile修饰的变量，JMM会确保所有线程看到的是一致的变量值。
JMM（Java内存模型）
这波不亏的博客
04-06 503
CPU架构 CPU架构缓存一致性 缓存一致性协议给缓存行（通常为64字节）定义了个状态，用来描述该缓存行是否被多处理器共享、是否修改，缓存一致性协议最出名的是MESI协议。 MESI中每个缓存行都有四个状态，分别是独占E（exclusive）、修改M（modified）、共享S（shared）、失效I（invalid）。 独占（exclusive）：仅当前处理器拥有该缓存行，并且没有修改过，是最新的值。 共享（share）：有多个处理器拥有该缓存行，每个处理器都没有修改过缓存，是最新的值。 修改（mod
jvm和jmm区别
weixin_41612174的博客
05-07 1730
jvm和jmm区别 概念 JVM是Java Virtual Machine（Java虚拟机）的缩写，JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。 JMM即Java内存模型(Java memory model)，在JSR133里指出了JMM是用来定义一个一致的、跨平台的内存模型，是缓存一致性协议，用来定义数据读写的规则。 ...
jvm内存模型和jmm
05-11
JVM内存模型是Java虚拟机规定的一种用于管理内存的规范，包括了线程私有的程序计数器、虚拟机栈、本地方法栈和线程共享的堆内存以及方法区（包括运行时常量池）。JVM内存模型保证了多线程程序在访问共享变量时的可见性、有序性和原子性。 JMM（Java内存模型）是Java语言规范中定义的一种规范，它描述了Java虚拟机如何提供内存的可见性、有序性和原子性保证，以及Java程序中各种操作之间的先后关系。JMM定义了一套规则，保证了Java程序在不同的平台和不同的JVM实现上都能够获得相同的内存行为。 JMM是JVM内存模型的一部分，它是由Java语言规范定义的，而JVM内存模型是由Java虚拟机规范定义的。JMM规范定义了Java程序对内存的访问和操作的规则，而JVM内存模型则描述了Java虚拟机如何实现这些规则。简单来说，JMM规范定义了Java程序如何使用内存，而JVM内存模型定义了Java虚拟机如何管理内存。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值