何为内存重排序？

前言

咱们知道对于咱们所编写的代码经过计算机如何顺序执行以源代码编写的指令，程序只是处理器自上而下执行的文本文件中列出的操做列表，其实这是错误的理解，计算机可以根据须要更改某些低级操做的顺序，尤为是在读取和写入内存时，出于性能缘由，会进行内存重排序，内存重排序是一种利用指令来进行对应操做，经过这种操做极大地提升了程序的速度，可是，另外一方面，它可能对无锁多线程形成严重破坏性，本节咱们来分析何为重排序。

何为重排序

程序被加载到主内存中以便执行，CPU的任务是运行存储在其中的指令，并在必要时读取和写入数据，那么具体CPU具体是如何操做的呢？获取指令、解码从主存储器中加载全部所需数据的指令、执行指令、将生成的结果写回并存储到主内存中。现代CPU可以每纳秒执行十条指令，可是须要数十纳秒才能从主内存中获取一些数据，与处理器相比，这种类型的内存变得很是慢，为了减小加载和存储操做中的延迟，所以操做系统为CPU配备了一个很小但又很是快的特殊内存块，称为缓存，因此CPU将使用寄存器-缓存，高速缓存是处理器存储其最常使用的数据的地方，以免与主内存的缓慢交互，当处理器须要读取或写入主内存时，它首先检查该数据的副本在其本身的缓存中是否可用，若是是这样，则处理器直接读取或写入高速缓存，而没必要等待较慢的主内存响应，现代的CPU由多个内核组成—执行实际计算的组件，每一个内核都有本身的缓存块，该缓存块又链接到主内存，以下图所示：

具体地说，解码模块能够具备一个派遣队列，在该队列中，提取的指令将保留，直到其请求的数据从主内存加载到缓存中或它们的从属指令完成为止，当一些指令正在等待（或停顿）时，就绪的指令会同时解码并下推到管道中，若是旧数据还没有在高速缓存中，则回写模块会将存储请求放入存储缓冲区中（高速缓存控制器按高速缓存行存储和加载数据，每条高速缓存行一般大于单个内存访问），并开始处理下一条独立指令。在将旧数据放入缓存后，或者若是它已经在缓存中，指令将使用新结果覆盖缓存，最终，新数据将最终根据不一样的策略异步刷新到主内存（例如，当必须从高速缓存中为新的高速缓存行或与其余数据一块儿以批处理方式处理数据时），总而言之，经过加入缓存使计算机运行速度更快， 或者说它可使处理器始终保持忙碌和高效的状态，从而帮助处理器因等待主内存响应避免浪费没必要要的时间。 

 

很显然，这种缓存机制会增长多核操做系统复杂性，有了缓存咱们将须要详细的规则来肯定数据如何在不一样的缓存之间流动，也就是使得各个缓存副本中的数据一致性以此确保每一个内核都具备最新的版本，它们被称为缓存一致性协议（高速缓存一致性是最重要的问题，它因为增长了芯片多处理器上的内核数量以及将在这些处理器上运行的共享内存程序而迅速影响了多核处理器的性能。 “窥探协议”和“基于目录的协议”是用于实现缓存之间一致性的两种协议，这些协议的主要目的是实现多核处理器的高速缓存中数据值的一致性和验证，以便经过任何高速缓存读取存储器地址都将返回写入该地址的最新数据），可能会致使巨大的性能损失，所以，操做系统则使用内存重排序技巧，以充分利用每一个内核，内存从新排序可能有几个缘由，例如，考虑两个被指令访问主内存中相同数据块的内核，内核A从内存中读取，内核B对其进行写入，可能会迫使内核A等待，而内核B将其本地缓存的数据写回到主内存中，以便内核A能够读取到最新信息，等待中的内核可能会选择提早运行其余内存指令，而不是浪费宝贵的时间而不作任何事情，启用某些优化后，编译器和虚拟机也能够自由地从新排序指令，这些更改在编译时发生，能够经过查看汇编代码或字节码知道，软件内存重排序以利用基础硬件可能提供的任何功能，只是为了使代码运行更快。咱们来看以下代码：

class ReadWriteDemo {
    int A = 0;
    boolean B = false;

    //CPU1 (thread1) runs this method
    void writer() {
        A = 10;  
        B = true;
    }

    //CPU2 (thread2) runs this method
    void reader() {
        while (!B)
            continue;
        System.out.println(A == 10);
    }
}

编写上述代码后，咱们会假设write方法将在reader方法执行以前完成，在理想状况下这种假设正确无疑，可是，若是使用CPU寄存器的缓存和缓冲，这种假设将多是错误的，例如，若是字段B已经在高速缓存中，而A不在，则B能够早于A存入主内存，即便A和B都在高速缓存中，B仍有可能早于A存入主内存或者A从主内存中先加载到B以前或者A在B存储前加载以前等相似多种可能性结果，简而言之，将语句在原始代码中的排序方式称为程序顺序，单个内存引用（加载或存储）完成的顺序称为执行顺序，因为CPU高速缓存，缓冲区和推测性执行在指令完成时间上增长了太多的异步性，所以执行顺序不必定与其程序顺序相同，这就是CPU中执行重排序的方式。若是程序是单线程或者方法writer中的字段A和B仅由一个线程访问，咱们实际上并不用关心重排序，由于方法writer中的两个存储区是独立的，即便两个存储被重排序。可是，若是程序为多线程，那么可能须要考虑执行顺序，例如，CPU1执行方法writer，而CPU2执行方法reader，因为线程使用共享的主内存进行通讯，而且因为CPU缓存一致性协议，缓存对访问是透明的，所以当从内存中加载数据时，若是从未从任何CPU加载过数据，则从主内存中获取，若是该CPU拥有数据，则为来自另外一个CPU的高速缓存，若是拥有数据，则为来自其自身的高速缓存，若是CPU1无序执行方法writer，则上述打印出false，即便CPU1按照程序顺序执行了方法writer，打印结果仍有可能为false，由于CPU2能够在执行while语句时以前执行打印结果，由于从逻辑上讲，在完成while语句以后才应该打印结果（这称为控制依赖），可是，CPU2能够自由地先推测性地执行打印结果，通常来说，当CPU看到诸如if或while语句之类的分支时，直到该分支指令完成以前，它才知道在哪里获取下一条指令，可是，若是它等待分支指令而又找不到足够的独立指令，则会下降CPU性能，所以，CPU1能够根据其预测推测性地执行打印结果，稍后能够批准其预测路径正确时，它将提交执行，在reader方法状况下，这意味着在打印结果以后，CPU1在while语句中找到了B == true，因为CPU并不知道咱们关心A和B的执行顺序，所以必须使用所谓的内存屏障来告知它们顺序必须使用同步构造以强制执行的排序语义。若是两个CPU都引用相同的内存位置，说明它们具备数据依赖性，则没有一个CPU将对存储的给定操做进行重排序，不然将违反程序语义，基于以上分析，咱们得出结论：单线程程序在顺序化语义as-if-serial下运行，重排序的效果仅对多线程程序可见（或者一个线程中的从新排序仅对其余线程可见/对其余线程很重要），当CPU本质上执行给不了咱们实际想要的排序语义时，程序必须使用同步机制。

指令调度说明 

只要编译器不违反程序语义（这里的编译指代的是JIT编译器）就能够自由地根据其优化对代码进行物理或逻辑从新排序，现代编译器具备许多强大的代码转换，以下：

public class Main {
    public static void main(String[] args) {

        int A = 10;
        int B = A + 10;
        int C = 20;
    }
}

假设编译器经过复杂的分析发现A不在缓存中，而C在缓存中，所以，A=10将触发多周期的数据加载，而C=20则能够在单个周期内完成，编译器能够直接跳过对A=10和B=A+10进行赋值操做而执行C=20，以将停顿减小1，若是编译器能够找到更多独立的指令，则能够经过减小更多的停顿来进行相同的重排序。由上述咱们知道在单核计算机上，硬件内存的重排序并非问题，线程是操做系统控制的软件结构，CPU仅接收连续的存储指令流，它们仍然能够重排序，可是要遵循一个基本规则：给定内核的内存访问在该内核中彷佛是在程序中编写的，所以，可能会发生内存重排序，但前提是它不会破坏最终结果。接下来咱们再来看一个例子（源于java并发实战）

public class UnsafeLazyInitialization {
    private static Resource resource;

    public static Resource getInstance() {
        if (resource == null)
            resource = new Resource();
        return resource;
    }
}

如上使用先检查后操做模式实例化Resource，不用多讲，颇有可能两个线程能够在该方法中同时到达，都将resource视为null并初始化变量。这里还涉及到咱们上一节所讲解的部分初始化对象问题，致使对象没法正确安全发布，当咱们初始化一个对象具体会进行5步操做：分配内存、建立对象、使用默认值初始化字段（好比int、boolean等）、运行构造函数、将对象的引用分配给变量，可是这里在进行第4步操做以前就运行第5步操做，因此getInstance方法将返回一个非空但不一致的对象（具备未初始化字段）的引用。可是上述方法也颇有可能返回null，由于JMM对此容许， 要了解为何这样作是可行的，咱们须要详细分析读写，并评估它们之间是否存在事先发生联系（happens-before），咱们将上述代码进行以下重写，以清楚地显示读取和写入：

 

在此示例中，容许21和24都遵照10或13，而且合法执行了该程序，假设线程1看到resource为空并对其进行了初始化，线程2看到x不为空，应该会实例化Resource，可是结果可能返回null的resource，这是为什么呢？前面咱们讲解过CPU缓存一致性协议，当线程1执行实例化Resource时，此时须要写入到主内存，同时线程2恰好要获取resource将进行等待，为了解决缓存一致性引发的等待问题，JIT经过指令进行重排序，接下来将跳过实例化resource并写入，直接返回resource，此时结果就为null。咱们将重排序操做改形成以下，相信能更好理解一点

public class UnsafeLazyInitialization {
    private static Resource resource;

    public static Resource getInstance() {
        Resource temp = resource;
        if (resource == null) 
            resource = temp = new Resource(); 
        return temp; 
    }
}

经过声明一个Resource的临时变量temp，此时在线程1和线程2都为null，接下来将在线程1中为null，而在线程2中不为null，由于它已由线程1初始化，最终线程1返回实例，而线程2返回null。

总结

本节咱们详细讲解了重排序的概念以及引入重排序的缘由，下一节咱们进入到内存模型，感谢您的阅读，咱们下节见。