c++ - 如果已知访问顺序是安全的，如何在没有互斥锁的情况下同步线程/CPU？

Question

考虑以下几点:

// these services are running on different threads that are started a long time ago
std::vector<io_service&> io_services;

struct A {
  std::unique_ptr<Object> u;
} a;

io_services[0].post([&io_services, &a] {
      std::unique_ptr<Object> o{new Object};

      a.u = std::move(o);

      io_services[1].post([&a] {
            // as far as I know changes to `u` isn't guaranteed to be seen in this thread 
            a.u->...;
          });
    });

实际代码将结构传递给一堆不同的 boost::asio::io_service对象和结构的每个字段由不同的服务对象填充(该结构永远不会同时从不同的 io_service 对象/线程访问，它通过引用在服务之间传递，直到过程完成).

据我所知，当我在线程之间传递任何内容时，即使没有读/写竞争(如同时访问)，我也总是需要某种显式同步/内存刷新。这种情况下正确的做法是什么？

请注意，对象 不属于我，它不可复制或移动。我可以使用 std::atomic<Object*> (如果我没记错的话)但我宁愿使用智能指针。有办法吗？

编辑:好像std::atomic_thread_fence是完成这项工作的工具，但我无法真正将“内存模型”概念包装成安全的代码。我的理解是此代码需要以下几行才能正常工作。真的是这样吗？

// these services are running on different threads that are started a long time ago
std::vector<io_service&> io_services;

struct A {
  std::unique_ptr<Object> u;
} a;

io_services[0].post([&io_services, &a] {
      std::unique_ptr<Object> o{new Object};

      a.u = std::move(o);

      std::atomic_thread_fence(std::memory_order_release);

      io_services[1].post([&a] {
            std::atomic_thread_fence(std::memory_order_acquire);

            a.u->...;
          });
    });

Answer 1

只有在没有同步的情况下才会出现数据竞争时才需要同步。数据竞争被定义为不同线程的无序访问。

您没有这种无序的访问权限。 t.join()保证后面的所有语句严格排在作为 t 的一部分运行的所有语句之后.因此不需要同步。

ELABORATION:(解释为什么thread::join具有上述声称的特性)首先，thread::join的描述来自标准 [thread.thread.member]:

void join();

3. Requires: joinable() is true.
4. Effects: Blocks until the thread represented by *this has completed.
5. Synchronization: The completion of the thread represented by *this synchronizes with (1.10) the corresponding successful join() return.

一个)。上面显示join()提供同步(具体来说:由 *this 表示的线程的完成与调用 join() 的外线程同步)。接下来[介绍.multithread]:

13. An evaluation A inter-thread happens before an evaluation B if

(13.1) — A synchronizes with B, or ...

这表明，由于 a)，我们完成了 t 线程间发生在 join() 返回之前打电话。

最后，[intro.multithread]:

23. Two actions are potentially concurrent if

(23.1) — they are performed by different threads, or

(23.2) — they are unsequenced, and at least one is performed by a signal handler.

The execution of a program contains a data race if it contains two potentially concurrent conflicting actions, at least one of which is not atomic, and neither happens before the other ...

上面描述了数据竞争的必要条件。 t.join() 的情况不满足这些条件是因为，如图所示，t 的完成事实上发生在 join() 的返回之前.

因此不存在数据竞争，所有数据访问都保证有明确定义的行为。