object - C++11 只能将原始数据类型声明为原子的吗？

Question

我想知道，只能在 C++11 中声明原始数据类型 std::atomic 吗？例如，是否有可能将库类对象声明为“原子地”变异或访问？

例如，我可能有

using namespace std::chrono;
time_point<high_resolution_clock> foo;

// setter method
void set_foo() {
  foo = high_resolution_clock::now();
}

// getter method
time_point<high_resolution_clock> get_foo() {
  return foo;
}

但是，如果在不同的线程中调用这些 setter 和 getter 方法，我认为可能会导致未定义的行为。如果我可以像下面这样声明 foo 就好了:

std::atomic<time_point<high_resolution_clock>> foo;

...以便 foo 上的所有操作都将以原子方式进行。在我的项目的应用程序中，可能有数百个这样的 foo 变量在几十个类中声明，我觉得让对象变异和访问“原子”可以说要方便得多，而不是必须声明和 lock_guard到处都是互斥体。

这是不可能的，还是有更好的方法，或者我真的必须在任何地方使用互斥锁和 lock_guard？

更新 :

有接类人吗？我一直在网上寻找体面的信息，但是使用 atomic 的例子太少了，我不能确定它可以应用到什么程度。

Answer 1

atomic<>不限于原始类型。允许使用 atomic<>带类型 T即 trivially copyable .来自 c++11 标准的第 29.5 节原子类型(也在 std::atomic 中说明):

There is a generic class template atomic. The type of the template argument T shall be trivially copyable (3.9).

如果需要原子访问的对象不能与 atomic<> 一起使用然后定义新对象，包含原始对象和 std::mutex .这意味着 lock_guard<>仅在新线程安全对象的 getter 和 setter 中使用，而不是在整个代码中乱扔。 A template也许能够定义所需的线程安全机制:

template <typename T>
class mutable_object
{
public:
    mutable_object() : t_() {}
    explicit mutable_object(T a_t) : t_(std::move(a_t)) {}
    T get() const
    {
        std::lock_guard<std::mutex> lk(mtx_);
        return t_;
    }
    void set(T const& a_t)
    {
        std::lock_guard<std::mutex> lk(mtx_);
        t_ = a_t;
    }
private:
    T t_;
    mutable std::mutex mtx_;
};

using mutable_high_resolution_clock =
        mutable_object<std::chrono::time_point<
            std::chrono::high_resolution_clock>>;

using mutable_string = mutable_object<std::string>;

mutable_high_resolution_clock c;
c.set(std::chrono::high_resolution_clock::now());
auto c1 = c.get();

mutable_string s;
s.set(std::string("hello"));
auto s1 = s.get();