学妹教你并发编程的三大特性：原子性、可见性、有序性-原创手记-慕课网

在并发编程中有三个非常重要的特性：原子性、有序性,、可见性，学妹发现你对它们不是很了解，她很着急，因为理解这三个特性对于能够正确地开发高并发程序有很大的帮助，接下来的面试中也极有可能被问到，小学妹就忍不住开始跟你逐一介绍起来。

Java内存模型

在讲三大特性之前先简单介绍一下Java内存模型（Java Memory Model，简称JMM），了解了Java内存模型以后，可以更好地理解三大特性。

Java内存模型是一种抽象的概念，并不是真实存在的，它描述的是一组规范或者规定。JVM运行程序的实体是线程，每一个线程都有自己私有的工作内存。Java内存模型中规定了所有变量都存储在主内存中，主内存是一块共享内存区域，所有线程都可以访问。但是线程对变量的读取赋值等操作必须在自己的工作内存中进行，在操作之前先把变量从主内存中复制到自己的工作内存中，然后对变量进行操作，操作完成后再把变量写回主内存。线程不能直接操作主内存中的变量，线程的工作内存中存放的是主内存中变量的副本。

原子性（Atomicity）

什么是原子性

原子性是指：在一次或者多次操作时，要么所有操作都被执行，要么所有操作都不执行。

一般说到原子性都会以银行转账作为例子，比如张三向李四转账100块钱，这包含了两个原子操作：在张三的账户上减少100块钱；在李四的账户上增加100块钱。这两个操作必须保证原子性的要求，要么都执行成功，要么都执行失败。不能出现张三的账户减少100块钱而李四的账户没增加100块钱，也不能出现张三的账户没减少100块钱而李四的账户却增加100块钱。

原子性示例

示例一

i = 1;

根据上面介绍的Java内存模型，线程先把i=1写入工作内存中，然后再把它写入主内存，就此赋值语句可以说是具有原子性。

示例二

i = j;

这个赋值操作实际上包含两个步骤：线程从主内存中读取j的值，然后把它存入当前线程的工作内存中；线程把工作内存中的i改为j的值，然后把i的值写入主内存中。虽然这两个步骤都是原子性的操作，但是合在一起就不是原子性的操作。

示例三

i++;

这个自增操作实际上包含三个步骤：线程从主内存中读取i的值，然后把它存入当前线程的工作内存中；线程把工作内存中的i执行加1操作；线程再把i的值写入主内存中。和上一个示例一样，虽然这三个步骤都是原子性的操作，但是合在一起就不是原子性的操作。

从上面三个示例中，我们可以发现：简单的读取和赋值操作是原子性的，但把一个变量赋值给另一个变量就不是原子性的了；多个原子性的操作放在一起也不是原子性的。

如何保证原子性

在Java内存模型中，只保证了基本读取和赋值的原子性操作。如果想保证多个操作的原子性，需要使用synchronized关键字或者Lock相关的工具类。如果想要使int、long等类型的自增操作具有原子性，可以用java.util.concurrent.atomic包下的工具类，如：AtomicInteger、AtomicLong等。另外需要注意的是，volatile关键字不具有保证原子性的语义。

可见性（Visibility）

什么是可见性

可见性是指：当一个线程对共享变量进行修改后，另外一个线程可以立即看到该变量修改后的最新值。

可见性示例

package onemore.study;

import java.text.SimpleDateFormat;
import java.util.Date;

public class VisibilityTest {
    public static int count = 0;

    public static void main(String[] args) {
        final SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss.SSS");

        //读取count值的线程
        new Thread(() -> {
            System.out.println("开始读取count...");
            int i = count;//存放count的更新前的值
            while (count < 3) {
                if (count != i) {//当count的值发生改变时，打印count被更新
                    System.out.println(sdf.format(new Date()) + " count被更新为" + count);
                    i = count;//存放count的更新前的值
                }
            }
        }).start();

        //更新count值的线程
        new Thread(() -> {
            for (int i = 1; i <= 3; i++) {
                //每隔1秒为count赋值一次新的值
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(sdf.format(new Date()) + " 赋值count为" + i);
                count = i;

            }
        }).start();
    }
}

在运行代码之前，先想一下运行的输出是什么样子的？在更新count值的线程中，每一次更新count以后，在读取count值的线程中都会有一次输出嘛？让我们来看一下运行输出是什么：

开始读取count...
17:21:54.796 赋值count为1
17:21:55.798 赋值count为2
17:21:56.799 赋值count为3

从运行的输出看出，读取count值的线程一直没有读取到count的最新值，这是为什么呢？因为在读取count值的线程中，第一次读取count值时，从主内存中读取count的值后写入到自己的工作内存中，再从工作内存中读取，之后的读取的count值都是从自己的工作内存中读取，并没有发现更新count值的线程对count值的修改。

如何保证可见性

在Java中可以用以下3种方式保证可见性。

使用`volatile`关键字

当一个变量被volatile关键字修饰时，其他线程对该变量进行了修改后，会导致当前线程在工作内存中的变量副本失效，必须从主内存中再次获取，当前线程修改工作内存中的变量后，同时也会立刻将其修改刷新到主内存中。

使用`synchronized`关键字

synchronized关键字能够保证同一时刻只有一个线程获得锁，然后执行同步方法或者代码块，并且确保在锁释放之前，会把变量的修改刷新到主内存中。

使用`Lock`相关的工具类

Lock相关的工具类的lock方法能够保证同一时刻只有一个线程获得锁，然后执行同步代码块，并且确保执行Lock相关的工具类的unlock方法在之前，会把变量的修改刷新到主内存中。

有序性（Ordering）

什么是有序性

有序性指的是：程序执行的顺序按照代码的先后顺序执行。

在Java中，为了提高程序的运行效率，可能在编译期和运行期会对代码指令进行一定的优化，不会百分之百的保证代码的执行顺序严格按照编写代码中的顺序执行，但也不是随意进行重排序，它会保证程序的最终运算结果是编码时所期望的。这种情况被称之为指令重排（Instruction Reordering）。

有序性示例

package onemore.study;

public class Singleton {
    private Singleton (){}

    private static boolean isInit = false;
    private static Singleton instance;

    public static Singleton getInstance() {
        if (!isInit) {//判断是否初始化过
            instance = new Singleton();//初始化
            isInit = true;//初始化标识赋值为true
        }
        return instance;
    }
}

这是一个有问题的单例模式示例，假如在编译期或运行期时指令重排，把isInit = true;重新排序到instance = new Singleton();的前面。在单线程运行时，程序重排后的执行结果和代码顺序执行的结果是完全一样的，但是多个线程一起执行时就极有可能出现问题。比如，一个线程先判断isInit为false进行初始化，本应在初始化后再把isInit赋值为true，但是因为指令重排没后初始化就把isInit赋值为true，恰好此时另外一个线程在判断是否初始化过，isInit为true就执行返回了instance，这是一个没有初始化的instance，肯定造成不可预知的错误。

如何保证有序性

这里就要提到Java内存模型的一个叫做先行发生（Happens-Before）的原则了。如果两个操作的执行顺序无法从Happens-Before原则推到出来，那么可以对它们进行随意的重排序处理了。Happens-Before原则有哪些呢？

程序次序原则：一段代码在单线程中执行的结果是有序的。
锁定原则：一个锁处于被锁定状态，那么必须先执行unlock操作后面才能进行lock操作。
volatile变量原则：同时对volatile变量进行读写操作，写操作一定先于读操作。
线程启动原则：Thread对象的start方法先于此线程的每一个动作。
线程终结原则：线程中的所有操作都先于对此线程的终止检测。
线程中断原则：对线程interrupt方法的调用先于被中断线程的代码检测到中断事件的发生。
对象终结原则：一个对象的初始化完成先于它的finalize方法的开始。
传递原则：操作A先于操作B，操作B先于操作C，那么操作A一定先于操作C。

除了Happens-Before原则提供的天然有序性，我们还可以用以下几种方式保证有序性：

使用volatile关键字保证有序性。
使用synchronized关键字保证有序性。
使用Lock相关的工具类保证有序性。

总结

原子性：在一次或者多次操作时，要么所有操作都被执行，要么所有操作都不执行。
可见性：当一个线程对共享变量进行修改后，另外一个线程可以立即看到该变量修改后的最新值。
有序性：程序执行的顺序按照代码的先后顺序执行。

synchronized关键字和Lock相关的工具类可以保证原子性、可见性和有序性，volatile关键字可以保证可见性和有序性，不能保证原子性。