java多线程（十一）多线程内存（volatile关键字）

基于白嫖黑马程序员白嫖视频:全面深入学习java并发编程，java基础进阶中级必会教程

即共享变量在多线程间的 可见性问题与多条指令执行时的 有序性问题。

1 java内存模式（JMM）

java memory model，包括抽象的主存和工作内存，底层对应CPU寄存器、缓存、硬件内存等。（类似于RUNNABLE抽象了OS层面的运行时、可运行、阻塞）

• 主存：共享变量的存储位置；
• 工作内存：线程变量存储位置；

性质：

• 原子性：指令不会受到线程上下文切换影响；
• 可见性：指令不会受到cpu缓存影响；
• 有序性：指令不会受到cpu指令并行优化影响；

2 可见性

2.1 例子

public class Main {
    static boolean can = true;

    public static void main(String[] args) {
        new Thread(() -> {
            while (can) {
                //执行
            }
        }).start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        can = false;
        System.out.println("end");
    }
}

线程是个死循环，主线程1秒后改变了can的值为false，但是还是没有停止。

2.2 原因

因为共享变量can在主存的共享区，但是java为了优化，反复从主存读的情况，把can的值加到了高速缓存里面，所以主线程更改仅仅是主存中更改了，却没有在高速缓存中更改。

2.3 改进（volatile关键字）

对于共享变量加上volatile关键字：

volatile static boolean can = true;

防止缓存存放，每个线程每次都必须去主内存中获取can的值；
volatile可以修饰成员变量和静态成员变量（不能修饰局部变量），防止拷贝到缓存找值，线程操作volatile关键字的变量都是直接操作主存。
注意：不能解决原子性问题，仅仅解决可见性问题。

3 有序性

• JVM会在不影响正确性的前提下调整语句的执行顺序；
• 现代CPU支持多级指令流水线，可能会调整（重排序、组合）指令的执行顺序；
• 单线程程序运行优化重新排序不会影响结果，但是多线程的某一个线程内优化就可能影响结果；
• 禁止重排序关键字：volatile（防止使用该变量之前的代码重拍序）；

4 volatile原理

4.1 保证可见性

写屏障（sfence）：保证在该屏障（代码语句）之前的（包括自己）对共享变量的改动都同步到主存中；

public void fun(){
	num = 2;
	ready = true;//ready被volatile修饰
	//创建写屏障，这之前的对共享变量的改动都同步到主存中(num和ready)
	……
}

读屏障（lfence）：在屏障之后的代码，对于共享变量的读取是加载主存中的最新值；

public void fun(){
	if(ready){//ready是volatile修饰的，之后的读入包括自己都是去主存读取
		int r = num + num;
	}
	else{
		r = 1; 
	}
}

一句话，写之后要保存到主存，读之前要去主存读；

4.2 保证有序性

• 写屏障能够确保写屏障之前的代码不会重拍到写屏障之后；
• 读屏障能够确保读屏障之后的代码不会重拍到读屏障之前；
• 注意仅仅是不拍到后（前）面，不是不重拍；
• 只管的到线程内代码模块，管不到线程间；

5 happens-before规则

对共享变量的写操作要对其他线程的读操作可见。

5.1 锁对象

public class Main {
    static int x;
    static Object object = new Object();

    public static void main(String[] args) {
        //写
        new Thread(() -> {
            synchronized (object) {
                x = 10;
            }
        }).start();
        //读
        new Thread(()->{
           synchronized (object){
               System.out.println(x);
           }
        }).start();

    }
}

解锁object之前对变量写，加锁其他线程对mdu可见。

5.2 volatile情况

public class Main {
    static volatile int x;

    public static void main(String[] args) {
        //写
        new Thread(() -> {
            x = 10;
        }).start();
        //读
        new Thread(()->{
            System.out.println(x);
        }).start();
    }
}

5.3 start之前写

public class Main {
    static int x;

    public static void main(String[] args) {
        x = 10;
        //读
        new Thread(() -> {
            System.out.println(x);
        }).start();
    }
}

5.4 线程结束

public class Main {
    static  int x;

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

        try {
            t1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(x);
    }
}

5.5 通过打断来通知

5.6 默认值

对变量默认值（0，false，null）的写，其他线程读可见

5.7 传递性

public class Main {
    volatile static int x;
    static int y;

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

        //读
        new Thread(() -> {
            System.out.println(x);//x和y都对该线程可见
        }).start();
    }
}

利用了写屏障有序性的属性。