C++17 原子和条件变量死锁

Question

我有以下代码，它在注释行上死锁。基本上 f1 和 f2 在程序中作为单独的线程运行。 f1 期望 i 为 1 并将其递减，通知 cv。 f2 期望 i 为 0 并增加它，通知 cv。我假设如果 f2 将 i 增加到 1，调用 cv.notify()，然后 f1 读取一个过时的 i 值（即 0），就会发生死锁，因为互斥锁和 i 之间没有内存同步，然后等待并且永远不会被唤醒向上。然后 f2 也进入睡眠状态，现在两个线程都在等待一个永远不会被通知的 cv。

我怎样才能编写这段代码，以免发生死锁？基本上我想要实现的是拥有一些由两个线程更新的原子状态。如果其中一个线程的状态不正确，我不想旋转；相反，我想在值正确时使用 cv 功能（或类似功能）来唤醒线程。

我是用g++-7用O3编译代码（虽然O0和O3都出现死锁）。

#include <atomic>
#include <condition_variable>
#include <iostream>
#include <mutex>
#include <thread>

std::atomic_size_t i{0};
std::mutex mut;
std::condition_variable cv;

void f1() {
  while (1) {
    {
      std::unique_lock<std::mutex> lk(mut);
      cv.wait(lk, []() { return i.load() > 0; }); // deadlocks
    }
    --i;
    cv.notify_one();
    std::cout << "i = " << i << std::endl; // Only to avoid optimization
  }
}

void f2() {
  while (1) {
    {
      std::unique_lock<std::mutex> lk(mut);
      cv.wait(lk, []() { return i.load() < 1; }); // deadlocks
    }
    ++i;
    cv.notify_one();
    std::cout << "i = " << i << std::endl; // Only to avoid optimization
  }
}

int main() {
  std::thread t1(f1);
  std::thread t2(f2);
  t1.join();
  t2.join();
  return 0;
}

编辑：cout 只是为了避免编译器优化。

Answer 1

我认为问题在于i 的值可以更改，并且notify_one 可以在另一个线程评估return i.load() > 0; 之后但在lambda 调用返回和cv 恢复等待之前的间隔内调用。这样原子变量的变化就不会被另一个线程观察到，也没有人唤醒它再次检查。这可以通过在更改变量时锁定互斥锁来解决，尽管这样做会破坏原子的目的。

Answer 2

我认为 VTT 的回答是正确的，只是想说明会发生什么。首先，代码可以改写成如下形式：

void f1() {
   while (1) {
      {
         std::unique_lock<std::mutex> lk(mut);
         while (i == 0) cv.wait(lk);
      }
      --i;
      cv.notify_one();
   }
}

void f2() {
   while (1) {
      {
         std::unique_lock<std::mutex> lk(mut);
         while (i >= 1) cv.wait(lk);
      }
      ++i;
      cv.notify_one();
   }
}

现在，考虑以下时间线，i 最初是 0：

time step    f1:               f2:
=========    ================= ================
        1                      locks mut
        2                      while (i >= 1) F
        3                      unlocks mut
        4    locks mut
        5    while (i == 0) T                  
        6                      ++i;
        7                      cv.notify_one();
        8    cv.wait(lk);
        9    unlocks mut(lk) 
       10                      locks mut                   
       11                      while (i >= 1) T
       12                      cv.wait(lk);

实际上，f1 在i 为1 时等待。两个线程现在同时处于阻塞状态。

---

解决方案是将i 的修改放入锁定部分。那么，i 甚至不需要是原子变量。

Answer 3

当线程不拥有互斥锁时，您调用cv.notify_one();。这可能会导致通知被发送为空。想象一下f2 在f1 之前开始。 f2 调用cv.notify_one(); 但f1 尚未加入cv.wait。

获取的互斥体保证f2 要么在std::unique_lock<std::mutex> lk(mut) 中，要么等待通知。

#include <atomic>
#include <condition_variable>
#include <iostream>
#include <mutex>
#include <thread>

std::atomic_size_t i{0};
std::mutex mut;
std::condition_variable cv;

void f1() {
  while (1) {
    std::size_t ii;
    {
      std::unique_lock<std::mutex> lk(mut);
      cv.wait(lk, []() { return i.load() > 0; });
      ii = --i;
      cv.notify_one();
    }
    std::cout << "i = " << ii << std::endl;
  }
}

void f2() {
  while (1) {
    std::size_t ii;
    {
      std::unique_lock<std::mutex> lk(mut);
      cv.wait(lk, []() { return i.load() < 1; });
      ii = ++i;
      cv.notify_one();
    }
    std::cout << "i = " << ii << std::endl;
  }
}

int main() {
  std::thread t1(f1);
  std::thread t2(f2);
  t1.join();
  t2.join();
  return 0;
}

顺便说一句，std::atomic_size_t i 可能是std::size_t i。

Answer 4

由于 i 是原子的，因此无需使用互斥锁来保护其修改。

f1 和 f2 中的条件变量等待永远等待，除非发生虚假唤醒，因为从未通知条件变量。由于无法保证虚假唤醒，我建议在等待条件变量之前检查条件，并最终通知其他线程的条件变量。

您的代码还有另一个问题。 f1 和 f2 两个函数都不会结束。所以你的 ma​​in 函数会一直等待加入它的线程。