c++ - std::atomic_bool 取消标志:std::memory_order_relaxed 是正确的内存顺序吗？

我有一个从套接字读取并生成数据的线程。每次操作后，线程都会检查 std::atomic_bool 标志以查看它是否必须提前退出。

为了取消操作，我将取消标志设置为 true ，然后在工作线程对象上调用 join() 。

线程和取消函数的代码如下所示:

std::thread work_thread;
std::atomic_bool cancel_requested{false};

void thread_func()
{
   while(! cancel_requested.load(std::memory_order_relaxed))
      process_next_element();

}

void cancel()
{
    cancel_requested.store(true, std::memory_order_relaxed);
    work_thread.join();
}

std::memory_order_relaxed 是否是原子变量使用的正确内存顺序？

最佳答案

只要 cancel_requested 标志和其他任何东西之间没有依赖关系，你就应该是安全的。

所示代码看起来没问题，假设您仅使用 cancel_requested 来加速关闭，但也有有序关闭的规定，例如队列中的哨兵条目(当然，队列本身是同步的)。

这意味着您的代码实际上是这样的:

std::thread work_thread;
std::atomic_bool cancel_requested{false};
std::mutex work_queue_mutex;
std::condition_variable work_queue_filled_cond;
std::queue work_queue;

void thread_func()
{
    while(! cancel_requested.load(std::memory_order_relaxed))
    {
        std::unique_lock<std::mutex> lock(work_queue_mutex);
        work_queue_filled_cond.wait(lock, []{ return !work_queue.empty(); });
        auto element = work_queue.front();
        work_queue.pop();
        lock.unlock();
        if (element == exit_sentinel)
            break;
        process_next_element(element);
    }
}

void cancel()
{
    std::unique_lock<std::mutex> lock(work_queue_mutex);
    work_queue.push_back(exit_sentinel);
    work_queue_filled_cond.notify_one();
    lock.unlock();
    cancel_requested.store(true, std::memory_order_relaxed);
    work_thread.join();
}

如果到此为止，那么 cancel_requested 也可以成为常规变量，代码甚至会变得更简单。

std::thread work_thread;
bool cancel_requested = false;
std::mutex work_queue_mutex;
std::condition_variable work_queue_filled_cond;
std::queue work_queue;

void thread_func()
{
    while(true)
    {
        std::unique_lock<std::mutex> lock(work_queue_mutex);
        work_queue_filled_cond.wait(lock, []{ return cancel_requested || !work_queue.empty(); });
        if (cancel_requested)
            break;
        auto element = work_queue.front();
        work_queue.pop();
        lock.unlock();
        process_next_element(element);
    }
}

void cancel()
{
    std::unique_lock<std::mutex> lock(work_queue_mutex);
    cancel_requested = true;
    work_queue_filled_cond.notify_one();
    lock.unlock();
    work_thread.join();
}

memory_order_relaxed 通常很难推理，因为它模糊了顺序执行代码的一般概念。因此，正如 Herb 在他的 atomic weapons talk 中解释的那样，它的用处非常非常有限。

注意 std::thread::join() 本身充当两个线程之间的内存屏障。

关于c++ - std::atomic_bool 取消标志:std::memory_order_relaxed 是正确的内存顺序吗？，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/53653252/