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); in fact doing so is a	pessimization,
       since the
	  notified thread would	immediately block again, waiting for the noti-
       fying thread to
	  release the lock.

Example
       // Run this code

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

	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)

http://cppreference.com		  2022.07.31	 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.0>

home | help