如何锁定语句确保内部处理器同步？ [英] How does the lock statement ensure intra processor synchronization?
问题描述
我能同时执行两个线程一个小的测试应用程序。其中增加一个静态长_value ，另一个递减它。我已经确保了与 ProcessThread.ProcessorAffinity 的线程不同的物理（无HT）内核相关迫使处理器内部通信，我已经确保他们在执行时间上重叠的一个显著的时间量
I have a small test application that executes two threads simultaneously. One increments a static long _value, the other one decrements it. I've ensured with ProcessThread.ProcessorAffinity that the threads are associated with different physical (no HT) cores to force intra processor communication and I have ensured that they overlap in execution time for a significant amount of time.
当然，以下不会导致零：
Of course, the following does not lead to zero:
for (long i = 0; i < 10000000; i++)
{
_value += offset;
}
因此，合乎逻辑的结论将是：
So, the logical conclusion would be to:
for (long i = 0; i < 10000000; i++)
{
Interlocked.Add(ref _value, offset);
}
这当然会导致零。
Which of course leads to zero.
但是，以下也导致零：
for (long i = 0; i < 10000000; i++)
{
lock (_syncRoot)
{
_value += offset;
}
}
当然，锁定语句保证了读取和写入，没有重新排序，因为它采用了全栅栏。但是，我找不到有关处理器的高速缓存同步的任何信息。如果不会有任何缓存同步，我想我应该会看到偏离0两个线程都结束后？
Of course, the lock statement ensures that the reads and writes are not reordered because it employs a full fence. However, I cannot find any information concerning synchronization of processor caches. If there wouldn't be any cache synchronization, I'd think I should be seeing deviation from 0 after both threads were finished?
有人能向我解释如何锁定 / Monitor.Enter /退出确保处理器缓存（ L1 / L2缓存）同步？
Can someone explain to me how lock/Monitor.Enter/Exit ensures that processor caches (L1/L2 caches) are synchronized?
推荐答案
在这种情况下，高速缓存一致性不依赖于锁定。如果你使用锁定语句它确保你的汇编指令不混合。
A + = B 不是原子处理器，它看起来像：
Cache coherence in this case does not depend on lock. If you use lock statement it ensures that your assembler commands are not mixed.
a += b is not an atomic to processor, it looks like:
- 在加载数据到寄存器从内存
- 增量数据
- 在存储数据传回
和无锁可能是：
- 在将数据加载到寄存器X从内存
- 在将数据加载到寄存器Y从内存
- 在增量数据（X）
- 在递减数据（Y）
- 在存储数据备份（从x）
- 在存储数据备份（从Y）//在这种情况下，增量都将丢失。
但它不是关于高速缓存一致性，这是一个更高层次的功能。
But it's not about cache coherence, it's a more high-level feature.
因此，锁定不保证缓存同步。高速缓存同步是处理器内部的功能，它不依赖于code。你可以阅读一下这里。
So, lock does not ensures that the caches are synchronized. Cache synchronization is a processor internal feature which does not depend on code. You can read about it here.
在一个核心将值写入内存，然后在第二个核心尝试读取值时，它不会在其缓存的实际拷贝，除非其高速缓存项将失效，从而发生缓存失配。而这个缓存未命中的力量缓存条目进行更新，以实际值。
When one core writes a value to memory and then when the second core try to read that value it won't have the actual copy in its cache unless its cache entry is invalidated so a cache miss occurs. And this cache miss forces cache entry to be updated to actual value.
这篇关于如何锁定语句确保内部处理器同步？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
