多线程基础(四)：volatile和可见性问题及happens-before原则

[toc]

在前文中知道了synchronized的使用，以及java内存模型JMM的基本构成。那么现在，我们来看一个新的问题。

1.可见性问题

我们来看看下面这段代码：

package com.dhb.concurrent.test;

import java.util.concurrent.TimeUnit;

public class VolatileTest {

    private static int INIT = 0;
    private static int MAX = 10;

    public static void main(String[] args) {

        new Thread(() -> {
            int local = INIT;
            while (local < MAX) {
                if (local != INIT) {
                    System.out.println("Get change for INIT [" + INIT + "] local is [" + local + "]");
                    local = INIT;
                }
            }
        }, "Reader Thread").start();

        new Thread(() -> {
            int local = INIT;
            while (local < MAX) {
                System.out.println("Update value [" + local + "] to [" + (local++) + "]");
                INIT = local;
                try {
                    TimeUnit.MILLISECONDS.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "Writer Thread").start();
    }

}

有两个线程，一个线程写入，另外一个线程读取，那么写入线程的结果，每次都能被读取线程读到吗？我们执行上述代码：

Update value [0] to [0]
Get change for INIT [1] local is [0]
Update value [1] to [1]
Update value [2] to [2]
Update value [3] to [3]
Update value [4] to [4]
Update value [5] to [5]
Update value [6] to [6]
Update value [7] to [7]
Update value [8] to [8]
Update value [9] to [9]

可以看到，在写入线程将INIT结果递增的过程中，读取线程只读到了第一次的值。之后无论写入线程对INIT的值如何改变，在读取线程中，这个值任然是之前的结果，也就是写入线程增加的值，对读取线程实际上是不可见的。这就是我们今天需要介绍的重点，可见性问题。

读不可见

如上图,每个线程实际上都是在自身的工作内存中操作的变量的副本，如果这个副本被修改之后，则会同步回主内存。因此Writer每次都将结果写入到主内存的INIT中去。但是对于Reader线程，只会在读取之后进行比较的时候读取一次，此时的值为1,那么在此之后，这个值就不会被修改了，而是一直将这个值放在该线程的工作内存中。这就是可见性问题产生的原因。实际上就是，由于Reader线程只是读取，内部只有use操作，因此不会assign，那么也就没有必要每次都从主内存中去加载这个变量。这样设计的初衷是为了增加JVM内存计算的效率，因为工作内存可能实际的部分在CPU的高速缓存中进行计算，如果每次都从主内存中加载，由于高速缓存和主内存的速度相差很大，那么就会导致不必要的系统开销。
那么我们应该怎么解决这个问题呢。这就是本文需要介绍的重点关键字，volatile。这个关键字有两个作用：

保持内存可见性
静止指令重排序
我们先来说内存的可见性。volatile是如何保持内存的可见性呢？很简单，实际上如果某个变量被volatile修饰的话，那么在工作内存中，就不再走工作内存的缓存了，而是每次都去主内存去加载。这样一来，虽然带来了一些性能的损耗，但是这样可以更好的解决系统的一致性。

读可见

如上图，这样一来，Reader线程的工作内存中在对INIT的读取的时候，每次都会从主内存中去同步。这样Writer线程对主内存的修改，对Reader线程来说，就是可见的了。我们修改代码如下：

public class VolatileTest {

    private volatile static int INIT = 0;
    private static int MAX = 10;

    public static void main(String[] args) {

        new Thread(() -> {
            int local = INIT;
            while (local < MAX) {
                if (local != INIT) {
                    System.out.println("Get change for INIT [" + INIT + "] local is [" + local + "]");
                    local = INIT;
                }
            }
        }, "Reader Thread").start();

        new Thread(() -> {
            int local = INIT;
            while (local < MAX) {
                System.out.println("Update value [" + local + "] to [" + (local++) + "]");
                INIT = local;
                try {
                    TimeUnit.MILLISECONDS.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "Writer Thread").start();
    }

}

执行结果：

Update value [0] to [0]
Get change for INIT [1] local is [0]
Update value [1] to [1]
Get change for INIT [2] local is [1]
Update value [2] to [2]
Get change for INIT [3] local is [2]
Update value [3] to [3]
Get change for INIT [4] local is [3]
Update value [4] to [4]
Get change for INIT [5] local is [4]
Update value [5] to [5]
Get change for INIT [6] local is [5]
Update value [6] to [6]
Get change for INIT [7] local is [6]
Update value [7] to [7]
Get change for INIT [8] local is [7]
Update value [8] to [8]
Get change for INIT [9] local is [8]
Update value [9] to [9]
Get change for INIT [10] local is [9]

这样reader线程每次都能读到最新的INIT的值了。

2.指令重排序

我们来看下面这个例子：

package com.dhb.concurrent.test;

public class VolatileTest2 {

    static int a,b,x,y;

    public static void main(String[] args) {
        long time = 0;
        while (true) {
            time ++;
            a = 0;
            b = 0;
            x = 0;
            y = 0;
            Thread t1 = new Thread(() -> {
                a = 1;
                x = b;
            });
            Thread t2 = new Thread(() -> {
                b = 1;
                y = a;
            });
            t1.start();
            t2.start();
            try {
                t1.join();
                t2.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            if( x==0 && y==0) {
                break;
            }
        }
        System.out.println("time:["+time+"] x:["+x+"] y:["+y+"]");
    }
}

对于指令重排序，如果在一个线程中，两条语句之间彼此没有任何关系，那么在jvm内部对指令进行优化的时候，就可以出现，写在后面的语句被优化到前面执行的情况。在这个例子中， a=1、x=b 这是两条没有任何关系的语句，同样，在另外一个线程中b=1、y=a也如此。这些语句彼此间没有先后关系。而在传统的逻辑中，这两种组合，无论哪个线程先执行或者同时执行，都不会出现x=0,y=0的情况。

执行情况	结果
t1先于t2执行	x=0,y=1
t2先于t1执行	x=1,y=0
t1、t2同时执行	x=1,y=1

只有当出现指令重排序，x=a，y=b先于a=1,b=1执行，那么才可能出现x=0,y=0的情况。
我们执行上述代码：

time:[102946] x:[0] y:[0]

这个指令重排序不是一个必然事件，因此这个代码每次执行的结果都不一样：

time:[8943] x:[0] y:[0]

如果运气好可能很快就会出现这个结果。
这就是指令重排序问题。那么volatile的另外一个作用就是能够禁止指令重排序，这种情况就不会产生。这也是一个比较常见的面试问题，DCL的单例模式需要加volatile的的原因。

3.synchronized与可见性

在JMM中，关于synchronized有两条规定：

线程解锁之前，必须把共享变量的最新值刷新到主内存中。
线程加锁的时候，将清空工作内存中的共享变量的值，从而使共享变量需要从主内存中重新获取最新的值。（加锁与解锁是同一个锁）

由此可见，synchronized，实际上也能实现可见性。此外，synchronized使用的是同步锁，还具有原子性。
再回到前文的例子中，我们将这个程序改造为如下方式：

package com.dhb.concurrent.test;

import java.util.concurrent.TimeUnit;

public class SyncTest {

    private static Count count = new Count();
    private static int MAX = 10;

    public static void main(String[] args) {

        new Thread(() -> {
            int local = count.getCount();
            while (local < MAX) {
                synchronized (count) {
                    if (local != count.getCount()) {
                        System.out.println("Get change for INIT [" + count.getCount() + "] local is [" + local + "]");
                        local = count.getCount();
                    }
                }
            }
        }, "Reader Thread").start();

        new Thread(() -> {

            int local = count.getCount();
            while (local < MAX) {
                synchronized (count) {
                    System.out.println("Update value [" + local + "] to [" + (++local) + "]");
                    count.setCount(local);
                }
                try {
                    TimeUnit.MILLISECONDS.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }, "Writer Thread").start();


    }

    private static class Count {
        int count = 0;

        public int add() {
            return ++count;
        }

        public int getCount() {
            return count;
        }

        public void setCount(int count) {
            this.count = count;
        }
    }

}

之后我们再来看执行结果：

Update value [0] to [1]
Get change for INIT [1] local is [0]
Update value [1] to [2]
Get change for INIT [2] local is [1]
Update value [2] to [3]
Get change for INIT [3] local is [2]
Update value [3] to [4]
Get change for INIT [4] local is [3]
Update value [4] to [5]
Get change for INIT [5] local is [4]
Update value [5] to [6]
Get change for INIT [6] local is [5]
Update value [6] to [7]
Get change for INIT [7] local is [6]
Update value [7] to [8]
Get change for INIT [8] local is [7]
Update value [8] to [9]
Get change for INIT [9] local is [8]
Update value [9] to [10]
Get change for INIT [10] local is [9]

这样通过synchronized也能很好的解决可见性问题。由于synchronized在1.8中已经做了很多优化，其性能与ReentrantLock的性能无差别，因此，只要不涉及到指令的重排序，通过synchronized也能很好的完成可见性的效果。

加锁可见

如上图所示，在加锁之后，每次读写的时候都需要从主内存中刷新同步。

4.Happens-Before规则

在《深入理解Java虚拟机》一书中，对Happens-Before原则进行了归纳，主要是以下8个：

1.程序次序规则：在同一线程内部，按照代码顺序，关联代码书写在前面的操作优先发生于书写在后面的操作。
2.管程锁定规则：一个unlock操作优先发生于此后对同一个锁的lock操作。
3.volatile变量规则：对一个变量的写操作优先发生于后面对这个变量的读操作。（时间先后）
4.线程启动规则：Thread的start方法优先发生于此线程的每一个动作。
5.线程终结规则：线程中所有操作都优先发生于线程的终止检测，我们可以通过Thread.join()、Thread.isAlive()返回值等手段进行检测。
6.线程中断规则：对线程interrupt()方法的调用先行发生于被中断线程的代码检测到事件的发生。
7.对象终结规则：一个对象的初始化完成先于发生他的finalize()方法的开始。
8.传递性规则：如果操作A对操作B可见，而操作B又对操作C可见，则可以得出操作A对操作C也可见。
如何来理解这些Happens-Before规则呢？Happens-Before并不是说，前一个操作发生在后续操作的前面。而是要表达，前面一个操作的结果对后续操作是可见的。
实际上，Happens-Before对编译器的行为进行了约束，编译器可以根据需要多代码的执行顺序进行优化，但是，编译器的这种优化一定要遵守Happens-Before规则。

5.对Happens-Before的理解

5.1 程序次序规则

需要注意的是，对于这个规则，一jvm在优化的时候，如果书写的代码之间没有任何的依赖关系，那么就不符合这个规则了。
如下代码：

int a = 3;     //代码1
int b = a + 1; //代码2

由于存在依赖关系，因此代码1的结果对代码2永远都是可见的。

int a = 3; //代码1
int b = 2; //代码2

那么上面这个代码，就不会有次序关系了，JVM指令会根据需要进行优化。优化之后的顺序就不一定了。可能是先执行代码1，也可能是先执行代码2。

5.2 管程锁定规则

这个规则很好理解，也就是说，在需要对一个锁进行加锁的时候，其上面的unlock操作一定是先执行的。

5.3 volatile变量规则

如果变量被volatile修饰，那么对这个变量的写操作，一定会被其后的所有读操作可见。
这也是本文前面的例子所证明的这一点。

public class VolatileTest {

    private volatile static int INIT = 0;
    private static int MAX = 10;

    public static void main(String[] args) {

        new Thread(() -> {
            int local = INIT;
            while (local < MAX) {
                if (local != INIT) {
                    System.out.println("Get change for INIT [" + INIT + "] local is [" + local + "]");
                    local = INIT;
                }
            }
        }, "Reader Thread").start();

        new Thread(() -> {
            int local = INIT;
            while (local < MAX) {
                System.out.println("Update value [" + local + "] to [" + (local++) + "]");
                INIT = local;
                try {
                    TimeUnit.MILLISECONDS.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "Writer Thread").start();
    }

}

5.4 传递性规则

如果操作A先行发生于操作B，而操作B又先行发生于操作C，则可以得出操作A先行发生于操作C。这有点类似于数学中的传递性规则。如果A>B,B>C，那么A>C。

package com.dhb.concurrent.test;

public class VolatileExample {

    static  int x = 0;
    static volatile boolean v = false;

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            x = 42;
            v = true;
        });

        Thread t2 = new Thread(() -> {
            if(v == true){
                System.out.println(x);
            }else {
                System.out.println(x);
            }
        });

        t1.start();
        t2.start();
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在上述例子中，如果t1一定会在前面执行的话，那么根据传递性规则，该结果输出一定是42。