Synchronization: Mutexes and Semaphores in C

What You’ll Learn 📚

• Understanding the need for synchronization
• Core concepts of mutexes and semaphores
• How to implement mutexes and semaphores in C
• Common pitfalls and how to avoid them
• Practical examples and exercises

Introduction to Synchronization

Imagine you’re in a kitchen with multiple chefs, all trying to use the same set of ingredients. Without coordination, chaos ensues! In programming, synchronization ensures that multiple threads can work together without stepping on each other’s toes. This is crucial in multi-threaded applications where shared resources are involved.

Key Terminology

• Thread: A sequence of executable instructions that can be managed independently by a scheduler.
• Mutex: Short for ‘mutual exclusion’, it’s a locking mechanism used to synchronize access to a resource.
• Semaphore: A signaling mechanism to control access, allowing multiple threads to access a finite number of resources.

Simple Example: Mutex

#include <stdio.h>
#include <pthread.h>

pthread_mutex_t lock;
int shared_resource = 0;

void* increment(void* arg) {
    pthread_mutex_lock(&lock);
    shared_resource++;
    printf("Resource value: %d\n", shared_resource);
    pthread_mutex_unlock(&lock);
    return NULL;
}

int main() {
    pthread_t threads[2];
    pthread_mutex_init(&lock, NULL);

    for (int i = 0; i < 2; i++) {
        pthread_create(&threads[i], NULL, increment, NULL);
    }

    for (int i = 0; i < 2; i++) {
        pthread_join(threads[i], NULL);
    }

    pthread_mutex_destroy(&lock);
    return 0;
}

Progressively Complex Examples

Example 2: Semaphore Basics

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

sem_t semaphore;
int shared_resource = 0;

void* increment(void* arg) {
    sem_wait(&semaphore);
    shared_resource++;
    printf("Resource value: %d\n", shared_resource);
    sem_post(&semaphore);
    return NULL;
}

int main() {
    pthread_t threads[3];
    sem_init(&semaphore, 0, 1);

    for (int i = 0; i < 3; i++) {
        pthread_create(&threads[i], NULL, increment, NULL);
    }

    for (int i = 0; i < 3; i++) {
        pthread_join(threads[i], NULL);
    }

    sem_destroy(&semaphore);
    return 0;
}

Example 3: Multiple Resources with Semaphores

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

#define NUM_RESOURCES 2
sem_t semaphore;
int shared_resources[NUM_RESOURCES] = {0, 0};

void* increment(void* arg) {
    int index = *(int*)arg;
    sem_wait(&semaphore);
    shared_resources[index]++;
    printf("Resource %d value: %d\n", index, shared_resources[index]);
    sem_post(&semaphore);
    return NULL;
}

int main() {
    pthread_t threads[4];
    int indices[4] = {0, 1, 0, 1};
    sem_init(&semaphore, 0, NUM_RESOURCES);

    for (int i = 0; i < 4; i++) {
        pthread_create(&threads[i], NULL, increment, &indices[i]);
    }

    for (int i = 0; i < 4; i++) {
        pthread_join(threads[i], NULL);
    }

    sem_destroy(&semaphore);
    return 0;
}

Common Questions and Answers

1. What is a race condition?

   A race condition occurs when two or more threads access shared data and try to change it at the same time. The outcome depends on the sequence of execution, which can lead to unpredictable results.

2. Why use mutexes over semaphores?

   Mutexes are typically used when you need mutual exclusion for a resource, ensuring only one thread accesses it at a time. Semaphores are more flexible, allowing multiple threads to access a limited number of resources.

3. Can semaphores be used for mutual exclusion?

   Yes, by initializing a semaphore to 1, it can be used similarly to a mutex for mutual exclusion.

4. What happens if a thread crashes while holding a mutex?

   If a thread crashes while holding a mutex, the mutex remains locked, potentially causing a deadlock. Proper error handling and timeout mechanisms can help mitigate this risk.

5. How do I choose between mutexes and semaphores?

   Use mutexes for exclusive access to a single resource. Use semaphores when managing access to multiple instances of a resource or when signaling between threads.

Troubleshooting Common Issues

If your program hangs, check for deadlocks where two or more threads are waiting indefinitely for resources held by each other.

Always initialize and destroy mutexes and semaphores properly to avoid resource leaks.

Remember that synchronization mechanisms add overhead. Use them judiciously to balance performance and safety.

Practice Exercises

• Create a program using a mutex to manage access to a shared counter incremented by 10 threads.
• Modify the semaphore example to allow up to 3 threads to access the resource simultaneously.
• Experiment with adding delays in threads to simulate real-world scenarios and observe the effects on synchronization.

For further reading, check out the pthread_mutex_lock documentation and sem_wait documentation.

Keep practicing, and soon synchronization will become second nature! 💪