Difference between revisions of "cpp/thread/counting semaphore"

Revision as of 10:09, 28 October 2020

A counting_semaphore contains an internal counter initialized by the constructor. This counter is decremented by calls to acquire() and related methods, and is incremented by calls to release(). When the counter is zero, acquire() blocks until the counter is incremented, but try_acquire() does not block; try_acquire_for() and try_acquire_until() block until the counter is incremented or a timeout is reached.

Similar to std::condition_variable's wait(), counting_semaphore's try_acquire() can spuriously fail.

Specializations of std::counting_semaphore are not DefaultConstructible, CopyConstructible, MoveConstructible, CopyAssignable, or MoveAssignable.

Member functions

Notes

As its name indicates, the LeastMaxValue is the minimum max value, not the actual max value. Thus max() can yield a number larger than LeastMaxValue.

Unlike std::mutex a counting_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 on counting_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 signalling/notifying rather than mutual exclusion, by initializing the semaphore with ​0​ and thus blocking the receiver(s) that try to acquire(), until the notifier "signals" by invoking release(n). In this respect semaphores can be considered alternatives to std::condition_variables, often with better performance.

Example

#include <iostream>
#include <thread>
#include <chrono>
#include <semaphore>
using namespace std::literals; 
 
// global binary semaphore instance
// object's count is set to zero
// object is in non-signaled state
std::binary_semaphore smphSignal(0);
 
void ThreadProc()
{
    // wait for a signal from the main proc
    // by attempting to decrement the semaphore
    smphSignal.acquire();
 
    // this call blocks until the semaphore's count
    // is increased from the main proc
 
    std::cout << "[thread] Got the signal" << std::endl; // response message
 
    // wait for 3 seconds to imitate some work
    // being done by the thread
    std::this_thread::sleep_for(3s);
 
    std::cout << "[thread] Send the signal\n"; // message
 
    // signal the main proc back
    smphSignal.release();
}
 
int main()
{
    // create some background worker thread
    // that would exist for a long period of time
    std::jthread thrWorker(ThreadProc);
 
    std::cout << "[main] Send the signal\n"; // message
 
    // signal the worker thread to start working
    // by increasing the semaphore's count
    smphSignal.release();
 
    // release() followed by acquire() may prevent the worker
    // thread from acquiring the semaphore, so add some delay:
    std::this_thread::sleep_for(50ms);
 
    // wait until the worker thread is done doing the work
    // by attempting to decrement the semaphore's count
    smphSignal.acquire();
 
    std::cout << "[main] Got the signal\n"; // response message
}

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