Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

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

NAME
       std::condition_variable::notify_all    -	  std::condition_variable::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 mu-
       tex 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	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)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::condition_variable::notify_all&sektion=3&manpath=FreeBSD+Ports+15.1.quarterly>

home | help