Java内存模型可见性

环境：

java version "1.8.0_201"
Java(TM) SE Runtime Environment (build 1.8.0_201-b09)
Java HotSpot(TM) 64-Bit Server VM (build 25.201-b09, mixed mode)

基本概念：

Java内存模型(即Java Memory Model，简称JMM)本身是一种抽象的概念，并不真实存在，它描述的是一组规则或规范，通过这组规范定义了程序中各个变量（包括实例字段，静态字段和构成数组对象的元素）的访问方式。

JVM程序运行的实体是线程，而每个线程创建时JVM都会为其创建一个工作内存(有些地方称为栈空间)，用于存储线程私有的数据，而Java内存模型中规定所有变量都存储在主内存，主内存是共享内存区域，所有线程都可以访问，但线程对变量的操作(读取赋值等)必须在工作内存中进行，首先要将变量从主内存拷贝的自己的工作内存空间，然后对变量进行操作，操作完成后再将变量写回主内存，不能直接操作主内存中的变量，工作内存中存储着主内存中的变量副本拷贝，前面说过，工作内存是每个线程的私有数据区域，因此不同的线程间无法访问对方的工作内存，线程间的通信(传值)必须通过主内存来完成，其简要访问过程如下图：

1.png

volatile关键字

volatile是Java虚拟机提供的轻量级的同步机制。volatile关键字有如下两个作用。

1）保证被volatile修饰的共享变量对所有线程总是可见的，也就是当一个线程修改了一个被volatile修饰共享变量的值，新值总是可以被其他线程立即得知。

2）禁止指令重排序优化。

可见性

并发编程中提到较多，是指对象间的可见性，含义是一个对象能够看到或者能够引用另一个对象的能力。
示例1：

public class Test1 {

    private static boolean flag = true;

    private static int i = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            while (flag) {
                i++;
            }
            System.out.printf("**********跳出成功, i=%d **********\n", i);
        });
        thread.start();
        Thread.sleep(100);
        flag = false;
        System.out.printf("**********main thread 结束, i=%d **********\n", i);
    }
}

此例中，flag虽然被主线程修改为false，但是子线程仍然读取的是栈空间的flag=true,所以不会跳出循环

示例2：

public class Test2 {

    private static volatile boolean flag = true;

    private static int i = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            while (flag) {
                i++;
            }
            System.out.printf("**********跳出成功, i=%d **********\n", i);
        });
        thread.start();
        Thread.sleep(100);
        flag = false;
        System.out.printf("**********main thread 结束, i=%d **********\n", i);
    }
}

此例中，flag有volatile修饰，当主线程修改flag为false时，子线程马上就结束了while循环。
由以上两例可以看出volatile确实可以保证被修饰的变量对其他线程立即可见，但是还有另外一种方法即便没有volatile修饰，也可以跳出while循环。
示例3：

public class Test3 {

    private static boolean flag = true;

    private static int i = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            while (flag) {
                i++;
            }
            System.out.printf("**********跳出成功, i=%d **********\n", i);
        });
        thread.start();
        Thread.sleep(1);
        flag = false;
        System.out.printf("**********main thread 结束, i=%d **********\n", i);
    }
}

此例中，修改了主线程休眠时间为1毫秒，while循环成功跳出，输出如下：

**********test1 main thread 结束, i=51464 **********
**********test1 跳出成功, i=51464 **********

Process finished with exit code 0

对比示例1和示例3不难得出一个结论：

当主线程停顿时间很极短（1～2ms）时，可以跳出循环；
当主线程停顿时间较长时，无法跳出循环；

结论变种1：

当子线程循环执行时间极短（1～2ms）时，可以跳出循环；
当子线程循环执行时间较长时，无法跳出循环；

结论变种2:

当子线程循环次数较少时，可以跳出循环；
当子线程循环次数较多时，无法跳出循环；

代码的执行结果如果跟执行时间、循环次数有关，那么一定是即时编译器（JIT，Just In Time）的优化对运行结果产生了影响。
在文章开始我已经列出了我本地使用java -version命令行查看到当前系统使用的编译模式：mixed mode。
mixed mode代表是默认的混合编译模式，除了这种模式外，我们还可以使用-Xint参数强制虚拟机运行于只有解释器的编译模式下，这时 JIT 完全不介入工作；也可以使用参数-Xcomp强制虚拟机运行于只有 JIT 的编译模式下。例如：

C:\Users\YiLin Li>java -Xint -version
java version "1.8.0_201"
Java(TM) SE Runtime Environment (build 1.8.0_201-b09)
Java HotSpot(TM) 64-Bit Server VM (build 25.201-b09, interpreted mode)

C:\Users\YiLin Li>java -Xcomp -version
java version "1.8.0_201"
Java(TM) SE Runtime Environment (build 1.8.0_201-b09)
Java HotSpot(TM) 64-Bit Server VM (build 25.201-b09, compiled mode)

当 JVM 的初始化完成后，类在调用执行过程中，执行引擎会把字节码转为机器码，然后在操作系统中才能执行。在字节码转换为机器码的过程中，虚拟机中还存在着一道编译，那就是即时编译。
最初，JVM 中的字节码是由解释器（ Interpreter ）完成编译的，当虚拟机发现某个方法或代码块的运行特别频繁的时候，就会把这些代码认定为热点代码（Hot Spot Code）。
为了提高热点代码的执行效率，在运行时，即时编译器（JIT，Just In Time）会把这些代码编译成与本地平台相关的机器码，并进行各层次的优化，然后保存到内存中。
运行过程中会被即时编译器编译的“热点代码”有两类：

被多次调用的方法。
被多次调用的循环体。

使用idea验证上述结论，在VM options中输入执行参数:

-Xint ：强制使用解释执行的方式启动java虚拟机，示例1和示例3的代码都会跳出循环。
-Xcomp：强制使用编译执行的方式启动java虚拟机，示例1和示例3都无法填出循环。

如果不输入执行参数，默认使用混合模式，而混合模式下只有热点代码达到一定阈值才会发生JIT优化，因此导致了上述看到的运行时间长短对运行结果的影响。

我在最开始学习的时候，习惯性的在while循环中输出了 i 的值，直接跳出了while循环
示例4：

public class Test4 {

    private static boolean flag = true;

    private static int i = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            while (flag) {
                i++;
                System.out.printf("**********当前值 i=%d **********\n", i);
            }
            System.out.printf("**********跳出成功, i=%d **********\n", i);
        });
        thread.start();
        Thread.sleep(100);
        flag = false;
        System.out.printf("**********main thread 结束, i=%d **********\n", i);
    }
}

示例4和示例1中代码唯一区别就是在while循环中输出了 i 的值，示例4没有修改线程休眠时间，也没有使用volatile关键字，但却可以跳出while循环，即便加上-Xcomp使用编译执行的方式启动，仍然可以跳出while循环。
根据java的内存模型规范，一个线程对普通变量的修改并不需要立即写回到主存，且另一个线程读取也不需要每一次都从主存中去读取。至于什么时候与主内存同步，虚拟机只需保证方法出栈时将修改的值同步到主内存。因此这其中有比较宽松的优化空间。由此推测，当使用 printf 输出时，存在一定的同步空间。虚拟机会在此时与主内存同步。