相关疑难解决方法(0)

C和C++中未定义,未指定和实现定义的行为有什么区别？

如果有两个线程访问全局变量,那么许多教程都说使变量volatile变为阻止编译器将变量缓存在寄存器中,从而无法正确更新.但是,访问共享变量的两个线程是通过互斥锁来调用保护的东西不是吗？但是在这种情况下,在线程锁定和释放互斥锁之间,代码处于一个关键部分,只有那个线程可以访问变量,在这种情况下变量不需要是volatile？

那么多线程程序中volatile的用途/目的是什么？

我读了一章,我不喜欢它.我还不清楚每个内存顺序之间的差异.这是我目前的推测,我在阅读更简单的http://en.cppreference.com/w/cpp/atomic/memory_order后理解这一点.

以下是错误的,所以不要试图从中学习

• memory_order_relaxed:当从另一个原子var中的另一个模式完成订单时,不同步但不被忽略
• memory_order_consume:Syncs读取这个原子变量然而它没有同步在此之前写的轻松变量.但是,如果线程在修改Y(并释放它)时使用var X. 消耗Y的其他线程也将看到X发布？我不知道这是否意味着这个线程推出了x的变化(显然是y)
• memory_order_acquire:同步读取这个原子变量并确保在此之前写入的轻松变量同步.(这是否意味着所有线程上的所有原子变量都被同步？)
• memory_order_release:将原子存储推送到其他线程(但仅当它们使用consume/acquire读取var时)
• memory_order_acq_rel:用于读/写操作.获取是否因此您不修改旧值并释放更改.
• memory_order_seq_cst:与获取版本相同的东西,除了它强制在其他线程中看到更新(如果a在另一个线程上放宽了存储.我b用seq_cst 存储.第三个线程读取a 放松将看到变化以及b任何其他原子变量？ ).

如果我错了,我想我理解但是纠正我.我找不到任何用易于阅读的英语解释它的东西.

我前面问过的一个问题是未定义的行为,因此编译器优化实际上导致程序中断.

但是如果代码中没有未定义的行为,那么有没有理由不使用编译器优化？我理解有时候,出于调试目的,可能不需要优化代码(如果我错了请纠正我).除此之外,在生产代码上,为什么不总是使用编译器优化？

另外,是否有理由使用,-O而不是-O2或-O3？

我需要为另一个线程设置一个标志来退出.另一个线程会不时检查退出标志.我是否必须使用原子作为旗帜或只是一个普通的布尔就足够了(为什么(如果我使用普通布尔可能会出错的例子)？

#include <future>
bool exit = false;
void thread_fn()
{
    while(!exit)
    {
        //do stuff
        if(exit) break;
        //do stuff
    }
}
int main()
{
    auto f = std::async(std::launch::async, thread_fn);
    //do stuff
    exit = true;
    f.get();
}

https://www.gnu.org/software/libc/manual/html_node/Atomic-Types.html#Atomic-Types说 -在实践中，你可以假设 int 是原子的。你也可以假设指针类型是原子的；那很方便。这两个假设在 GNU C 库支持的所有机器上和我们知道的所有 POSIX 系统上都是正确的。

我的问题是，对于使用 gcc m64 标志编译的 C 程序，是否可以将指针分配视为 x86_64 架构上的原子分配。操作系统为 64 位 Linux，CPU 为 Intel(R) Xeon(R) CPU D-1548。一个线程将设置一个指针，另一个线程将访问该指针。只有一个写入线程和一个读取线程。Reader 应该获取指针的先前值或最新值，并且两者之间没有垃圾值。

如果它不被认为是原子的，请让我知道我如何使用 gcc 原子内置函数或者像 __sync_synchronize 这样的内存屏障来实现相同的效果而不使用锁。只对 C 解决方案感兴趣，对 C++ 不感兴趣。谢谢！

考虑下面的示例是打算等到另一个线程存储42在一个共享变量shared没有锁，无需等待线程终止，为什么会volatile T或std::atomic<T>会要求或建议，以保证并发正确性？

#include <atomic>
#include <cassert>
#include <cstdint>
#include <thread>

int main()
{
  int64_t shared = 0;
  std::thread thread([&shared]() {
    shared = 42;
  });
  while (shared != 42) {
  }
  assert(shared == 42);
  thread.join();
  return 0;
}

使用 GCC 4.8.5 和默认选项，示例按预期工作。

假设我有多个线程访问相同的内存位置。而且，如果有的话，它们都写入相同的值，但没有人读取它。之后，所有线程（通过锁）收敛，然后我才读取值。我需要为此使用原子吗？这是针对 x86_64 系统的。该值是一个 int32。

正如我从测试用例中看到的：https : //godbolt.org/z/K477q1

生成的程序集加载/存储原子放松与普通变量相同：ldr 和 str

那么，松弛原子变量和普通变量之间有什么区别吗？

请注意：这只是出于好奇而提出的问题，与编写更好的多线程代码无关。当然，我不会也不会在实际项目中编写这样的代码。

添加关键字时可能会发生内联替换inline。所以我很好奇。

假设我们有这样的代码：

static bool done = false;

inline void setDone(bool newState) {
    done = newState;
}

inline bool getDone() {
    return done;
}

void someWorkerThreadJob() {
    // Accessing without any lock/atomic/volatile
    while (getDone() == false) {
    }
}

可以someWorkerThreadJob()像下面这样编译并进入无限循环吗？

void someThreadJob() {
    while (done == false) {
    }
}

这也将我引向了下一个问题。类中的getter和setter怎么样？在类中定义的成员函数是隐式的inline，所以我认为可能会发生内联替换，因此同样的问题。这样对吗？