CERT C++: CON55-CPP

This issue occurs when you use the std::condition_variable::notify_one() function to notify one of at least two threads that are concurrently waiting for the same condition variable. For threads with the same priority level, this function causes the thread scheduler to arbitrarily notify one of the threads waiting for the condition variable.

See the Event column in the Results Details pane to view the threads waiting for the same condition variable.

When multiple threads use the same std::condition_variable, then the function std::condition_variable::notify_one() arbitrarily notifies one of the waiting threads. The notified thread usually tests for a condition predicate. If the condition predicate is false, the thread continues to wait until it is notified again. Because this method notifies an arbitrary thread, it is possible that the condition predicate for the notified thread never becomes true. The program ends up in a state where no thread is awake, resulting in indefinite blocking.

To fix this issue, do one of the following:

In this example, multiple threads are created and assigned step numbers. All these threads are controlled using the same std::condition_variable conVar. Each thread checks if its assigned step number matches the current step number. If the assigned step number of a thread does not match the current step number, the thread goes back to waiting on the condition variable. Because the code uses std::condition_variable::notify_one() to notify conVar, it is possible that the arbitrarily notified thread has a different stepNumber than the currentStep, which causes the notified thread to resume waiting. If no other thread is awake, then conVar is never notified again, resulting in indefinite blocking.

#include <condition_variable>
#include <iostream>
#include <mutex>
#include <thread>
  
std::mutex myMutex;
std::condition_variable conVar;
 
void stepFunc(size_t stepNumber) {
  static size_t currentStep = 0;
  std::unique_lock<std::mutex> uLock(myMutex);
 
 
  while (currentStep != stepNumber) {
    conVar.wait(uLock);
  }
 
  // Do processing...
  //....
  currentStep++;
 
  // Signal awaiting task.
  conVar.notify_one(); //Noncompliant
 
}
 
void foo() {
  constexpr size_t nThreads = 5;
  std::thread threads[nThreads];
 
  // Create threads.
  for (size_t i = 0; i < nThreads; ++i) {
    threads[i] = std::thread(stepFunc, i);
  }
 
  // Wait for all threads to complete.
  for (size_t i = nThreads; i != 0; --i) {
    threads[i - 1].join();
  }
}

One possible correction is to use std::condition_variable::notify_all() instead to signal conVar. The function std::condition_variable::notify_all() notifies all the thread that are waiting on conVar. At least one of the threads fail the test (currentStep != stepNumber) and currentStep is incremented.

#include <condition_variable>
#include <iostream>
#include <mutex>
#include <thread>
  
std::mutex myMutex;
std::condition_variable conVar;
 
void stepFunc(size_t stepNumber) {
  static size_t currentStep = 0;
  std::unique_lock<std::mutex> uLock(myMutex);
 
 
  while (currentStep != stepNumber) {
    conVar.wait(uLock);
  }
 
  // Do processing...
  //....
  currentStep++;
 
  // Signal ALL awaiting task.
  conVar.notify_all(); //Compliant
 
}
 
void foo() {
  constexpr size_t nThreads = 5;
  std::thread threads[nThreads];
 
  // Create threads.
  for (size_t i = 0; i < nThreads; ++i) {
    threads[i] = std::thread(stepFunc, i);
  }
 
  // Wait for all threads to complete.
  for (size_t i = nThreads; i != 0; --i) {
    threads[i - 1].join();
  }
}

Notifying all threads by using std::condition_variable::notify_all() is not always thread-safe. An alternative is to use unique condition variables for each thread. This way, a thread can choose which thread to notify. In this code, each thread signals the thread corresponding to the next stepNumber. The notified threads does not resume waiting and currentStep is incremented.

#include <condition_variable>
#include <iostream>
#include <mutex>
#include <thread>
  constexpr size_t numThreads = 5;
std::mutex myMutex;
std::condition_variable conVar[numThreads];
 
void stepFunc(size_t stepNumber) {
  static size_t currentStep = 0;
  std::unique_lock<std::mutex> uLock(myMutex);
 
 
  while (currentStep != stepNumber) {
    conVar[stepNumber].wait(uLock);
  }
 
  // Do processing...
  //....
  currentStep++;
 
  // Signal awaiting task.
  if ((stepNumber + 1) < numThreads) {
    conVar[stepNumber + 1].notify_one();
  }
 
}
 
void foo() {
  constexpr size_t nThreads = 5;
  std::thread threads[nThreads];
 
  // Create threads.
  for (size_t i = 0; i < nThreads; ++i) {
    threads[i] = std::thread(stepFunc, i);
  }
 
  // Wait for all threads to complete.
  for (size_t i = nThreads; i != 0; --i) {
    threads[i - 1].join();
  }
}