Acounting_semaphore contains an internal counter initialized by the constructor. This counter is decremented by calls toacquire() and related methods, and is incremented by calls torelease(). When the counter is zero,acquire() blocks until the counter is incremented, buttry_acquire() does not block;try_acquire_for() andtry_acquire_until() block until the counter is incremented or a timeout is reached.

Similar tostd::condition_variable::wait(),counting_semaphore'stry_acquire() can spuriously fail.

Specializations ofstd::counting_semaphore are notDefaultConstructible,CopyConstructible,MoveConstructible,CopyAssignable, orMoveAssignable.

[edit]Data Members

[edit]Member functions

[edit]Notes

As its name indicates, theLeastMaxValue is theminimum max value, not theactual max value. Thusmax() can yield a number larger thanLeastMaxValue.

Unlikestd::mutex acounting_semaphore is not tied to threads of execution - acquiring a semaphore can occur on a different thread than releasing the semaphore, for example. All operations oncounting_semaphore can be performed concurrently and without any relation to specific threads of execution, with the exception of the destructor which cannot be performed concurrently but can be performed on a different thread.

Semaphores are also often used for the semantics of signaling/notifying rather than mutual exclusion, by initializing the semaphore with​0​ and thus blocking the receiver(s) that try toacquire(), until the notifier "signals" by invokingrelease(n). In this respect semaphores can be considered alternatives tostd::condition_variables, often with better performance.

[edit]Example

#include <chrono>#include <iostream>#include <semaphore>#include <thread> // global binary semaphore instances// object counts are set to zero// objects are in non-signaled statestd::binary_semaphore    smphSignalMainToThread{0},    smphSignalThreadToMain{0}; void ThreadProc(){// wait for a signal from the main proc// by attempting to decrement the semaphore    smphSignalMainToThread.acquire(); // this call blocks until the semaphore's count// is increased from the main proc std::cout<<"[thread] Got the signal\n";// response message // wait for 3 seconds to imitate some work// being done by the threadusingnamespace std::literals;std::this_thread::sleep_for(3s); std::cout<<"[thread] Send the signal\n";// message // signal the main proc back    smphSignalThreadToMain.release();} int main(){// create some worker threadstd::thread thrWorker(ThreadProc); std::cout<<"[main] Send the signal\n";// message // signal the worker thread to start working// by increasing the semaphore's count    smphSignalMainToThread.release(); // wait until the worker thread is done doing the work// by attempting to decrement the semaphore's count    smphSignalThreadToMain.acquire(); std::cout<<"[main] Got the signal\n";// response message    thrWorker.join();}

[main] Send the signal[thread] Got the signal[thread] Send the signal[main] Got the signal

• In other languages

• Español
• 日本語
• Русский
• 中文