如果你使用的是。net 1.1，在进行双重检查锁定时需要volatile关键字。为什么?因为在。net 2.0之前，下面的场景可能会导致第二个线程访问一个非空的，但还没有完全构造的对象:

线程1询问变量是否为空。 / /如果(这一点。Foo == null) 线程1确定变量为空，因此进入一个锁。 / /锁(this.bar) 线程1再次询问变量是否为空。 / /如果(这一点。Foo == null) 线程1仍然确定变量为空，因此它调用一个构造函数并将值赋给变量。 / /这个。foo = new foo ();

在。net 2.0之前，这个。在构造函数完成运行之前，foo可以被分配给foo的新实例。在这种情况下，第二个线程可以进来(在线程1调用Foo的构造函数期间)，并经历以下情况:

线程2询问变量是否为空。 / /如果(这一点。Foo == null) 线程2确定变量为非空，因此尝试使用它。 / / this.foo.MakeFoo ()

在. net 2.0之前，您可以声明这一点。Foo是不稳定的来解决这个问题。从。net 2.0开始，您不再需要使用volatile关键字来完成双重检查锁定。

维基百科上有一篇关于双重检查锁定的好文章，简要地提到了这个话题: http://en.wikipedia.org/wiki/Double-checked_locking

我认为没有比Eric Lippert更好的人来回答这个问题了(在原文中强调):

In C#, "volatile" means not only "make sure that the compiler and the jitter do not perform any code reordering or register caching optimizations on this variable". It also means "tell the processors to do whatever it is they need to do to ensure that I am reading the latest value, even if that means halting other processors and making them synchronize main memory with their caches". Actually, that last bit is a lie. The true semantics of volatile reads and writes are considerably more complex than I've outlined here; in fact they do not actually guarantee that every processor stops what it is doing and updates caches to/from main memory. Rather, they provide weaker guarantees about how memory accesses before and after reads and writes may be observed to be ordered with respect to each other. Certain operations such as creating a new thread, entering a lock, or using one of the Interlocked family of methods introduce stronger guarantees about observation of ordering. If you want more details, read sections 3.10 and 10.5.3 of the C# 4.0 specification. Frankly, I discourage you from ever making a volatile field. Volatile fields are a sign that you are doing something downright crazy: you're attempting to read and write the same value on two different threads without putting a lock in place. Locks guarantee that memory read or modified inside the lock is observed to be consistent, locks guarantee that only one thread accesses a given chunk of memory at a time, and so on. The number of situations in which a lock is too slow is very small, and the probability that you are going to get the code wrong because you don't understand the exact memory model is very large. I don't attempt to write any low-lock code except for the most trivial usages of Interlocked operations. I leave the usage of "volatile" to real experts.

欲进一步阅读，请参阅:

理解低锁技术在多线程应用中的影响 再见不稳定

综上所述，这个问题的正确答案是: 如果代码在2.0运行时或更高版本中运行，volatile关键字几乎不需要，如果不必要地使用，弊大于利。也就是说，永远不要用它。但是在运行时的早期版本中，需要对静态字段进行适当的双重检查锁定。特别是具有静态类初始化代码的静态字段。

CLR喜欢优化指令，所以当你在代码中访问一个字段时，它可能并不总是访问该字段的当前值(它可能来自堆栈等)。将字段标记为volatile可以确保该指令可以访问该字段的当前值。当程序中的并发线程或操作系统中运行的其他代码可以修改该值(在非锁定场景中)时，这很有用。

您显然失去了一些优化，但它确实使代码更加简单。

我发现Joydip Kanjilal的这篇文章非常有用!

当您将一个对象或变量标记为volatile时，它将成为volatile读写的候选对象。需要注意的是，在c#中，所有的内存写操作都是volatile的，不管你写的是volatile对象还是非volatile对象。但是，当读取数据时，就会出现这种不确定性。当读取非易失性数据时，执行线程可能总是获得最新的值，也可能不总是。如果对象是volatile，线程总是获得最新的值

我就把它放在这里，供大家参考

如果你使用的是。net 1.1，在进行双重检查锁定时需要volatile关键字。为什么?因为在。net 2.0之前，下面的场景可能会导致第二个线程访问一个非空的，但还没有完全构造的对象:

线程1询问变量是否为空。 / /如果(这一点。Foo == null) 线程1确定变量为空，因此进入一个锁。 / /锁(this.bar) 线程1再次询问变量是否为空。 / /如果(这一点。Foo == null) 线程1仍然确定变量为空，因此它调用一个构造函数并将值赋给变量。 / /这个。foo = new foo ();

在。net 2.0之前，这个。在构造函数完成运行之前，foo可以被分配给foo的新实例。在这种情况下，第二个线程可以进来(在线程1调用Foo的构造函数期间)，并经历以下情况:

线程2询问变量是否为空。 / /如果(这一点。Foo == null) 线程2确定变量为非空，因此尝试使用它。 / / this.foo.MakeFoo ()

在. net 2.0之前，您可以声明这一点。Foo是不稳定的来解决这个问题。从。net 2.0开始，您不再需要使用volatile关键字来完成双重检查锁定。

维基百科上有一篇关于双重检查锁定的好文章，简要地提到了这个话题: http://en.wikipedia.org/wiki/Double-checked_locking