深入理解Java内存模型的语义_JAVA_编程开发_程序员俱乐部

### 前言
Java内存模型（JMM）给我们介绍了在当代不同的硬件架构情况下，多线程程序需要关注什么问题以及如何利用JMM来正确的处理这些问题。

### 多线程带来的问题

多线程程序主要关注两个问题：

（1）共享变量可见性问题

（2）代码重排序一致性问题


### Java内存模型的关键点
JMM已经保证了as-if-serial原则，也就是Java的程序在单线程情况下，不管JIT做不做重排序，也不管代码指令在几个CPU上执行，看到的最终结果必须和代码顺序执行的结果保持一致。

但是在多线程的情况下，如何才能正确的处理的变量可见性问题和重排序的一致性问题？

关键在于理解和运用下面的两块内容：

（1）happens-before相关

（2）data race相关

### 关于Memory Consistency Errors
Memory Consistency Errors中文含义是：**内存一致性错误**，指的的是多线程环境下，对于同一个共享变量的值在不同的线程看到的视图不一致。

伪代码如下：

class="java" name="code">```
int counter = 0;
```

此时A线程正在执行：

```
counter++;
```

然后过了几秒后，B线程打印这个值：

```
System.out.println(counter);
```

此时B线程的打印结果很大可能是0，但A线程里面其实这个值已经是1了，这就是典型的内存一致性错误。这情况种只能通过happens-before规则来避免。



### 关于happens-before
happens-before是JMM里面保证在一个线程里面执行的action（读或者写）的结果，可以在随后的其他线程里面立马可见的一系列规则。比如 x happens-before y ，那么不管x和y是不是在同一个线程里面，JMM都会保证对于x的update都会立马里面对y线程可见，也就是x总会先于y执行，前提是两者必须有happens-before关系，否则就会出现上面的内存一致性错误的问题。

如何建立happens-before关系？ 这里面有几条规则：

（1） 单线程中的程序执行结果与代码的顺序执行结果保持一致。

你能会好奇，难道单线程不是顺序执行的吗？ 答案是的确不一定按照顺序执行，这个跟硬件的指令重排序有关，目的是为了优化性能让cpu更快的执行指令，但有happens-before保证，所以结果跟代码顺序执行的结果保持一致，这是最基础的保证，也是最重要的保证。

（2）同一个锁的unlock操作，在其他线程lock后，变量是可见的。

```
class LockRule {
    private int value = 0;
    
    public synchronized void setValue(int value) {
        this.value = value;
    }
    
    public synchronized int getValue() {
        return value;
    }
}
```

也就是在A线程中执行setValue操作，在B线程中执行getValue方法是可以看到变化的，注意这里一定是同一个监视器才可以，比如上面这段代码就是用对象做为监视器。此外ReentrantLock锁也具有相同的语义。

（3）volatile修饰的变量，在一个线程update后，立刻对其他的线程可见。这个不多说，前面的文章介绍过。

（4）关于Thread的start方法，是指在一个线程A中启动另外另外一个线程B时，A里面所有的变量对B是可见的，最常见的就是我们在java的main线程中启动的线程是可以看到启动之前所有的main线程的变量的。底层是启动前把所有内容都同步到主内存里面了，然后新的线程会从主内存里面拷贝一份数据到自己的cache，所以是可见的。

（5）关于Thread的join方法，同样道理，比如我在java的main线程里面声明了一个线程B，然后调用
B.start() //启动B线程
B.join() //main线程等待B线程结束
此时在B线程里面修改了成员变量，在B线程结束的时候，main线程是可以直接看到最终变化的。这是一个线程结束的时候会把自己缓存的值给刷新到主内存，所以感知了B线程结束的主线程是可以看到所有变化的。

(6)关于Thread的interrupt方法，同样道理，在java的main线程中，比如我在java的main线程里面声明了一个线程B，然后调用
B.start() //启动B线程
B.interrupt() //打断B线程，此时B线程的是可以看到主线程的修改的状态

（7）对于实例的finalize()方法，当实例的构造方法执行完毕之后，如果再执行finalize()方法，此时实例里面的所有变量不管有多少线程修改过对finalize()方法都是可见的。

（8）传递性规则： 如果 A happens-before B 并且 B happens-before C, 那么 A happens-before C




### 关于data race

data race又叫数据竞争，在这里指的多个线程之间没有符合的happens-before规则，但是它们又需要修改同一个共享变量，比如上面的counter的例子，最终会造成内存一致性的问题，这种情况下可以通过Java自带的一些锁机制来避免。

### 关于上篇文章遗留问题

在上篇文章中，我遗留了一个问题，那就在下面的代码中：

```
    private  static boolean  keepRunning=true;

    public static void main(String[] args)  throws Exception {

        new Thread(
                ()->{

                    while (keepRunning){
                        //System.out.println();
                    }
                }

        ).start();

        Thread.sleep(1000);
        keepRunning=false;

    }
```

如果我把while循环里面的打印语句去掉，那么即使没有volatile关键字，程序也可以结束循环，为什么？ 其实答案就在今天的知识里面，因为打印语句会锁住当前的实例，源码如下：

```
    public void println(boolean x) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }
```

对应到上面的happens-before的第二条规则就很容易的解释通了。



### 总结

本篇文章主要介绍了Java内存模型主要描述的问题以及解决多线程环境下的问题思路，我们了解和学习了什么是内存一致性错误，happens-before的规则，数据竞争的内容，掌握了这些知识将非常有助于我们深入到Java并发编程的世界，希望大家可以有所收获。