我已经研究了这个主题相当长的时间，我认为我理解了最重要的概念，例如发布和获取内存屏障。
然而，我还没有找到一个令人满意的解释关于volatile和主存缓存之间的关系。
我明白每次读取和写入与volatile字段相关的数据时，都会强制执行其前后的读取和写入操作的严格顺序（读取-获取和写入-释放）。但是这仅仅保证了操作的顺序。它并未说明其他线程/处理器何时可以看到这些更改。特别是这依赖于缓存刷新的时间（如果有的话）。我记得曾经看过Eric Lippert的评论，大意是“volatile字段的存在会自动禁用缓存优化”之类的话。但我不确定这具体意味着什么。这是否意味着只要我们在某个地方有单个的volatile字段，整个程序的缓存就会被完全禁用？如果不是，那么缓存被禁用的粒度是多少？
此外，我了解了一些关于强和弱volatile语义的内容，以及C#遵循强语义的情况，在这种情况下，每次写入都会直接到达主存储器，无论它是volatile字段还是非volatile字段。所有这些让我感到非常困惑。
volatile操作到底会发生什么？volatile读具有获取语义，它在任何后续内存引用之前。volatile写具有释放语义，它在任何先前的内存引用之后。
获取锁执行volatile读取，释放锁执行volatile写入。
Interlocked操作具有获取和释放语义。
还有一个重要的术语需要学习，那就是原子性。
对于32位架构上的基本值和64位架构上的基本值，无论是否为volatile，读取和写入都保证是原子的。对于引用，它们也保证是原子的。对于其他类型，例如长结构体，操作不是原子的，可能需要多个独立的内存访问。
然而，即使使用volatile语义，读取-修改-写入操作，例如v += 1或等效的++v（或v++，就副作用而言），也不是原子的。
Interlocked操作保证某些操作的原子性，通常是加法、减法和比较交换（CAS），即如果当前值仍然是某个期望值，则写入某个值。.NET还具有针对64位整数的原子Read(ref long)方法，即使在32位架构上也可以使用。
我将继续将获取语义称为volatile读取，将释放语义称为volatile写入，将二者或其中任何一个称为volatile操作。
所有这些都意味着什么，就是顺序？
volatile读取是一个点，在该点之前，没有内存引用可以跨越，而volatile写入是一个点，在该点之后，没有内存引用可以跨越，这两个点在语言级别和机器级别都是如此。
如果中间没有volatile写入，则非volatile操作可以跨越到以下volatile读取之后，如果中间没有volatile读取，则可以跨越到先前的volatile写入之前。
线程内的volatile操作是顺序的，不能被重新排序。
线程中的volatile操作按照相同的顺序对所有其他线程可见。但是，没有所有线程的volatile操作的总顺序，即如果一个线程执行V1然后执行V2，另一个线程执行V3然后执行V4，则任何具有V1在V2之前和V3在V4之前的顺序都可以被任何线程观察到。在这种情况下，可以是以下任意一个：
也就是说，对于单个执行过程中的任何线程，观察到的副作用可能的顺序都是有效的。没有总排序的要求，因此所有线程观察到单个执行过程中可能的顺序之一。
如何进行同步？
基本上，它归结为这样：同步点是指在一个易失性写入之后发生的易失性读取。
实际上，您必须检测一个线程中的易失性读取是否发生在另一个线程的易失性写入之后 3 。以下是一个基本示例：
public class InefficientEvent
{
private volatile bool signalled = false;
public Signal()
{
signalled = true;
}
public InefficientWait()
{
while (!signalled)
{
}
}
}
InefficientWait()，另一个调用Signal()，并且当后者从Signal()返回时的副作用在前者从InefficientWait()返回时变得可见。var currentValue = Volatile.Read(ref field);
var newValue = GetNewValue(currentValue);
var oldValue = currentValue;
var spinWait = new SpinWait();
while ((currentValue = Interlocked.CompareExchange(ref field, newValue, oldValue)) != oldValue)
{
spinWait.SpinOnce();
newValue = GetNewValue(currentValue);
oldValue = currentValue;
}
SpinLock，你必须真正地针对基于监视器的锁进行分析，因为虽然它们可能使当前线程让出，但它们不会将当前线程置于睡眠状态，类似于SpinWait的使用方式。1.
有一些地方的微软（前）员工和MVP声称写操作具有发布语义：
在我的代码中，我忽略了这个实现细节。我假设非易失性写入不保证可见。
2.
有一个普遍的误解，认为在C＃和/或CLI中允许引入读取操作。
然而，这仅适用于局部参数和变量。
对于静态和实例字段、数组或堆上的任何内容，您不能合理地引入读取操作，因为这样的引入可能会从当前执行线程的角度打破执行顺序，无论是来自其他线程的合法更改还是通过反射进行的更改。
也就是说，您不能将此代码：
object local = field;
if (local != null)
{
// code that reads local
}
变成这样：
if (field != null)
{
// code that replaces reads on local with reads on field
}
表示非易失性访问不能保证可见性
没有表示非易失性访问一定不可见
表示易失性访问会影响非易失性访问的可见性
object local2 = local1;
if (local2 != null)
{
// code that reads local2 on the assumption it's not null
}
变成这样：
if (local1 != null)
{
// code that replaces reads on local2 with reads on local1,
// as long as local1 and local2 have the same value
}
var local = field;
local?.Method()
转换为：
var local = field;
var _temp = local;
(_temp != null) ? _temp.Method() : null
var local = field;
(local != null) ? local.Method() : null
因为你永远无法分辨它们的区别。但是，你不能将其转换为这样：
(field != null) ? field.Method() : null
public class Worker
{
private bool working = false;
private bool stop = false;
public void Start()
{
if (!working)
{
new Thread(Work).Start();
working = true;
}
}
public void Work()
{
while (!stop)
{
// TODO: actual work without volatile operations
}
}
public void Stop()
{
stop = true;
}
}
不能保证Stop()会停止工作线程。微软的.NET实现保证stop=true;是一个可见的副作用，但它不能保证在Work()内对stop的读取不会被省略为以下内容：
public void Work()
{
bool localStop = stop;
while (!localStop)
{
// TODO: actual work without volatile operations
}
}
3.
.NET的volatile同步与Java的volatile同步的一个显著区别是，Java要求您使用相同的volatile位置，而.NET只需要在release（volatile write）之后发生acquire（volatile read）。因此，原则上您可以使用以下代码在.NET中进行同步，但是您无法使用Java中的等效代码进行同步：
using System;
using System.Threading;
public class SurrealVolatileSynchronizer
{
public volatile bool v1 = false;
public volatile bool v2 = false;
public int state = 0;
public void DoWork1(object b)
{
var barrier = (Barrier)b;
barrier.SignalAndWait();
Thread.Sleep(100);
state = 1;
v1 = true;
}
public void DoWork2(object b)
{
var barrier = (Barrier)b;
barrier.SignalAndWait();
Thread.Sleep(200);
bool currentV2 = v2;
Console.WriteLine("{0}", state);
}
public static void Main(string[] args)
{
var synchronizer = new SurrealVolatileSynchronizer();
var thread1 = new Thread(synchronizer.DoWork1);
var thread2 = new Thread(synchronizer.DoWork2);
var barrier = new Barrier(3);
thread1.Start(barrier);
thread2.Start(barrier);
barrier.SignalAndWait();
thread1.Join();
thread2.Join();
}
}
Thread.Sleep(int)需要精确地花费一定的时间。如果是这样，它将正确同步，因为DoWork1执行了一个易失性写操作（release）后，DoWork2执行了一个易失性读操作（acquire）。DoWork2中，您必须从与DoWork1写入的相同易失性字段中读取。是的，volatile 关乎栅栏，而栅栏关乎顺序。
因此何时？不在范围内，实际上是所有层次（编译器、JIT、CPU 等）结合起来的实现细节，
但每个实现都应该对这个问题有一个合理且实用的答案。
volatile的原因。 - Eric Lippert