相关疑难解决方法(0)

Nutshell中的C#4(强烈推荐的btw)使用以下代码来演示MemoryBarrier的概念(假设A和B在不同的线程上运行):

class Foo{
  int _answer;
  bool complete;
  void A(){
    _answer = 123;
    Thread.MemoryBarrier(); // Barrier 1
    _complete = true;
    Thread.MemoryBarrier(); // Barrier 2
  }
  void B(){
    Thread.MemoryBarrier(); // Barrier 3;
    if(_complete){
      Thread.MemoryBarrier(); // Barrier 4;
      Console.WriteLine(_answer);
    }
  }
}

他们提到障碍1和4阻止这个例子写0和障碍2和3提供新鲜度保证:他们确保如果B在A之后运行,读_complete将评估为真.

我不是真的得到它.我想我明白为什么壁垒1和4是必要的:我们不想在写_answer进行优化,并放置在写后_complete(屏障1),我们需要确保_answer没有被缓存(光栅4) .我也认为我理解为什么Barrier 3是必要的:如果A在写完_complete = true之后才运行,B仍然需要刷新_complete以读取正确的值.

我不明白为什么我们需要障碍2!我的一部分说这是因为可能线程2(运行B)已经运行直到(但不包括)if(_complete),因此我们需要确保_complete被刷新.

但是,我不知道这有多大帮助.是不是仍然可以在A 中将_complete设置为true但是B方法会看到_complete的缓存(错误)版本？即,如果线程2运行方法B直到第一个MemoryBarrier之后,然后线程1运行方法A直到_complete = true但没有进一步,然后线程1恢复并测试是否(_complete) - 如果不导致错误 …

我读过很多关于volatile和VoletileRead(ReadAcquireFence)的矛盾信息(msdn,SO等).

我理解那些内存访问重新排序的限制含义 - 我仍然完全混淆的是新鲜度保证 - 这对我来说非常重要.

msdn doc for volatile提及:

(...)这可确保始终在字段中显示最新值.

用于volatile字段的msdn doc提及:

读取volatile字段称为volatile读取.易失性读取具有"获取语义"; 也就是说,保证在指令序列之后发生的任何内存引用之前发生.

VolatileRead的.NET代码是:

public static int VolatileRead(ref int address)
{
    int ret = address;
    MemoryBarrier(); // Call MemoryBarrier to ensure the proper semantic in a portable way.
    return ret;
}

根据msdn MemoryBarrier doc内存屏障阻止重新排序.然而,这似乎对新鲜度没有任何影响 - 对吗？

如何获得新鲜度保证？标记字段volatile与使用VolatileRead和VolatileWrite语义访问它之间有区别吗？我目前正在执行我的性能关键代码,需要保证新鲜度,但读者有时会得到陈旧的价值.我想知道是否标记状态不稳定将使情况不同.

EDIT1:

我正在努力实现的目标 - 保证读者线程将尽可能获得共享变量(由多个编写者编写)的最新值 - 理想情况下不会超过上下文切换或其他可能推迟立即操作的操作的成本写国家.

如果挥发性或更高级别的构造(例如锁定)具有这种保证(是吗？)而不是它们如何实现这一点？

EDIT2:

非常简洁的问题应该是 - 如何在读取过程中尽可能保证新的价值？理想情况下没有锁定(因为不需要独占访问,并且存在高争用的可能性).

从我在这里学到的东西,我想知道这可能是解决方案(求解(？)行标有注释):

private SharedState _sharedState;
private SpinLock _spinLock = new SpinLock(false);

public void Update(SharedState newValue) …

我花了很多周时间在C#4.0中进行多线程编码.但是,有一个问题对我来说仍然没有答案.

我知道volatile关键字阻止编译器将变量存储在寄存器中,从而避免无意中读取过时值.写入在.Net中总是不稳定的,因此任何说明它也避免了stales写入的文档都是多余的.

我也知道编译器优化有些"不可预测".以下代码将说明由于编译器优化而导致的停顿(在VS之外运行发布编译时):

class Test
{
    public struct Data
    {
        public int _loop;
    }

    public static Data data;

    public static void Main()
    {
        data._loop = 1;
        Test test1 = new Test();

        new Thread(() =>
        {
            data._loop = 0;
        }
        ).Start();

        do
        {
            if (data._loop != 1)
            {
                break;
            }

            //Thread.Yield();
        } while (true);

        // will never terminate
    }
}

代码表现如预期.但是,如果我取消注释//Thread.Yield(); 行,然后循环将退出.

此外,如果我在do循环之前放入Sleep语句,它将退出.我不明白.

当然,用volatile来装饰_loop也会导致循环退出(以其显示的模式).

我的问题是:编译器遵循的规则是什么,以确定何时隐含执行易失性读取？为什么我仍然可以通过我认为奇怪的措施退出循环？

编辑

IL代码如图所示(档位):

L_0038: ldsflda valuetype ConsoleApplication1.Test/Data ConsoleApplication1.Test::data
L_003d: ldfld int32 ConsoleApplication1.Test/Data::_loop
L_0042: ldc.i4.1 
L_0043: beq.s L_0038 …

假设我想在线程之间使用布尔状态标志来进行协作取消.(我意识到最好使用一个CancellationTokenSource;这不是这个问题的重点.)

private volatile bool _stopping;

public void Start()
{
    var thread = new Thread(() =>
    {
        while (!_stopping)
        {
            // Do computation lasting around 10 seconds.
        }
    });

    thread.Start();
}

public void Stop()
{
    _stopping = true;
}

问:如果我在另一个线程上调用Start()0s和Stop()3s,那么循环是否保证在当前迭代结束时在10s左右退出？

我见过的绝大多数消息来源表明上述内容应该按预期工作; 见: MSDN ; Jon Skeet ; 布赖恩吉迪恩 ; 马克格拉维尔 ; Remus Rusanu.

但是,volatile只会在读取时生成获取栅栏,并在写入时生成释放栅栏:

易失性读取具有"获取语义"; 也就是说,保证在指令序列之后发生的任何内存引用之前发生.易失性写入具有"释放语义"; 也就是说,保证在指令序列中的写指令之前的任何存储器引用之后发生.(C#规格)

因此,正如Joseph Albahari所观察到的那样,无法保证不会(似乎)交换易失性写入和易失性读取.因此,后台线程可能会在当前迭代结束后继续读取_stopping(即false)的陈旧值.具体地说,如果我Start()在0和Stop()3s …

我一直在阅读,以Full fences防止任何类型的指令重新排序或缓存围栏(通过memoryBarrier)

然后我读到了volatile 哪些会产生"半围栏":

volatile关键字指示编译器在每次从该字段读取时生成一个获取栅栏,并在每次写入该字段时生成一个释放栅栏.

acquire-fence

获取栅栏可防止其他读/写在栅栏前移动;

release-fence

释放栅栏可防止在栅栏后移动其他读/写.

有人可以用简单的英语向我解释这两句话吗？

(围栏在哪里？)

编辑

在这里得到一些答案后 - 我已经制作了一幅可以帮助每个人的图画 - 我想.

http://i.stack.imgur.com/A5F7P.jpg

我试图看看如何应用围栏.

我有这个代码(无限期地阻止):

static void Main()
{
    bool complete = false;
    var t = new Thread(() => {
        bool toggle = false;
        while(!complete) toggle = !toggle;
    });
    t.Start();
    Thread.Sleep(1000);
    complete = true;
    t.Join(); // Blocks indefinitely
}

写作volatile bool _complete;解决了这个问题.

获取围栏:

获取栅栏可防止其他读/写在栅栏前移动;

但是如果我用箭头来说明它? (想想箭头就可以把所有东西推开.)

所以现在 - 代码看起来像:

 var t = new Thread(() => {
            bool toggle = false;
            while( !complete ) 
                    ???????     // instructions can't go up before this fence.  
               {
                 toggle = !toggle;
                }
        }); …