Synchronization and Race Conditions

When multiple threads access shared resources, race conditions can occur, leading to unpredictable results.

In this lesson, you will learn:

• What race conditions are and how they occur.
• How to use mutexes to prevent race conditions.
• How semaphores help manage shared resources.

A race condition occurs when multiple threads access shared data simultaneously, leading to unpredictable behavior.

Example:

• Two threads try to update a global counter.
• The final value may be incorrect due to interference.

This program demonstrates a race condition where multiple threads modify a shared variable.

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

int counter = 0;

void *incrementCounter(void *arg) {
    for (int i = 0; i < 1000000; i++) {
        counter++;
    }
    return NULL;
}

int main() {
    pthread_t t1, t2;
    pthread_create(&t1, NULL, incrementCounter, NULL);
    pthread_create(&t2, NULL, incrementCounter, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    printf("Final counter value: %d\n", counter);
    return 0;
}

A mutex (mutual exclusion) ensures only one thread accesses a resource at a time.

Mutex functions:

• pthread_mutex_init() - Initializes a mutex.
• pthread_mutex_lock() - Locks the mutex.
• pthread_mutex_unlock() - Unlocks the mutex.
• pthread_mutex_destroy() - Destroys the mutex.

This program fixes the race condition by using a mutex to control access to the shared counter.

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

int counter = 0;
pthread_mutex_t lock;

void *incrementCounter(void *arg) {
    for (int i = 0; i < 1000000; i++) {
        pthread_mutex_lock(&lock);
        counter++;
        pthread_mutex_unlock(&lock);
    }
    return NULL;
}

int main() {
    pthread_t t1, t2;
    pthread_mutex_init(&lock, NULL);
    pthread_create(&t1, NULL, incrementCounter, NULL);
    pthread_create(&t2, NULL, incrementCounter, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_mutex_destroy(&lock);
    printf("Final counter value: %d\n", counter);
    return 0;
}

A semaphore is a counter used to control access to resources.

Key functions:

• sem_init() - Initializes a semaphore.
• sem_wait() - Decreases the semaphore value.
• sem_post() - Increases the semaphore value.
• sem_destroy() - Destroys the semaphore.

This program uses a semaphore to manage access to a shared resource.

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

sem_t sem;

void *task(void *arg) {
    sem_wait(&sem);
    printf("Thread %d is executing\n", *(int *)arg);
    sem_post(&sem);
    return NULL;
}

int main() {
    pthread_t t1, t2;
    int id1 = 1, id2 = 2;
    sem_init(&sem, 0, 1);
    pthread_create(&t1, NULL, task, &id1);
    pthread_create(&t2, NULL, task, &id2);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    sem_destroy(&sem);
    return 0;
}

To avoid race conditions:

• Use mutexes to protect shared variables.
• Use semaphores for resource management.
• Minimize shared resource usage where possible.

In this lesson, you learned:

• What race conditions are and how they occur.
• How to use mutexes to prevent race conditions.
• How semaphores help manage access to shared resources.

This concludes the Multithreading and Concurrency section in C!