Java虚拟机之内存模型

1. 内存模型Java内存模型是Java虚拟机规范中试图定义一种Java内存模型(Java Memory Model，JMM)来屏蔽掉各种硬件和操作系统的内存访问差异，以实现让Java程序在各种平台上都能达到一致的内存访问效果。简单来说JMM定义了一套在多线程读写共享数据时，对数据可见性、有序性和原子性的规则和保障。1.1 原子性synchronized同步关键字。/*** @Descriptio

江海i

2025人浏览 · 2022-03-30 15:58:22

江海i · 2022-03-30 15:58:22 发布

1. 内存模型

Java内存模型是Java虚拟机规范中试图定义一种Java内存模型(Java Memory Model，JMM)来屏蔽掉各种硬件和操作系统的内存访问差异，以实现让Java程序在各种平台上都能达到一致的内存访问效果。
简单来说JMM定义了一套在多线程读写共享数据时，对数据可见性、有序性和原子性的规则和保障。

1.1 原子性

synchronized同步关键字。

/**
 * @Description JMM——原子性
 * @date 2022/3/30 8:39
 */
public class Atomicity {
    static int i = 0;

    static Object obj = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            for (int j = 0; j < 50000; j++) {
                synchronized (obj){
                    i++;
                }
            }
        });
        
        Thread t2 = new Thread(()->{
            for (int j = 0; j < 50000; j++) {
                synchronized (obj){
                    i--;
                }
            }
        });

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

        t1.join();
        t2.join();

        System.out.println(i);
    }
}

使用synchronized关键字之后，当前对象的monitor区域能够使用，其中包括：

Owner：只能有一个线程成为Owner；
EntryList：排队等候区，其它线程成为Owner，再进来线程就要在这等待（阻塞），等到Owner执行完毕后，EntryList中的线程就会争抢成为新的Owner。

1.2 可见性

下方代码中：运行一个t线程从主线程中读取run变量，等待线程睡眠一秒后，修改run的值，但t线程并不会停下来。

/**
 * @Description JMM——可见性
 * @date 2022/3/30 8:55
 */
public class Visibility {
    static boolean run = true;

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
           while (run){

           }
        });
        t.start();
        Thread.sleep(1000);
        run = false;
    }
}

内存模型：
在这里插入图片描述
由于t线程要频繁的读取run的值，即时编译器会将run缓存到工作内存中，减少对主线程的访问，提高效率：

1秒之后修改的run的值也仅仅是在主线程中修改的，但高速缓存没有变化。

volatile关键字，用来修饰成员变量和静态成员变量，避免线程从自己的工作缓存中查找变量的值，必须到主内存中获取它的值。但是它只能保证一个线程写入，其它线程读取的情况。如果多个线程一起写入就无法保证变量的原子性。

1.3 有序性

指令重排：是即使编译器在运行时的优化，JVM会在不影响正确性的前提下，可以调整语句的执行顺序。但是在多线程的情况下，指令重排会影响正确性。使用volatile关键字可以避免指令重排。

happen-before：如果一个操作执行的结果需要对另一个操作可见。

规则：

如果一个操作happens-before另一个操作，那么第一个操作的执行结果将对第二个操作可见，而且第一个操作的执行顺序排在第二个操作之前。
两个操作之间存在happens-before关系，并不意味着一定要按照happens-before原则制定的顺序来执行。如果重排序之后的执行结果与按照happens-before关系来执行的结果一致，那么这种重排序并不非法。

规则原则： 摘自《深入理解Java虚拟机第12章》）

程序次序规则：一段代码在单线程中执行的结果是有序的。注意是执行结果，因为虚拟机、处理器会对指令进行重排序（重排序后面会详细介绍）。虽然重排序了，但是并不会影响程序的执行结果，所以程序最终执行的结果与顺序执行的结果是一致的。故而这个规则只对单线程有效，在多线程环境下无法保证正确性。
volatile变量规则：这是一条比较重要的规则，它标志着volatile保证了线程可见性。通俗点讲就是如果一个线程先去写一个volatile变量，然后一个线程去读这个变量，那么这个写操作一定是happens-before读操作的。
传递规则：提现了happens-before原则具有传递性，即A happens-before B , B happens-before C，那么A happens-before C
线程启动规则：假定线程A在执行过程中，通过执行ThreadB.start()来启动线程B，那么线程A对共享变量的修改在接下来线程B开始执行后确保对线程B可见。
线程终结规则：假定线程A在执行的过程中，通过制定ThreadB.join()等待线程B终止，那么线程B在终止之前对共享变量的修改在线程A等待返回后可见。

1.4 CAS与原子类

CAS(Compare and Swap)：体现一种乐观锁的思想，它会不断的尝试进行某种操作，直到当前线程修改的同时对其它的线程没有影响。获取变量时，为保证可见性一般使用volatile来修饰。因为没有使用synchronized关键字，不会造成线程阻塞，效率会提高。但如果竞争激烈，重试会频繁发生，效率会收到影响。一般工作在多核CPU下。

CAS底层实现依赖于Unsafe类直接调用操作系统底层的CAS指令。

Java中的乐观锁和悲观锁：

乐观锁：CAS就是乐观锁的思想，最乐观的估计，不怕别的线程来修改共享变量，即使改了之后，CAS也会在重试。
悲观锁：synchronized是悲观锁的思想，最悲观的估计，防着其它线程来修改共享变量，只有等待解卡锁之后其它的线程才有机会。

1.5 原子类

Java中的JUC提供了原子操作类，提供线程安全的操作，底层使用CAS + volatile来实现。

基本类型: AtomicInteger, AtomicLong, AtomicBoolean ;
数组类型: AtomicIntegerArray, AtomicLongArray, AtomicReferenceArray ;
引用类型: AtomicReference, AtomicStampedRerence, AtomicMarkableReference ;
对象的属性修改类型: AtomicIntegerFieldUpdater, AtomicLongFieldUpdater, AtomicReferenceFieldUpdater

1.6 `synchronized`优化

在Java HotSpot 虚拟机中，每个对象都有对象头(包括class指针和Mark word)。Mark平时存储对象的哈希码、分代年龄；当加锁时这些信息根据情况被替换为标记位、线程锁记录指针、重量级锁指针、线程ID等内容。

1.6.1 轻量级锁

如果一个对象虽然有多线程访问，但是多线程访问时间是错开的，就可以使用轻量级锁。

两个代码块使用一个对象加锁

/**
 * @Description synchronized 优化 —— 轻量级锁
 * @date 2022/3/30 15:11
 */
public class LightLock {
    static Object obj = new Object();

    public static void method1(){
        synchronized (obj){
            method2();
        }
    }

    public static void method2(){
        synchronized (obj){

        }
    }
}