Semaphore vs Mutex in C++: What's the Difference?

Can you explain the difference between semaphore and mutex in C++?

Sure! A mutex is a locking mechanism that ensures only one thread can access a resource at a time, while a semaphore allows multiple threads to access a limited number of resources.

When should I use a semaphore instead of a mutex?

You should use a semaphore when you need to control access to a pool of resources, like a fixed number of connections, whereas a mutex is ideal for protecting a single resource.

Can you give me an example of how to implement a semaphore in C++?

Certainly! You can use the std::counting_semaphore from the C++20 standard library. Here's a simple example:

#include <semaphore.h>
#include <thread>
#include <iostream>

std::counting_semaphore<3> sem(3); // Allow 3 threads to access

void accessResource(int id) {
    sem.acquire(); // Wait for access
    std::cout << "Thread " << id << " is accessing the resource.\n";
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout << "Thread " << id << " is done.\n";
    sem.release(); // Release access
}

int main() {
    std::thread threads[5];
    for (int i = 0; i < 5; ++i) {
        threads[i] = std::thread(accessResource, i);
    }
    for (auto& th : threads) th.join();
    return 0;
}

What are the potential pitfalls of using semaphores?

Some pitfalls include potential deadlocks if not managed properly, and they can be more complex to use than mutexes, leading to harder-to-maintain code.