Stdcounting Semaphore Stdbinary Semaphore In C++

Overview

In C++20, the library's initial version underwent various enhancements that enhanced concurrent synchronization in programming, notably std::countingsemaphore and std::binarysemaphore. Each of the primary synchronization methods mentioned earlier was crafted to facilitate thread coordination while also offering specific advantages within the broader concurrency framework.

The std::counting_semaphore operates as a semaphore that maintains an internal tally of the total resources and permissions that are accessible. The consent database initially begins with a satisfactory count, allowing threads to gain access by invoking acquire, which decreases the count. Permits can be relinquished without using release, thereby expanding the total pool of opportunities.

On the flip side, the std::binary_semaphore is a specialized type of semaphore that specifically deals with binary data, allowing for only two states: not one or zero. This semaphore is ideal for handling basic scenarios where thread signaling is required, such as coordinating task initialization or enforcing mutual exclusion straightforwardly. This specific synchronization mechanism often serves as a foundational element for more intricate synchronization strategies, like setting up locks or facilitating communication between threads within producer-consumer architectures.

Syntax:

It has the following syntax:

#include <semaphore>
class std::counting_semaphore {
public:
    // Constructor: Initializes the semaphore with a given count.
    explicit counting_semaphore(int init_count);
    
    // Acquires a permit, decrementing the count.
    void acquire();
    
    // Acquires a permit, blocking if none are available.
    void acquire(int count);
    
    // Releases a permit, incrementing the count.
    void release();
    
    // Releases a specified number of permits.
    void release(int count);
    
    // Non-blocking try acquire operation.
    bool try_acquire();
    
    // Non-blocking try acquire with a timeout.
    bool try_acquire_for(std::chrono::milliseconds timeout);
    
    // Non-blocking try acquire with a deadline.
    bool try_acquire_until(std::chrono::steady_clock::time_point deadline);
};

Explanation:

• ✅ std::counting_semaphore: It initializes with a count that can be any non-negative integer. It provides methods to acquire or release a number of permits. Supports non-blocking operations with optional timeouts.
• ✅ std::binary_semaphore: It initializes as either available (true) or unavailable (false). It provides simple acquire and release methods. Also supports non-blocking operations with timeouts.

Both std::countingsemaphore and std::binarysemaphore elevate the functionality of contemporary C++ in managing concurrency by offering increased expressive and adaptable mechanisms for coordinating threads. These features align with the wider scope of C++20's initiatives to update the standard library and deliver comprehensive assistance for multi-threaded programming.

Properties:

Since the release of C++20, the coordinating mechanisms std::countingsemaphore and std::binarysemaphore exhibit numerous distinctive traits that render them suitable for diverse concurrent needs.

1. std::counting_semaphore

The std::counting_semaphore differentiates itself by the fact that it can handle an amount of available resources and permits, thus rendering it extremely useful in many different kinds of synchronization contexts. It initially begins with a positive integer corresponding to the number of permits available. Threads are capable of communicating with the semaphore using two fundamental operations: acquire and release. The semaphore register has been set up with a non-negative integer count, corresponding to the number of permits available.

• ✅ Acquisition: Whenever a thread calls acquire, the semaphore lowers its internal count. If the total number of permissions is zero, the thread will stall until a permission becomes available. When a running thread uses release, the semaphore increases its own internal count. If the count is zero, the thread blocks until a permit becomes available.
• ✅ Release: Whenever a thread calls release, the semaphore increases therefore, internal count and may wake up blocked threads.
• ✅ Flexibility: This particular kind of semaphore is excellent for administering concurrent accesses, such as prohibiting threads to a shared resource or coordinating access to a pool.

2. std::binary_semaphore

• ✅ As its name suggests, the std::binary_semaphore operates with a binary state: either zero or one. This makes it simpler but very effective for specific use cases like signaling or mutual exclusion.
• ✅ The initialization procedure: The semaphore with binary values has been assigned to the values one (available) and zero (unavailable). Its binary nature makes it ideal for signaling operations.
• ✅ Calling release reduces the internal thread count to one, which renders the semaphore instrument available to other threads.
• ✅ Simplicity: This semaphore may be used for basic signaling or mutual exclusion, among other things limiting thread execution to a critical portion or synchronizing events throughout threads.

In essence, although std::countingsemaphore presents a versatile approach for handling multiple permits and regulating resource access, and std::binarysemaphore delivers a more straightforward binary signaling method. Both are essential components for efficient thread coordination and synchronization in contemporary C++ development.

Example:

In C++20, two fresh synchronization primitives were added: std::countingsemaphore and std::binarysemaphore. These semaphore mechanisms are included in the <semaphore> header and offer methods to manage resource access in concurrent programming.

Here is a summary of each semaphore type:

• ✅ std::counting_semaphore: This semaphore type permits a specific number of threads to access a shared resource. By setting an initial count, you establish the available resource quantity. Threads have the ability to obtain or release resources, with the semaphore keeping track of the available resources.
• ✅ std::binary_semaphore: Operating as a restricted version of the counting semaphore, the binary semaphore restricts the count to either 0 or 1. It functions similarly to a mutex but with distinct operational semantics.

Here is a basic illustration showcasing the utilization of both std::countingsemaphore and std::binarysemaphore:

Example with std::counting_semaphore:

Let's consider a scenario to demonstrate the std::counting_semaphore function in C++.

#include <iostream>
#include <thread>
#include <semaphore>

std::counting_semaphore<3> sem(3); // Semaphore with a maximum of 3 permits

void worker(int id) {
    std::cout << "Thread " << id << " is waiting for a permit.\n";
    sem.acquire(); // Acquire a permit (or wait if none are available)
    std::cout << "Thread " << id << " has acquired a permit.\n";

    // Simulate some work
    std::this_thread::sleep_for(std::chrono::seconds(1));

    std::cout << "Thread " << id << " is releasing the permit.\n";
    sem.release(); // Release a permit
}

int main() {
    std::thread t1(worker, 1);
    std::thread t2(worker, 2);
    std::thread t3(worker, 3);
    std::thread t4(worker, 4); // This thread will have to wait until one permit is released

    t1.join();
    t2.join();
    t3.join();
    t4.join();

    return 0;
}

Output:

Thread Thread 14 is waiting for a permit.
Thread 4 has acquired a permit.
Thread 3 is waiting for a permit.
Thread 3 has acquired a permit.
Thread 2 is waiting for a permit.
Thread 2 has acquired a permit.
 is waiting for a permit.
Thread 4 is releasing the permit.
Thread 2 is releasing the permit.
Thread 1 has acquired a permit.
Thread 3 is releasing the permit.
Thread 1 is releasing the permit.

Example with std::binary_semaphore:

Let's consider a scenario to demonstrate the std::binary_semaphore method in C++.

#include <iostream>
#include <thread>
#include <semaphore>

std::binary_semaphore sem(1); // Binary semaphore with an initial permit

void worker(int id) {
    std::cout << "Thread " << id << " is waiting for the semaphore.\n";
    sem.acquire(); // Acquire the semaphore (or wait if not available)
    std::cout << "Thread " << id << " has acquired the semaphore.\n";

    // Simulate some work
    std::this_thread::sleep_for(std::chrono::seconds(2));

    std::cout << "Thread " << id << " is releasing the semaphore.\n";
    sem.release(); // Release the semaphore
}

int main() {
    std::thread t1(worker, 1);
    std::thread t2(worker, 2); // This thread will have to wait until the semaphore is released

    t1.join();
    t2.join();

    return 0;
}

Output:

Thread 1 is waiting for the semaphore.
Thread 1 has acquired the semaphore.
Thread 2 is waiting for the semaphore.
Thread 1 is releasing the semaphore.
Thread 2 has acquired the semaphore.
Thread 2 is releasing the semaphore.

Explanation:

In the std::counting_semaphore illustration, the code showcases the interaction of several threads with a semaphore controlling a set quantity of permits. The semaphore is set with a cap of 3 permits, allowing a maximum of three threads to obtain a permit concurrently.

The software initiates four threads, where each thread tries to obtain a permit from the semaphore. Threads 1, 2, and 3 succeed in acquiring permits promptly as there are three permits accessible. Upon acquiring a permit, a thread then emulates certain tasks by pausing for a specific duration. Subsequently, upon finishing its tasks, the thread relinquishes the permit to the semaphore, hence freeing it up for other threads to use.

However, thread number 4 needs to wait for one of the permits to become available as threads 1, 2, and 3 have already obtained all permits. After any of these threads releases a permit, Thread 4 can then acquire it to carry out its tasks. The result demonstrates that Thread 4 initiates its operations only after one of the preceding threads has completed its work and freed up a permit. This scenario effectively showcases the capability of std::counting_semaphore in efficiently controlling access to a restricted set of resources.

Complexity:

The intricate characteristics of operations involving std::countingsemaphore and std::binarysemaphore in C++ often scale with the time needed to acquire and release binary semaphores, underscoring their significance in performance. Now, let's delve further into each one.

1. Std::counting_semaphore

You can employ the acquire and acquire_for method for obtaining a process.

Time complexity: Typically, the time complexity of the std::counting_semaphore function is O(1) in most cases. This function halts the thread's execution if the semaphore count reaches zero and resumes when the count becomes positive. The time complexity remains constant for a well-utilized semaphore in normal scenarios. However, in exceptional cases or high contention scenarios, more intricate management may be necessary.

Use the Release Operation (release).

Time complexity: O(1).

Deploying an analog semaphore involves increasing the character count and potentially signaling any threads that are waiting. Utilizing std::binary_semaphore for this purpose is a common practice in concurrent programming.

You can make use of the acquire and acquire_for method for obtaining an operation. Normally, the time complexity remains O(1). The binary semaphore has only two potential states (0 or 1); thus, acquiring it involves a straightforward conditional check that may result in blocking if the desired state is unavailable. The time complexity remains constant as it involves checking and potentially pausing the thread.

The time complexity of the release operation (release) is O(1). Releasing a binary semaphore involves updating the current state to 1 if it was previously 0 and, if needed, signaling a waiting thread. The operation is constant time due to similar reasons as std::counting_semaphore.

Conclusion:

• ✅ Convenience and Efficiency: Both semaphores enable an easily understood API that handles concurrency with effective procedures for common use cases.
• ✅ Use cases: The std::countingsemaphore can be beneficial for controlling access to a set number of resources, such as limiting concurrent connections or managing a pool of worker threads. The std::binarysemaphore is ideal to enable signaling between threads, such as establishing producer-consumer arrangements or orchestrating the completion of tasks.
• ✅ Implementation and Performance: Although synchronization operations maintain a theoretical complexity of unchanging time, their respective positions and practical performance depend on implementation characteristics and embedded in the system considerations, including as thread scheduling and contention.

In summary, the std::countingsemaphore and std::binarysemaphore offer robust and effective solutions for handling concurrency and synchronization in contemporary C++ applications. With their efficient operations and clear semantics, they are advantageous for various concurrent programming situations.