What is the difference between mutex and semaphore in C++?

What is the difference between mutex and semaphore in C++?

A mutex (mutual exclusion) is a locking mechanism that allows only one thread to access a resource at a time, while a semaphore is a signaling mechanism that can allow multiple threads to access a resource up to a certain limit.

Can you give me an example of how to use a mutex in C++?

Sure! Here's a simple example:

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx;

void printNumbers(int id) {
    mtx.lock();  // Lock the mutex
    for (int i = 0; i < 5; ++i) {
        std::cout << "Thread " << id << ": " << i << std::endl;
    }
    mtx.unlock();  // Unlock the mutex
}

int main() {
    std::thread t1(printNumbers, 1);
    std::thread t2(printNumbers, 2);
    t1.join();
    t2.join();
    return 0;
}

What about semaphores? Can you show me an example?

Certainly! Here's an example of using a semaphore in C++:

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

std::binary_semaphore sem(1);  // Initialize semaphore with 1

void accessResource(int id) {
    sem.acquire();  // Acquire the semaphore
    std::cout << "Thread " << id << " is accessing the resource." << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout << "Thread " << id << " is done accessing the resource." << std::endl;
    sem.release();  // Release the semaphore
}

int main() {
    std::thread t1(accessResource, 1);
    std::thread t2(accessResource, 2);
    t1.join();
    t2.join();
    return 0;
}