What are some examples of race conditions in pthreads?

What are some examples of race conditions in pthreads?

Race conditions occur when multiple threads access shared data concurrently, leading to unpredictable results. For example, if two threads increment a shared counter without proper synchronization, they might read the same value and both increment it, resulting in a lost update.

Can you give me a code example of that?

Sure! Here's a simple example in C:

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

int counter = 0;

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

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

In this example, both threads increment the shared counter, which can lead to a race condition.

How can I prevent race conditions in my code?

You can prevent race conditions by using synchronization mechanisms like mutexes or semaphores. For instance, wrapping the increment operation in a mutex lock ensures that only one thread can modify the counter at a time.

Can you show me how to use a mutex in that example?

Absolutely! Here's the modified code using a mutex:

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

int counter = 0;
pthread_mutex_t lock;

void* increment(void* arg) {
    for (int i = 0; i < 100000; 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, increment, NULL);
    pthread_create(&t2, NULL, increment, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    printf("Final counter value: %d\n", counter);
    pthread_mutex_destroy(&lock);
    return 0;
}

This ensures that the increment operation is thread-safe.