JMM可见性和有序性

Java内存模型(JMM)

JMM(Java Memory Model),从Java层面定义了(主存,工作内存)抽象概念
主存:所有线程共享的数据
工作内存:每个线程私有的数据

JMM体现在以下几个方面:
原子性:临界区指令执行是原子的,不会受到线程上下文切换的影响
可见性:保证指令不会受cpu缓存的影响
有序性:保证指令不会受cpu指令并行优化的影响

共享变量在多线程间的可见性问题

static boolean run = true;
public static void main(String[] args) throws InterruptedException {
    new Thread(() -> {
        while(run){
            //...
        }
    },"t1").start();

    TimeUnit.SECONDS.sleep(1);
    log.debug("停止 t1");
    run = false; // t1线程并不会设想的那样停下来
}

volatile

// volatile表示易变的意思
加了volatile的变量,读取时每次都要从主存中读取
synchronized也可以保证代码块内变量的可见性

// 原理
volatile的底层实现原理是内存屏障(Memory Barrier)

// ready是volatile变量
// volatile变量的写指令之后会加入写屏障
// 写屏障保证在屏障之前,对共享变量的改动,都同步到主存当中
public void actor2(I_Result r){
    num = 2;
    ready = true;
    // 写屏障
}

// volatile变量的读指令之前会加入读屏障
// 读屏障保证该屏障之后,对共享变量的读取,加载的是主存中的数据
public void actor1(I_Result r){
	// 读屏障
    if(ready){
        r.r1 = num + num;
    }else{
        r.r1 = 1;
    }
}

多条指令执行时的有序性问题

JVM会在不影响正确性的前提下，指令重排，多线程下可能会出现安全问题

int num = 0;
boolean ready = false;
// 线程1执行该方法
public void actor1(I_Result r){
    if(ready){
        r.r1 = num + num;
    }else{
        r.r1 = 1;
    }
}
// 线程2执行该方法
public void actor2(I_Result r){
    num = 2;
    ready = true;
}

// r.r1会有三种结果(0,1,4)
// 指令重排时,假如(num = 2;ready = true;)交换了次序
// 先执行了ready=true;还没给num赋值, 恰此时又发生了上下文切换执行第一个方法, 则r.r1的值就为0

// 如何禁止指令重排
// 在ready上加volatile即可
// (写屏障之前的代码不会进行指令重排)
// (读屏障之后的代码不会进行指令重排)
// 有序性只是保证本线程内相关代码不被重排序
// volatile保证的是有序性和可见性,不能保证原子性
// synchronized三者都可以

public final class Singleton{
    private Singleton(){}
    private static volatile Singleton INSTANCE;

    public static Singleton getInstance(){
        // 只有前面会进synchronized,后面直接拿就行
        if(INSTANCE == null){
            synchronized (Singleton.class){
                if(INSTANCE == null){
                    INSTANCE = new Singleton(); // volatile保证INSTANCE的创建是有序的,避免指令重排
                }
            }
        }
        return INSTANCE;
    }
}
// new Singleton()编译为字节码是有多个指令的

private boolean starting = false;
// 确保只被执行一次
public void start(){
    synchronized (this){
        if(starting){
            return;
        }
        starting = true;
    }
    // ... do things
}