java并发编程之HappenBefore

概述

HappenBefore意思表示的是前一个操作的结果对于后续操作是可见的，所以它是一种表达多个线程之间对于内存的可见性。所以我们可以认为在 JMM 中，如果一个操作执行的结果需要对另一个操作可见，那么这两个操作必须要存在happens-before 关系。 这两个操作可以是同一个线程，也可以是不同的线程。比如操作1HappenBefore操作2，那么操作1的执行结果对操作2可见。

也就是说HappenBefore原则是指导我们写出具有可见性代码的原则。编写的代码符合这些其中一个原则，就是满足可见性的代码。

HappenBefore原则

程序顺序规则

一个线程中的每个操作， happens-before 于该线程中的任意后续操作; 可以简单认为是 as-if-serial。 单个线程中的代码顺序不管怎么变， 对于结果来说是不变的。也就是同一线程的所有操作，前面的对后面的总是可见。

	int a;
    int b;



    public void happenBeforeDemo1(){
        a = 5;  //1
        b = 6;  //2
        int c = a + b;  //3
    }

上面代码，对于同一个线程来说 1happenbefore2 ，2happenbefore3。但是对于不同线程来说，这个原则不成立。

volatile 变量规则

对于 volatile 修饰的变量的写的操作，一定 happen-before 后续对于 volatile 变量的读操作；

private   int count = 0;

    private volatile boolean flag = false;

    public void writer(){
        count = 5;  //1
        flag = true; //2
    }

    public void reader(){
        if (flag){  //3
            int k = count; //4
        }
    }

对于上面代码2 HappenBefore 3，因为flag变量被volatile关键字修饰，所以对该变量的修改HappenBefore于对该变量的读取。也就是说对于不同的线程，flag的修改总是对其他线程可见。

传递性规则

如果 1 happens-before 2; 2happensbefore 3; 那么传递性规则表示: 1 happens-before 3;

start规则

如果线程 A 执行操作 ThreadB.start(),那么线程A执行ThreadB.start()之前的操作Happen-Before线程B的任意操作。

结合下面代码解释，也就是先按照程序顺序规则来说，对于同一线程主线程，4 HappeBefore 5 Happen 6. 5操作是启动线程B，按照start原则，4属于5之前的操作，所以4操作会HappenBefore任意线程B里面的操作（也就是操作1、2、3），但是操作6不符合。

 static int age = 5;

    public static void main(String[] args) {


        Thread thread = new Thread(()->{
        	int a = 5; //1
        	int b = 10; //2
            System.out.println(age); //3
        });

        age = 10; //4
        thread.start(); //5

        age = 60; //6
    }

join原则

如果线程 A 执行操作 ThreadB.join()并成功返回，那么线程 B 中的任意操作 happens-before 于线程
A 从 ThreadB.join()操作成功返回。

	int a = 0;
    public void HappenBeforeDemo2(){
        Thread thread = new Thread(() -> {
            a = 5; //1
        });

        thread.start();
        try {
            thread.join(); //2
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(a); //3
    }

上面代码在主线程中调用thread 线程的join方法，那么thread线程的任意操作都HappenBefore与主线程thread.join();后面的代码。也就是1 HappenBefore 3.原因很简单，因为在主线程中调用thread.join();方法，表示就是阻塞住主线程，知道thread线程执行完毕返回才继续向下执行，所以1 HappenBefore 3也算理所当然。

监视器规则

监视器锁的规则， 对一个锁的解锁， happens-before 于随后对这个锁的加锁。

也就是使用synchronized加锁本来就解决来可见性问题。

synchronized (this) { // 此处自动加锁
// x 是共享变量, 初始值 =10
if (this.x < 12) {
this.x = 12;
}
} // 此处自动解锁

假设 x 的初始值是 10，线程 A 执行完代码块后 x 的值会变成 12（执行完自动释放锁），线程 B获取锁 进入代码块时，能够看到线程 A 对 x 的写操作，也就是线程 B 能够看到 x==12。