请看下面的代码并尝试猜测输出：

可能一看下面的代码你可能会放弃继续看了，但如果你想要彻底弄明白volatile，你需要耐心,下面的代码很简单！

在下面的代码中，我们定义了4个字段x，y，a和b，它们被初始化为0
然后，我们创建2个分别调用Test1和Test2的任务，并等待两个任务完成。
完成两个任务后，我们检查a和b是否仍为0，
如果是，则打印它们的值。
最后，我们将所有内容重置为0，然后一次又一次地运行相同的循环。

using System;
using System.Threading;
using System.Threading.Tasks;

namespace MemoryBarriers
{
    class Program
    {
        static volatile int x, y, a, b;
        static void Main()
        {
            while (true)
            {
                var t1 = Task.Run(Test1);
                var t2 = Task.Run(Test2);
                Task.WaitAll(t1, t2);
                if (a == 0 && b == 0)
                {
                    Console.WriteLine("{0}, {1}", a, b);
                }
                x = y = a = b = 0;
            }
        }

        static void Test1()
        {
            x = 1;
           // Interlocked.MemoryBarrierProcessWide();
            a = y;
        }

        static void Test2()
        {
            y = 1;
            b = x;
        }
    }

如果您运行上述代码（最好在Release模式下运行），则会看到输出为0、0的许多输出，如下图。

我们先根据代码自我分析下

在Test1中，我们将x设置为1，将a设置为y，而Test2将y设置为1，将b设置为x
因此这4条语句会在2个线程中竞争
罗列下可能会发生的几种情况：

1. Test1先于Test2执行：

x = 1
a = y
y = 1
b = x

在这种情况下，我们假设Test1在Test2之前完成，那么最终值将是

x = 1，a = 0，y = 1，b = 1

2. Test2执行完成后执行Test1：

y = 1 
b = x
x = 1
a = y

在这种情况下，那么最终值将是

x = 1，a = 1，y = 1，b = 0

2. Test1执行期间执行Test2：

x = 1
y = 1
b = x
a = y

在这种情况下，那么最终值将是

x = 1，a = 1，y = 1，b = 1

3. Test2执行期间执行Test1

y = 1
x = 1
a = y
b = x

在这种情况下，那么最终值将是

x = 1，a = 1，y = 1，b = 1

4. Test1交织Test2

x = 1
y = 1
a = y
b = x

在这种情况下，那么最终值将是

x = 1，a = 1，y = 1，b = 1

5.Test2交织Test1

y = 1
x = 1
b = x
a = y

在这种情况下，那么最终值将是

x = 1，a = 1，y = 1，b = 1

我认为上面已经罗列的
已经涵盖了所有可能的情况，
但是无论发生哪种竞争情况，
看起来一旦两个任务都完成，
就不可能使a和b都同时为零，
但是奇迹般地，居然一直在打印0,0 (请看上面的动图，如果你怀疑的话代码copy执行试试)

真相永远只有一个

先揭晓答案：cpu的乱序执行。

让我们看一下Test1和Test2的IL中间代码。
我在相关部分中添加了注释。

#ConsoleApp9.Program.Test1()
    #function prolog ommitted
    L0015: mov dword ptr [rax+8], 1   # 把值 1 上传到内存地址 'x'
    L001c: mov edx, [rax+0xc]         # 从内存地址 'y' 下载值并放到edx(寄存器)
    L001f: mov [rax+0x10], edx.       # 从(edx)寄存器把值上传到内存地址 'a'
    L0022: add rsp, 0x28.           
    L0026: ret

#ConsoleApp9.Program.Test2()
    #function prolog
    L0015: mov dword ptr [rax+0xc], 1  # 把值 1 上传到内存地址 'y'
    L001c: mov edx, [rax+8].           # 从内存地址 'x' 下载值并放到edx(寄存器) 
    L001f: mov [rax+0x14], edx.        # 从(edx)寄存器把值上传到内存地址 'b'
    L0022: add rsp, 0x28
    L0026: ret

请注意，我在注释中使用“上载”和“下载”一词，而不是传统的读/写术语。
为了从变量中读取值并将其分配到另一个存储位置，
我们必须将其读取到CPU寄存器（如上面的edx），
然后才能将其分配给目标变量。
由于CPU操作非常快，因此与在CPU中执行的操作相比，对内存的读取或写入真的很慢。
所以我使用“上传”和“下载”，相对于CPU的高速缓存而言【读取和写入内存的行为】
就像我们向远程Web服务上载或从中下载一样慢。

以下是各项指标(2020年数据)（ns为纳秒）

L1 cache reference: 1 ns
L2 cache reference: 4 ns
Branch mispredict: 3 ns
Mutex lock/unlock: 17 ns
Main memory reference: 100 ns
Compress 1K bytes with Zippy: 2000 ns
Send 2K bytes over commodity network: 44 ns
Read 1 MB sequentially from memory: 3000 ns
Round trip within same datacenter: 500,000 ns
Disk seek: 2,000,000 ns
Read 1 MB sequentially from disk: 825,000 ns
Read 1 MB sequentially from SSD: 49000 ns

由此可见 访问主内存比访问CPU缓存中的内容慢100倍

如果让你开发一个应用程序，实现上载或者下载功能。
您将如何设计此？肯定想要开多线程，并行化执行以节省时间！
这正是CPU的功能。CPU被我们设计的很聪明，
在实际运行中可以确定某些“上载”和“下载”操作(指令)不会互相影响，
并且CPU为了节省时间，对它们(指令)进行了(优化)并行处理，
也叫【cpu乱序执行】（out-of-order）

上面我说道：在实际运行中可以确定某些“上载”和“下载”操作(指令)不会互相影响，
这里有一个前提条件哈：该假设仅基于基于线程的依赖性检查进行（per-thread basis dependency checks）。
虽然在单个线程是可以被确定为指令独立性，但CPU无法考虑多个线程的情况，所以提供了【volatile关键字】

我们回到上面的示例，尽管我们已将字段标记为volatile，但感觉上没有起作用。为什么？

一般说道volatile我都一般都会举下面的例子(内存可见性)

using System;
using System.Threading;
public class C {
    bool completed;
    static void Main()
    {
      C c = new C();
      var t = new Thread (() =>
      {
        bool toggle = false;
        while (!c.completed) toggle = !toggle;
      });
      t.Start();
      Thread.Sleep (1000);
      c.completed = true;
      t.Join();        // Blocks indefinitely
    }
}

如果您使用release模式运行上述代码，它也会无限死循环。
这次CPU没有罪，但罪魁祸首是JIT优化。

你如果把：

bool completed;

改成

volatile bool completed;

就不会死循环了。
让我们来看一下[没有加volatile]和[加了volatile]这2种情况的IL代码：

没有加volatile

L0000: xor eax, eax
L0002: mov rdx, [rcx+8]
L0006: movzx edx, byte ptr [rdx+8]
L000a: test edx, edx
L000c: jne short L001a
L000e: test eax, eax 
L0010: sete al
L0013: movzx eax, al
L0016: test edx, edx # <-- 注意看这里
L0018: je short L000e
L001a: ret

加了volatile

L0000: xor eax, eax
L0002: mov rdx, [rcx+8]
L0006: cmp byte ptr [rdx+8], 0
L000a: jne short L001e
L000c: mov rdx, [rcx+8]
L0010: test eax, eax
L0012: sete al
L0015: movzx eax, al
L0018: cmp byte ptr [rdx+8], 0  <-- 注意看这里
L001c: je short L0010
L001e: ret

留意我打了注释的那行。上面的这些IL代码行 实际上是代码进行检查的地方：

        while (!c.completed)

当不使用volatile时，JIT将完成的值缓存到寄存器(edx)，然后仅使用edx寄存器的值来判断(while (!c.completed))。
但是，当我们使用volatile时，将强制JIT不进行缓存，
而是每次我们需要读取它直接访问内存的值 (cmp byte ptr [rdx+8], 0)

JIT缓存到寄存器 是因为 发现了 内存访问的速度慢了100倍以上，就像CPU一样，JIT出于良好的意图，缓存了变量。
因此它无法检测到别的线程中的修改。
volatile解决了这里的问题，迫使JIT不进行缓存。

说完可见性了我们在来说下volatile的另外一个特性：内存屏障

1. 确保在执行下一个上传/下载指令之前，已完成从volatile变量的下载指令。

2. 确保在执行对​​volatile变量的当前上传指令之前，完成了上一个上传/下载指令。

但是volatile并不禁止在完成上一条上传指令之前完成对volatile变量的下载指令。
CPU可以并行执行并可以继续执行任何先执行的操作。
正是由于volatile关键字无法阻止，所以这就是这里发生的情况：

mov dword ptr [rax+0xc], 1  # 把值 1 上传到内存地址 'y'
mov edx, [rax+8].           # 从内存地址 'x' 下载值并放到edx(寄存器) 

变成这个

mov edx, [rax+8].           # 从内存地址 'x' 下载值并放到edx(寄存器)
mov dword ptr [rax+0xc], 1  # 把值 1 上传到内存地址 'y'

因此，由于CPU认为这些指令是独立的，因此在y更新之前先读取x，同理在Test1方法也是会发生x更新之前先读取y。
所以才会出现本文例子的坑~~！

如何解决？

输入内存屏障 内存屏障是对CPU的一种特殊锁定指令，它禁止指令在该屏障上重新排序。因此，该程序将按预期方式运行，但缺点是会慢几十纳秒。

在我们的示例中，注释了一行代码：

   //Interlocked.MemoryBarrierProcessWide();

如果取消注释该行，程序将正常运行~~~~~

总结

平常我们说volatile一般很容易去理解它的内存可见性，很难理解内存屏障这个概念，内存屏障的概念中对于volatile变量的赋值，
volatile并不禁止在完成上一条上传指令之前完成对volatile变量的下载指令。这个在多线程环境下一定得注意！