相关疑难解决方法(0)

该标准定义了几个“发生在之前”关系，这些关系将古老的“之前排序”扩展到多个线程：

\n

[intro.races]

\n

11 评估 A简单地发生在评估 B 之前，如果

\n

(11.1) \xe2\x80\x94 A 在 B 之前排序，或者
\n(11.2) \xe2\x80\x94 A 与 B 同步，或者
\n(11.3) \xe2\x80\x94 A 只是发生在 X 之前，并且X 只是发生在 B 之前。

\n

[注10：在没有消耗操作的情况下，发生在之前和简单发生在关系之前是相同的。\xe2\x80\x94 尾注]

\n

12 评估 A强烈发生在评估 D 之前，如果：

\n

(12.1) \xe2\x80\x94 A 在 D 之前排序，或者
\n(12.2) \xe2\x80\x94 A 与 D 同步，并且 A 和 D 都是顺序一致的原子操作\n([atomics.order] )，或
\n(12.3) \xe2\x80\x94 存在评估 B 和 C，使得 A 在 B 之前排序，B 仅发生在 C 之前，并且 C 在 D 之前排序，或者 …

我目前正在阅读Anthony Williams的C++ Concurrency in Action.他的一个列表显示了这段代码,他声明z != 0可以解雇的断言.

#include <atomic>
#include <thread>
#include <assert.h>

std::atomic<bool> x,y;
std::atomic<int> z;

void write_x()
{
    x.store(true,std::memory_order_release);
}

void write_y()
{
    y.store(true,std::memory_order_release);
}

void read_x_then_y()
{
    while(!x.load(std::memory_order_acquire));
    if(y.load(std::memory_order_acquire))
        ++z;
}

void read_y_then_x()
{
    while(!y.load(std::memory_order_acquire));
    if(x.load(std::memory_order_acquire))
        ++z;
}

int main()
{
    x=false;
    y=false;
    z=0;
    std::thread a(write_x);
    std::thread b(write_y);
    std::thread c(read_x_then_y);
    std::thread d(read_y_then_x);
    a.join();
    b.join();
    c.join();
    d.join();
    assert(z.load()!=0);
}

所以我能想到的不同执行路径是这样的:

1)

Thread a (x is now true)
Thread c (fails to increment z)
Thread b (y …

Run Code Online (Sandbox Code Playgroud)

我有一个关于GCC-Wiki文章的问题.在标题"总结"下,给出了以下代码示例:

线程1:

y.store (20);
x.store (10);

线程2:

if (x.load() == 10) {
  assert (y.load() == 20)
  y.store (10)
}

据说,如果释放所有商店并获得所有负载,则线程2中的断言不会失败.这对我来说很清楚(因为线程1中x的存储与线程2中x的加载同步).

但现在出现了我不理解的部分.还有人说,如果所有商店都被释放并且消耗了所有负载,那么结果是相同的.来自y的负载是否可能在x的负载之前被提升(因为这些变量之间没有依赖关系)？这意味着线程2中的断言实际上可能会失败.