Java并发编程：JMM (Java内存模型) 以及与volatile关键字详解

计算机系统的一致性

在现代计算机操做系统中，多任务处理几乎是一项必备的功能，由于嵌入了多核处理器，计算机系统真正作到了同一时间执行若干个任务，是名副其实的多核系统。在多核系统中，为了提高CPU与内存的交互效率，通常都设置了一层 “高速缓存区” 做为内存与处理器之间的缓冲，使得CPU在运算的过程当中直接从高速缓存区读取数据，必定程度上解决了性能的问题。可是，这样也带来了一个新问题，就是“缓存一致性”的问题。好比，多核的状况下，每一个处理器都有本身的缓存区，数据如何保持一致性。针对这个问题，现代的计算机系统引入多处理器的数据一致性的协议，包括MOSI、Synapse、Firely、DragonProtocol等。

当处理器经过高速缓存区与主内存发生交互时，对数据的读写必须遵循协议规定的标准，用一张关系图表示的话大概以下：

而Java的内存模型 (JMM) 能够说与硬件的一致性模型很类似，采用的是共享内存的线程通讯机制。

Java内存模型

Java内存模型规定了全部的变量都存储在主内存中，每一个线程拥有本身的工做内存，工做内存中保存了被该线程使用的变量的主内存副本拷贝，线程只能操做本身工做内存的变量副本，操做完变量后会更新到主内存，经过主内存来完成与其余线程间变量值的传递。此模型的交互关系以下图所示：

然而，Java的内存模型只是反映了虚拟机内部的线程处理机制，并不保证程序自己的并发安全性。

举一个例子，在程序中对一个共享变量作自增操做：

i++；
复制代码

假设初始化的时候i=0，当跑到此程序时，线程首先从主内存读取i的值，而后复制到本身的工做内存，进行i++操做，最后将操做后的结果从工做内存复制到主内存中。若是是两个线程执行i++的程序，预期的结果是2。但真的是这样吗？答案是否认的。

假设线程1读取主内存的i=0，复制到本身的工做内存，在进行i++的操做后还没来得及更新到主内存，这时线程2也读取i=0，作了一样的操做，那么最终获得的结果为1，而不是2。

这是典型的关于多线程并发安全例子，也是Java并发编程中最值得探讨的话题之一，通常来讲，处理这种问题有两种手段：

• 加锁，好比同步代码块的方式。保证同一时间只能有一个线程能执行i++这条程序。
• 利用线程间的通讯，好比使用对象的wait和notify方法来。

由于本文主要是探究 JMM 和 volatile 关键字的知识，具体怎么实现并发处理就不作深刻探讨了，改天看看抽个时间再写篇博文专门讲解好了。

内存模型的3个重要特征

初步了解完什么是JMM后，咱们来进一步了解它的重要特征。值得说明的是，在Java多线程开发中，遵循着三个基本特性，分别是原子性、可见性和有序性，而Java的内存模型正是围绕着在并发过程当中如何处理这三个特征创建的。

原子性

原子性是指操做是原子性的，不可中断的。举个例子：

String s="abc";
复制代码

这个操做是直接赋值，是原子性操做。而相似下面这段代码就不是原子性了：

i++;
复制代码

当执行i++时，须要先获取i的值，而后再执行i+1，至关于包含了两个操做，因此不是原子性。

可见性

可见性是指共享数据的时候，一个线程修改了数据，其余线程知道数据被修改，会从新读取最新的主存的数据。就像前面说的两个线程处理i++的问题，线程1改完后没有更新到主内存，因此线程2是不知道的。

有序性

是指代码执行的有序性，对于一个线程执行的代码，咱们能够认为代码是依次执行的，但并发中可能就会出现乱序，由于代码有可能发生指令重排序（Instruction Reorder），重排后的指令与原指令的顺序未必一致。

指令重排序

编译器可以自由的以优化的名义去改变指令顺序。在特定的环境下，处理器可能会次序颠倒的执行指令。是为指令的重排序，尤为是并发的状况下。

java提供了volatile和synchronized来保证线程之间操做的有序性。volatile含有禁止指令重排序的语义(即它的第二个语义)，synchronized规定一个变量在同一时刻只容许一条线程对其lock操做，也就是说同一个锁的两个同步块只能串行进入。禁止了指令的重排序。

volatile关键字

说到了volatile，咱们就有必要了解一下这个关键字是作什么的。

准确来讲，volatile是java提供的轻量的同步机制。它有两个特性：

1. 保证修饰的变量对全部线程的可见性。
2. 禁止指令的重排序优化。

保证可见性和防止指令重排

简单写段代码说明一下：

public class VolatileDemo {
    
    private static boolean isReady;
    private static int number;
    
    private static class ReaderThread extends Thread{
        @Override
        public void run() {
            while (!isReady);
            System.out.println("number = "+number);
        }
    }

    public static void main(String[] args) {
        new ReaderThread().start();
        try {
            Thread.sleep(1000);
            number = 42;
            isReady = true;
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
复制代码

在上面的代码中，ReaderThread只有在isReady 为 true 时才会打印出 number 的值，然而，真实的状况有多是打印不出来(可能性比较小，但仍是有)，由于线程ReaderThread线程没法看到主线程中对isReady的修改，致使while循环永远没法退出，同时，由于有可能发生指令重排，致使下面的代码不能按顺序执行：

number = 42;
isReady = true;
复制代码

也就是能打印的话，number值多是0，不是42。若是在变量加上volatile关键字，告诉Java虚拟机这两个变量可能会被不一样的线程修改，那么就能够防止上述两种不正常的状况的发生。

不能保证原子性

volatile能保证可见性和有序性，但没法保证原子性，好比下面的例子：

public class VolatileDemo {

    public static volatile int i = 0;

    public static void increase() {
        i++;
    }

    public static void main(String[] args) throws InterruptedException {
        VolatileDemo test = new VolatileDemo();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++)
                    test.increase();
            }).start();
        }      
        Thread.sleep(1000);
        System.out.println(test.i);
    }
}
复制代码

正常状况下，咱们指望上面的main函数执行完后输出的结果是10000，但你会发现，结果老是会小于10000，由于increase()方法中的i++操做不是原子性的，分红了读和写两个操做。假设当线程1读取了 i 的值，尚未修改，线程2这时也进行了读取。而后，线程1修改完了，通知线程2从新读取 i 的值，可这时它不须要读取 i，它仍执行写操做，而后赋值给主线程，这时数据就会出现问题。

因此，通常针对共享变量的读写操做，仍是须要用锁来保证结果，例如加上 synchronized关键字。

参考：

《Java高并发程序设计》

《深刻理解Java虚拟机》