home | help 
std::condit...::notify_all(3)  C++ Standard Libary std::condit...::notify_all(3)

NAME
     std::condition_variable_any::notify_all  - std::condition_variable_any::no-
     tify_all

Synopsis
	void notify_all() noexcept;  (since C++11)

	Unblocks all threads currently waiting for *this.

Parameters
	(none)

Return value
	(none)

Notes
	The effects of notify_one()/notify_all() and each of  the  three  atomic
     parts of
	wait()/wait_for()/wait_until()	(unlock+wait,  wakeup,	and  lock)  take
     place in a
	single total order that can be viewed as modification order of an atomic
     variable:
	the order is specific to this individual condition variable. This  makes
     it
	impossible  for  notify_one()  to, for example, be delayed and unblock a
     thread that
	started waiting just after the call to notify_one() was made.

	The notifying thread does not need to hold the lock on the same mutex as
     the one
	held by the waiting thread(s). Doing so may be	a  pessimization,  since
     the notified
	thread	would  immediately block again, waiting for the notifying thread
     to release
	the lock, though some implementations recognize the pattern and  do  not
     attempt to
	wake up the thread that is notified under lock.

Example
     // Run this code

      #include <chrono>
      #include <condition_variable>
      #include <iostream>
      #include <thread>

      std::condition_variable_any cv;
      std::mutex cv_m; // This mutex is used for three purposes:
		       // 1) to synchronize accesses to i
		       // 2) to synchronize accesses to std::cerr
		       // 3) for the condition variable cv
      int i = 0;

      void waits()
      {
	  std::unique_lock<std::mutex> lk(cv_m);
	  std::cerr << "Waiting... \n";
	  cv.wait(lk, []{ return i == 1; });
	  std::cerr << "...finished waiting. i == 1\n";
      }

      void signals()
      {
	  std::this_thread::sleep_for(std::chrono::seconds(1));
	  {
	      std::lock_guard<std::mutex> lk(cv_m);
	      std::cerr << "Notifying...\n";
	  }
	  cv.notify_all();

	  std::this_thread::sleep_for(std::chrono::seconds(1));

	  {
	      std::lock_guard<std::mutex> lk(cv_m);
	      i = 1;
	      std::cerr << "Notifying again...\n";
	  }
	  cv.notify_all();
      }

      int main()
      {
	  std::thread t1(waits), t2(waits), t3(waits), t4(signals);
	  t1.join();
	  t2.join();
	  t3.join();
	  t4.join();
      }

Possible output:
      Waiting...
      Waiting...
      Waiting...
      Notifying...
      Notifying again...
      ...finished waiting. i == 1
      ...finished waiting. i == 1
      ...finished waiting. i == 1

See also
	notify_one notifies one waiting thread
		   (public member function)
	C documentation for
	cnd_broadcast

Hidden category:
	  * Pages with unreviewed LWG DR marker

http://cppreference.com 	   2024.06.10	   std::condit...::notify_all(3)
home | help