主页 / 问题 / 1166689
Accepted
Ildar
Asked:2020-08-16 22:22:10 +0000 UTC2020-08-16 22:22:10 +0000 UTC

为什么条件变量需要互斥锁

  • 772
  1. 为什么unique_lock在调用wait条件变量的方法之前锁定互斥锁？
  2. 为什么该方法wait需要互斥锁作为参数，因为如果我愿意，我会在醒来后自己阻塞必要的互斥锁？
  3. notify_one在另一个线程中调用条件变量之前是否有必要锁定同一个互斥锁？

一些背景

#include <iostream>

#include <thread>
#include <mutex>
#include <condition_variable>

std::mutex outputStreamMutex;

std::mutex productMutex;
std::condition_variable condVar;
bool productReady = false;

class Product 
{
public:
  void make() {}
} product;


void makeProduct()
{
  {
    std::lock_guard<std::mutex> lock(outputStreamMutex);
    std::cout << "making process...\n";
  }

  {
    std::lock_guard lock(productMutex);
    product.make();
    productReady = true;
    condVar.notify_one();

    std::lock_guard<std::mutex> lockStream(outputStreamMutex);
    std::cout << "product is made\n";
  }
}

void send(const Product& prod)
{
  //...
}

void sendProduct()
{
  {
    std::lock_guard<std::mutex> lock(outputStreamMutex);
    std::cout << "waiting product process...\n";
  }

  {
    std::unique_lock lock(productMutex);
    condVar.wait(lock, []() {return productReady;});
    send(product);
    productReady = false;

    std::lock_guard<std::mutex> lockStream(outputStreamMutex);
    std::cout << "product is sent\n";
  }
}


int main()
{
  std::thread makerThread(makeProduct);
  std::thread senderThread(sendProduct);
  makerThread.join();
  senderThread.join();

  return 0;
}
c++

1 个回答

  1. Best Answer

    不加糖的条件变量的典型用法通常看起来像这样（伪代码）¹：

    condition_variable cv; // условная переменная
mutex dataMutex;       // Мьютекс, контролирующий доступ к данным
MyData data;           // Некоторые пользовательские данные

Consumer() {
  dataMutex.lock();        // Захват мьютекса, дабы данные не изменялись во 
                           // время проверки предиката
  while(!data.isReady()) { // Проверка, не готовы ли данные
    cv.wait(dataMutex);    // Ожидание сигнала от производителя, когда он изменит 
  }                        // данные

  // ... какая-то обработка данных ...

  dataMutex.unlock();      // Освобождение мьютекса т.к. он более не используется
}

Produser() {
  while (1) {
    dataMutex.lock();        // Захват мьютекса, чтобы изменить данные
    data.doWork();           // Какая-то обработка данных
    cv.notify_one();         // Пробуждение одного потока, ждущего в очереди
    dataMutex.unlock();      // Освобождение мьютекса, дабы потребитель смог
  }                          // проверить своё условие и обработать данные
}

    在最原始的情况下，条件变量的典型实现是这样安排的（也是伪代码）：

    struct condition_variable {
  mutex cvMut;                     // Внутренний мьютекс защищающий доступ к очереди.
  queue<thread_t*> waitingQueue;   // Очередь потоков, ожидающих сигнала
  
  void wait(mutex dataMutex) {
    // Добавление текущего потока в очередь ожидания
    cvMut.lock();
    waitingQueue.push(this_thread);
    cvMut.unlock();
    
    dataMutex.unlock(); // Освобождение мьютекса доступа к данным,
                        // дабы производитель мог с ними работать
    suspend();          // Приостановка работы и ожидание сигнала о пробуждении

    dataMutex.lock();   // Захват Мьютекса обратно, дабы внешняя программа смогла
                        // проверить, выполнено ли условие.
  }

  void notify_one(){
    // Получить процесс из очереди ожидания
    cvMut.lock();
    thread_t *thread = waitingQueue.pop();
    cvMut.unlock();
     
    // Если очередь не пуста, то разбудить ожидающий поток.
    if(thread) {
      restart(thread);
    }
  }
}

    实现suspend()和resume()系统相关。例如，在经典 UNIX 系统上，它们可以使用sigsuspend()/构建信号kill()，但在现代（2.4+）GNU/Linux 上，它们构建在futex'ax.

    1. 为什么unique_lock在调用wait条件变量的方法之前锁定互斥锁？

    从上面的示例实现中可以看出，在检查条件之前必须持有锁，直到线程被添加到等待队列中。如果它不存在，那么由于竞态条件，可能会出现以下事件序列：

    Потребитель   : проверяет условие.
Производитель : изменяет данные
Производитель : проверяет, что очередь ожидания пуста и ничего не делает
Потребитель   : добавляет себя в очередь
Потребитель   : засыпает и ждёт сигнала

    结果，消费者可以无限期地保持睡眠，尽管条件已经满足。锁实际上阻止了生产者在检查和将自己添加到队列之间更改数据。

    使用是精确的unique_lock，而不是std::lock_guard因为后者无法解锁。std::mutex::lock()普通的/本来可以省略unlock()，但在 C++ 中，如果有人抛出异常，这将充满悬空锁（请参阅使用锁对象的一般动机）。

    1. 为什么该方法wait需要互斥锁作为参数，因为如果我愿意，我会在醒来后自己阻塞必要的互斥锁？

    见典型的实现和答案（1）。在条件检查期间阻塞它很重要，直到并包括将线程添加到等待队列中。

    1. notify_one在另一个线程中调用条件变量之前是否有必要锁定同一个互斥锁？

    在这种情况下，它不是必需的，但必须在任何可能导致条件变化的数据变化时捕获它。当唤醒信号发出时，它已经可以被释放了。

    如果不超过一个进程在等待条件变量，那么绝对没有区别。但是，正如POSIX 警告的那样，如果在存在多个消费者的情况下需要“可预测的调度程序行为”，那么应该保留它。在这种情况下，可能会出现饥饿情况，包括更高优先级的流。在此处查看详细信息。

    ¹ 此处及下方未指定内存屏障

    • 6

相关问题