JVM---Java内存屏障和JMM

最新推荐文章于 2023-02-08 08:40:40 发布

意田天

最新推荐文章于 2023-02-08 08:40:40 发布

阅读量1.8w

点赞数

分类专栏： JVM 文章标签： jvm 内存屏障 java

本文链接：https://blog.csdn.net/A_Java_Dog/article/details/118251798

版权

JVM 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

Java内存屏障-JMM

Java内存屏障和JMM

Java内存屏障和JMM

硬件层数据一致性

协议很多

intel 用MESI

https://www.cnblogs.com/z00377750/p/9180644.html

现代CPU的数据一致性实现 = 缓存锁(MESI …) + 总线锁

伪共享

读取缓存以cache line为基本单位，目前64bytes

位于同一缓存行的两个不同数据，被两个不同CPU锁定，产生互相影响的伪共享问题

代码演示

package com.cyc.juc.c_028_FalseSharing;

import java.util.Random;

/**
 * 模拟位于同一缓存行的两个不同数据，被两个不同CPU锁定，产生互相影响的伪共享问题
 * arr数组中有T对象,长度为2, 开启两个线程, 循环的同时给a0和a1赋值,t1线程只给a0赋值, 但是却要拿到整个
 * arr数组,t2给a1赋值, 同样, 拿到的也是arr数组, 也就是说他们操作的是同一个对象, t1操作之后, t2拿到的arr要同步t1
 * 修改过的a0,同理, t1拿到arr之后也要同步t2修改过的a1, 两者在操作之前都要去同步数据，此时效率就降低了很多。
 */
public class T01_CacheLinePadding {
    private static class T {
        public volatile long x = 0L;
    }

    public static T[] arr = new T[2];

    static {
        arr[0] = new T();
        arr[1] = new T();
    }

    public static void main(String[] args) throws Exception {
        Thread t1 = new Thread(()->{
            for (long i = 0; i < 1000_0000L; i++) {
                arr[0].x = i;
            }
        });

        Thread t2 = new Thread(()->{
            for (long i = 0; i < 1000_0000L; i++) {
                arr[1].x = i;
            }
        });

        final long start = System.nanoTime();
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println((System.nanoTime() - start)/100_0000);
    }
}

连续三次的输出结果为: 238, 214, 273

使用缓存行的对齐能够提高效率

代码演示

package com.mashibing.juc.c_028_FalseSharing;

/**
 * 由于一个缓存行占64个字节, 因此Padding中预设7个基本数据类型,每个数据类型占8个字节,共计56个字节,
 * 这些数据不做任何操作,只是为了占位和保持行对齐
 * 新建的T对象继承Padding, 此时每个T对象保证可以是在不同的缓存行中,从而避免相互影响
 */
public class T02_CacheLinePadding {
    private static class Padding {
        public volatile long p1, p2, p3, p4, p5, p6, p7;
    }

    private static class T extends Padding {
        public volatile long x = 0L;
    }

    public static T[] arr = new T[2];

    static {
        arr[0] = new T();
        arr[1] = new T();
    }

    public static void main(String[] args) throws Exception {
        Thread t1 = new Thread(()->{
            for (long i = 0; i < 1000_0000L; i++) {
                arr[0].x = i;
            }
        });

        Thread t2 = new Thread(()->{
            for (long i = 0; i < 1000_0000L; i++) {
                arr[1].x = i;
            }
        });

        final long start = System.nanoTime();
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println((System.nanoTime() - start)/100_0000);
    }
}

连续三次执行的结果耗时: 69, 69, 70

可以看到, 执行速度有了很大的提升, 虽然多占据了一些空间, 但是比起节省的时间, 还是值得的。

乱序问题

CPU为了提高指令执行效率，会在一条指令执行过程中（比如去内存读数据（慢100倍）），去同时执行另一条指令，前提是，两条指令没有依赖关系

https://www.cnblogs.com/liushaodong/p/4777308.html

写操作也可以进行合并

https://www.cnblogs.com/liushaodong/p/4777308.html

JUC/029_WriteCombining

乱序执行的证明：JVM/jmm/Disorder.java

原始参考：https://preshing.com/20120515/memory-reordering-caught-in-the-act/

如何保证特定情况下不乱序

硬件内存屏障 X86

sfence: store| 在sfence指令前的写操作当必须在sfence指令后的写操作前完成。
lfence：load | 在lfence指令前的读操作当必须在lfence指令后的读操作前完成。
mfence：modify/mix | 在mfence指令前的读写操作当必须在mfence指令后的读写操作前完成。

原子指令，如x86上的”lock …” 指令是一个Full Barrier，执行时会锁住内存子系统来确保执行顺序，甚至跨多个CPU。Software Locks通常使用了内存屏障或原子指令来实现变量可见性和保持程序顺序

JVM级别如何规范（JSR133）

LoadLoad屏障：
对于这样的语句Load1; LoadLoad; Load2，

 在Load2及后续读取操作要读取的数据被访问前，保证Load1要读取的数据被读取完毕。

StoreStore屏障：

 对于这样的语句Store1; StoreStore; Store2，
 
 在Store2及后续写入操作执行前，保证Store1的写入操作对其它处理器可见。

LoadStore屏障：

 对于这样的语句Load1; LoadStore; Store2，
 
 在Store2及后续写入操作被刷出前，保证Load1要读取的数据被读取完毕。

StoreLoad屏障：
对于这样的语句Store1; StoreLoad; Load2，

 在Load2及后续所有读取操作执行前，保证Store1的写入对所有处理器可见。

volatile的实现细节

字节码层面
ACC_VOLATILE

在这里插入图片描述

查看其字节码文件，通过对比，可以看到 volatile修改的变量在字节码层面添加了个volatile标识。

JVM层面
volatile内存区的读写都加屏障

StoreStoreBarrier

volatile 写操作

StoreLoadBarrier

LoadLoadBarrier

volatile 读操作

LoadStoreBarrier
OS和硬件层面
https://blog.csdn.net/qq_26222859/article/details/52235930
hsdis - HotSpot Dis Assembler
windows lock 指令实现 | MESI实现