我应该使用 std::atomic 还是 std::mutex 来避免线程竞争？

Question

What is the better way to avoid the data race in this specific scenario?

I am writing a program where a class has some variable and creates a detached (async/parallel) thread to update its private variable in an infinite while loop. Also, this class has a function that accesses its private variable time to time in the main thread:

#include "UART.h"
class Example
{
private:
  double x;
  double y;
  UART &uart;
public:
  Example::Example(UART u) : uart(u), x(0), y(0) {};

  void Example::run()
  {
     while(1)
     {
         x = uart.read() // Here x is being filled with some other values
     }
  }

  void Example::getX()
  {
     // Data race
      y = this->x*2;
   }
};

int main(int argc, char** argv)
{
  Example example(u);
  std::thread t1(&Example::run, example);
  t1.detach();

  example.getX();
}

So with the code above, what is the better solution to avoid a data race and undefined behavior of x ?

Is it having mutex in function getx() :

// mtx will be created in Example private member sector
void Example::getX()
{
   mtx.lock();
   y = this->x*2;
   mtx.unlock();
}

Or is it better to make x as atomic?

std::atomic<double> x;

Answer 1

这里不仅atomic足够，而且memory_order_relaxed （而不是简单的赋值）就足够了，因为没有其他内存写入需要提供给另一个线程使用。