探讨并发编程的三大特性：原子性、可见性、有序性

神仙姐姐带你了解并发的三大特性！！！撸起袖子干吧！！！！！

1 Java内存模型

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

2 原子性（Atomicity）[ˌætəˈmɪsəti]

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

2.1 示例一:

i = 1;

线程先把i=1写入工作内存中，然后再把它写入主内存，就此赋值语句可以说是具有原子性。

2.2 示例二:

i = j;

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

2.3 示例三:

i++;

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

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

2.4 如何保证原子性

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

3 可见性（Visibility） [ˌvɪzəˈbɪləti]

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

package com.zs.thread;

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

public class SemaphoreTester {
    public static int count = 0;
    public static void main(String[] args) {
        final SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");

        //读取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值的线程一直没有读取到count的最新值，这是为什么呢？因为在读取count值的线程中，第一次读取count值时，从主内存中读取count的值后写入到自己的工作内存中，再从工作内存中读取，之后的读取的count值都是从自己的工作内存中读取，并没有发现更新count值的线程对count值的修改。

3.1 如何保证可见性

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

3.1.1 使用volatile关键字

...
public volatile static int count = 0;
...

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

3.1.2 使用synchronized关键字

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

package com.zs.thread;

public class SemaphoreTester {
    private static boolean isOver = false;
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            while (!isOver){}
            System.out.println("thread stopping...");
        });
        thread.start();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        isOver = true;
        System.out.println("main ----- true");
    }
}

执行上面这段代码,只会打印出“main ----- true”然后一直死循环阻塞。原因是当主线程把变量isOver修改为true，值的修改作用范围仅仅是当前线程内（主线程）。另外的线程并没有读取主线程修改后的值。

package com.zs.thread;

public class SemaphoreTester {
    private static boolean isOver = false;
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            synchronized (SemaphoreTester.class) {
                while (!isOver){
                    try {
                        SemaphoreTester.class.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("thread stopping...");
            }
        });
        thread.start();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized (SemaphoreTester.class) {
            isOver = true;
            SemaphoreTester.class.notify();
        }
        System.out.println("main ----- true");
    }
}

3.1.3 使用Lock相关的工具类

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

4 有序性（Ordering）

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

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

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，肯定造成不可预知的错误。

4.1 如何保证有序性

这里就要提到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关键字可以保证可见性和有序性，不能保证原子性。