Semaphores can be used to coordinate shared access to shared resources. You can also play ping-pong with them.

A counting semaphore is a special semaphore that has a counter greater than zero. This counter is initialized in the constructor. Requesting the semaphore decrements and releasing it increments the counter. If a thread tries to request the semaphore if the counter has the value zero, this thread is blocked until another thread releases the semaphore by incrementing the counter.

Who invented it? The Danish computer scientist Edsger W. Dijkstra provided 1965 suggest the concept of a semaphore. A semaphore is a data structure with a queue and a counter. The counter is initialized to a value greater than or equal to zero. It supports the two operations wait and signal. The former requests the semaphore and decrements the counter. In this case the executing thread is blocked if the semaphore has the value zero. signal enables the semaphore and increments the counter. Blocked threads are added to the queue to avoid starvation.

The term semaphore originally stands for a railway signal.

Counting semaphores in C ++ 20 C ++ 20 supports a std :: binary_semaphore , which is an alias to a std :: counting_semaphore is. In this case the maximum value for the counter is 1. A std :: binary_semaphore can be added can be used to implement a lock:

using binary_semaphore = std :: counting_semaphore ; as opposed to a std :: mutex is a std :: counting_semaphore not bound to a thread. This means that the request and release of the semaphore can take place in different threads. The following table presents the interface of a std :: counting_semaphore :

The call to the constructor std :: counting_semaphore sem (5) generates the semaphore sem , which maximally has the value 10 can accept. The counter has the value 5. sem.max () gives the maximum value for the counter back . try_aquire_for (relTime) requires a period of time, the function sem.try_acquire_until (absTime) a time. In my articles on the time library you can read more about the details of durations and points in time: time. The three calls sem.try_acquire , sem.try_acquire_for and sem.try_acquire_until return a truth value that indicates the success of the operation.

Semaphores are typically used in sender-receiver processes. For example, if a semaphore is initialized to 0, the recipient call blocks sem.acquire () until the sender executes sem.release () . The recipient waits for the sender to be notified. The one-time synchronization of threads can easily be implemented with semaphores:

// threadSynchronizationSemaphore.cpp #include

# include

# include

# include

std :: vector myVec {};

std :: counting_semaphore prepareSignal (0); // (1)

void prepareWork () {

myVec.insert (myVec.end (), {0, 1, 0, 3});

std :: cout