相关疑难解决方法(0)

来自《Effective Java》一书：

虽然 volatile 修饰符不执行互斥，但它保证任何读取该字段的线程都会看到最近写入的值

SO和许多其他来源声称类似的事情。

这是真的？

我的意思是真的，不是一个足够接近的模型，或者只在 x86 上，或者只在 Oracle JVM 中，或者“最近写的”的一些定义，这不是标准的英语解释......

其他来源（SO 示例）说 Java 中的 volatile 就像 C++ 中的获取/释放语义。我认为不提供报价的保证。

我发现在JLS 17.4.4 中它说“对 volatile 变量 v 的写入（第 8.3.1.4 节）与任何线程对 v 的所有后续读取同步（其中“后续”是根据同步顺序定义的）。 ” 但我不太明白。

有很多支持和反对的消息来源，所以我希望答案能够说服其中许多（在任何一方）确实是错误的 - 例如参考或规范，或反示例代码。

与我之前的问题类似，请考虑以下代码

-- Initially --
std::atomic<int> x{0};
std::atomic<int> y{0};

-- Thread 1 --
x.store(1, std::memory_order_release);

-- Thread 2 --
y.store(2, std::memory_order_release);

-- Thread 3 --
int r1 = x.load(std::memory_order_acquire);   // x first
int r2 = y.load(std::memory_order_acquire);

-- Thread 4 --
int r3 = y.load(std::memory_order_acquire);   // y first
int r4 = x.load(std::memory_order_acquire);

是怪异的结果 r1==1, r2==0，并r3==2, r4==0有可能在C ++ 11内存模型下，这种情况下？如果我要全部替换std::memory_order_acq_rel成该std::memory_order_relaxed怎么办？

在x86上，这样的结果似乎是被禁止的，请参见此SO问题，但我一般是在询问C ++ 11内存模型。

奖励问题：

我们都同意，与std::memory_order_seq_cst该怪异的结果不会在C ++ 11被允许。现在，赫伯·萨特（Herb Sutter）在他著名的- …

考虑cppreference 中的这个示例

#include <thread>
#include <atomic>
#include <cassert>
 
std::atomic<bool> x = {false};
std::atomic<bool> y = {false};
std::atomic<int> z = {0};
 
void write_x()
{
    x.store(true, std::memory_order_seq_cst);  // #1
}
 
void write_y()
{
    y.store(true, std::memory_order_seq_cst); // #2
}
 
void read_x_then_y()
{
    while (!x.load(std::memory_order_seq_cst))  // #3
        ;
    if (y.load(std::memory_order_seq_cst)) {  // #4
        ++z;
    }
}
 
void read_y_then_x()
{
    while (!y.load(std::memory_order_seq_cst))  // #5
        ;
    if (x.load(std::memory_order_seq_cst)) {  // #6
        ++z;
    }
}
 
int main()
{
    std::thread a(write_x);
    std::thread b(write_y);
    std::thread c(read_x_then_y);
    std::thread d(read_y_then_x); …