在一男子给对象转账5000元，居然又退还了！和我就站在你面前，你却视而不见！文中，我们学习了线程安全的原子性和可见性，这篇文章就来说说有序性。

有序性

首先还是来看下概念，有序性就是指代码按照编写顺序执行。

大家可能会有疑问，难道还会出现乱序执行吗？

因为编译器为了程序性能，可能会改变代码中语句的先后顺序，也就是指令重排序。比如：

String name = "wupx";
Integer age = 18;

编译器优化后可能变成：

Integer age = 18;
String name = "wupx";

在上述的情况中，指令重排序对运行结果没有什么影响，但是指令重排序的优化只能保证单线程程序中是线程安全的。

如果在并发环境下，是不能保证有序性的，这就引出了有序性问题：

有序性问题

下面通过一个双重校验获取单例对象的例子，让大家了解下：

public class Singleton {
    private static Singleton instance; 
 
    public static Singleton getSingleton() {
        if (instance == null) {                         
            synchronized (Singleton.class) {
                if (instance == null) {       
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

这段代码的意思大致就是：首先判断 instance 是不是为空，如果为空，则进入同步代码块并进行再次判空操作，不然直接返回 instance。在同步代码块中再次判断 instance 是否为空，若仍然为空，则创建 Singleton 的实例 instance，其中第二次判空是为了避免了在进入同步代码块时间段内有线程已经创建了 Singleton 的实例。

哇，一个完美的单例模式的实现就完成了，其实并不是，因为代码中的 instance = new Singleton(); 这一行代码对应的 CPU 指令是三个：

1. 为 instance 分配一块内存 M
2. 在内存 M 上初始化 Singleton 对象
3. 内存 M 的地址赋值给 instance 变量

但是由于编译器做的指令重排序的优化（可以看出不是代码层面的重排序，是指令层面的重排序），这些命令可能会变成：

1. 为 instance 分配一块内存 M
2. 内存 M 的地址赋值给 instance 变量
3. 在内存 M 上初始化 Singleton 对象

不要小瞧编译器做的小动作，我们现在来举例分析下，比如：

1. Thread-0 先执行 getSingleton() 方法，当执行到第 2 条指令的时候，发生了线程切换，切换到了 Thread-1
2. Thread-1 也执行 getSingleton() 方法，首先判断 instance 是否为空
3. 此时 Thread-0 已经为 instance 分配一块内存 M，并把地址赋值给 instance 变量
4. 因此，Thread-0 在第一个判断 instance == null 的时候，会判断 instance 不为空，直接返回 instance
5. 线程切换到 Thread-0，在内存 M 上初始化 Singleton 对象

如果在第 5 步没有执行完之前，Thread-1 获取到了一个未初始化的 instance，如果在这个时间段内访问 instance 变量，就有可能发生空指针异常（NPE）。

为了方便大家理解，我画个图说明下：

如果要解决这个代码中的有序性问题，可以在 instance 的声明中加上 volatile 关键字，volatile 变量规则是 Happens-Before（先行发生原则） 中的一种：对一个变量的写操作先行发生于后面对这个变量的读操作，因此 volatile 修饰的变量是会保证读操作一定能读到写完的值。

关于 volatile 相关知识，建议阅读：你真的了解 volatile 关键字吗？

在这里再简单介绍下 Happens-Before 规则，Happens-Before 限制了编译器的优化行为，就是要求编译器优化后一定遵守 Happens-Before 规则，我的个人理解就是先前的操作的结果对之后的操作是可见的。

Happens-Before 包括如下规则：

1. 程序次序规则：一个线程内，按照代码顺序，书写在前面的操作先行发生于书写在后面的操作​
2. 锁定规则：一个 unlock 操作先行发生于后面对同一个锁的 lock 操作
3. volatie 变量规则：对一个变量的写操作先行发生于后面对这个变量的读操作
4. 传递规则：如果操作 A 先行于发生于操作 B，而 B 又先行发生于操作 C，则可以得出操作 A 先行发生于操作 C
5. 线程启动规则：Thread 对象的 start() 方法先行发生于此线程的每一个动作
6. 线程中断规则：对线程 interrupt() 方法的调用先行发生于被中断线程的代码检测到中断事件的发生
7. 线程终结规则：线程中所有的操作都先行发生于线程的终止检测，我们可以通过 Thread.join() 方法结束、Thread.isAlive() 的返回值手段检测到线程已经终止执行
8. 对象终结规则：一个对象的初始化完成先行发生于他的 finalize() 方法的开始

总结

这篇文章，我们一起学习了有序性，并了解了在并发环境下编译器指令重排序优化带来的有序性问题，并在最后简单介绍了 Happens-Before 原则。

到此为止，可见性、原子性、有序性就全部讲解完了，欢迎大家留言讨论，分享你的想法。

最好的关系就是互相成就，大家的在看、转发、留言三连就是我创作的最大动力。

参考

《深入理解Java虚拟机：JVM高级特性与最佳实践》

《实战Java高并发程序设计》

Java并发编程实战