What are semaphores and mutexes in C++?

Can you explain the difference between semaphores and mutexes in C++?

Sure! Semaphores are signaling mechanisms that control access to a resource by multiple threads, while mutexes are used to ensure that only one thread can access a resource at a time.

Can you provide a code example of using a semaphore in C++?

Absolutely! Here's a simple example:

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

sem_t semaphore;

void* threadFunction(void* arg) {
    sem_wait(&semaphore);
    std::cout << "Thread " << arg << " is in the critical section." << std::endl;
    sem_post(&semaphore);
    return nullptr;
}

int main() {
    sem_init(&semaphore, 0, 1);
    pthread_t threads[5];
    for (int i = 0; i < 5; ++i) {
        pthread_create(&threads[i], nullptr, threadFunction, (void*)i);
    }
    for (int i = 0; i < 5; ++i) {
        pthread_join(threads[i], nullptr);
    }
    sem_destroy(&semaphore);
    return 0;
}

This code initializes a semaphore and uses it to control access to a critical section.

What about a mutex example?

Here's a simple mutex example:

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

std::mutex mtx;

void threadFunction(int id) {
    mtx.lock();
    std::cout << "Thread " << id << " is in the critical section." << std::endl;
    mtx.unlock();
}

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

This code uses a mutex to ensure that only one thread can access the critical section at a time.