c# - 如何在不锁定的情况下读取这个原始实例线程安全？

Question

以下类的问题是在读取 myThreadSafe.Value 时它可能不会返回最新的值。

public class ThreadSafe
{   
    private int value;
    public int Value { get { return value; } }

    public void Update()
    {
        Interlocked.Add(ref value, 47); // UPDATE: use interlocked to not distract from the question being asked.
    }
}

我意识到我可以在读取和写入时锁定:

public int Value { get { lock(locker) return value; } }

public void Update()
{
    lock(locker)
    {
        value += 47;        
    }
}

我一直遵循这种使用锁的模式。然而，我正在尝试减少我代码中的锁的数量(有很多，它们被频繁调用，我已经分析过并且 Montior.Enter() 占用了比我想要的更多的时间 - 因为它被调用了很多次)。

更新:我现在想知道锁是否真的会在确保我读取最新值方面有任何不同，它仍然可能来自机器的 CPU 缓存之一不能它？ (所有锁保证都是互斥线程访问)。

我认为 volatile 会是答案，MSDN确实说:“这确保了字段中始终存在最新的值”，但是我读了 elsewhere写入然后读取 CPU 指令在使用 volatile 时仍然可以交换，在这种情况下，我可以获得 myThreadSafe.Value 的先前值也许我可以接受 - 只是出局了一个更新。

让我始终获得 myThreadSafe.Value 的最新值的最有效方法是什么？

更新:此代码将在 CPU 架构上编译和运行:

• x86
• AMD64(尽管我可以构建为 x86)
• PowerPC
• ARM(仅限小端)

使用运行时:

• CLR v4.0
• Mono(我不确定 mono 运行时版本，但如果它们对应于 Mono 版本:至少 3.0)。

我希望对所有构建使用相同的代码!

Answer 1

好的，我相信我找到了答案，我的担心是正确的!

代码恰好在 x86 和 AMD64 上是线程安全的，因为它们在写入变量时使 CPU 缓存无效，导致后续读取从内存中读取变量。引用 Shafqay Ahmed quoting杰弗里·里希特:

Since two processors can have different caches, which are copies of the ram, they can have different values. In x86 and x64 processors (according to Jeffrey’s book) are designed to sync the caches of different processors so we may not see the problem.

顺便使用lock 和Interlocked 从缓存中刷新变量，因此在读取属性时使用lock 是安全的。来自 http://blogs.msdn.com/b/ericlippert/archive/2011/06/16/atomicity-volatility-and-immutability-are-different-part-three.aspx :

Locks guarantee that memory read or modified inside the lock is observed to be consistent, locks guarantee that only one thread accesses a given hunk of memory at a time, and so on.

但是，在读取由另一个线程(不使用锁定同步结构)更新的值时，CLR 规范不保证是最新的。事实上，在 ARM 上，我可以使用 ThreadSafe 类从 http://msdn.microsoft.com/en-us/magazine/jj553518.aspx 中获得旧值。 :

If your code relies on lock-free algorithms that depend on the implementation of the x86 CLR (rather than the ECMA CLR specification), you’ll want to add the volatile keyword to relevant variables as appropriate. Once you’ve marked shared state as volatile, the CLR will take care of everything for you. If you’re like most developers, you’re ready to run on ARM because you’ve already used locks to protect your shared data, properly marked volatile variables and tested your app on ARM.

所以看起来答案是我可以在阅读时使用lock或者让我的字段volatile，虽然也许我应该使用lock并尝试减少调用次数，作为一个从事编译器工作的人says :

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.