假设您有一个像这样的简单类:

class MyClass
{
    private readonly int a;
    private int b;

    public MyClass(int a, int b) { this.a = a; this.b = b; }

    public int A { get { return a; } }
    public int B { get { return b; } }
}

我可以以多线程方式使用这个类:

MyClass value = null;
Task.Run(() => {
    while (true) { value = new MyClass(1, 1); Thread.Sleep(10); }
});
while (true)
{
    MyClass result = value;
    if (result != null && (result.A != 1 || result.B != 1)) { 
        throw new Exception(); 
    }
    Thread.Sleep(10);
}

我的问题是:我会看到这个(或其他类似的多线程代码)抛出异常吗？我经常看到其他线程可能不会立即看到非 volatile 写入这一事实。因此，这似乎可能会失败，因为对值字段的写入可能发生在对 a 和 b 的写入之前。这是可能的，还是内存模型中有什么东西可以使这个(非常常见的)模式安全？如果是这样，它是什么？ readonly 为此目的是否重要？如果 a 和 b 是不能以原子方式编写的类型(例如自定义结构)，这有关系吗？

最佳答案

编写的代码将从 CLR2.0 开始工作，因为 CLR2.0 内存模型保证所有存储都具有释放语义。

释放语义:确保在栅栏之前没有加载或存储 将在栅栏后移动。之后的说明可能还是发生在之前 围栏。(摘自 CPOW 第 512 页)。

这意味着构造函数初始化不能在类引用赋值之后移动。

Joe duffy 在他的 article about the very same subject 中提到了这一点.

Rule 2: All stores have release semantics, i.e. no load or store may move after one.

还有 Vance morrison 的 article here确认相同(第 4 节技术:惰性初始化)。

Like all techniques that remove read locks, the code in Figure 7 relies on strong write ordering. For example, this code would be incorrect in the ECMA memory model unless myValue was made volatile because the writes that initialize the LazyInitClass instance might be delayed until after the write to myValue, allowing the client of GetValue to read the uninitialized state. In the .NET Framework 2.0 model, the code works without volatile declarations.

从 CLR 2.0 开始，写入保证按顺序发生。它没有在 ECMA 标准中指定，它只是 CLR 的微软实现提供了这种保证。如果您在 CLR 1.0 或任何其他 CLR 实现中运行此代码，您的代码可能会中断。

此更改背后的故事是:(来自 CPOW 第 516 页)

When the CLR 2.0 was ported to IA64, its initial development had happened on X86 processors, and so it was poorly equipped to deal with arbitrary store reordering (as permitted by IA64) . The same was true of most code written to target .NET by nonMicrosoft developers targeting Windows

The result was that a lot of code in the framework broke when run on IA64, particularly code having to do with the infamous double-checked locking pattern that suddenly didn't work properly. We'll examine this in the context of the pattern later in this chapter. But in summary, if stores can pass other stores, consider this: a thread might initialize a private object's fields and then publish a reference to it in a shared location; because stores can move around, another thread might be able to see the reference to the object, read it, and yet see the fields while they are still i n an uninitialized state. Not only did this impact existing code, it could violate type system properties such as initonly fields.

So the CLR architects made a decision to strengthen 2.0 by emitting all stores on IA64 as release fences. This gave all CLR programs stronger memory model behavior. This ensures that programmers needn' t have to worry about subtle race conditions that would only manifest in practice on an obscure, rarely used and expensive architecture.

注意 Joe duffy 说他们通过将 IA64 上的所有存储作为发布栅栏发出来加强 2.0 这并不意味着其他处理器可以对其重新排序。其他处理器本身固有地提供了存储存储(存储后跟存储)不会被重新排序的保证。所以 CLR 不需要明确保证这一点。

关于c# - 为什么(或不是)在构造函数中设置字段是线程安全的？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/29146200/