Synchronisierung und Race Conditions

Wenn mehrere Threads auf gemeinsam genutzte Ressourcen zugreifen, können Race Conditions auftreten und zu unvorhersehbaren Ergebnissen führen.

In dieser Lektion lernen Sie:

• Was Race Conditions sind und wie sie entstehen.
• Wie Sie Mutexes verwenden, um Race Conditions zu verhindern.
• Wie Semaphore bei der Verwaltung gemeinsam genutzter Ressourcen helfen.

Was ist eine Race Condition?

Eine Race Condition tritt auf, wenn mehrere Threads gleichzeitig auf gemeinsam genutzte Daten zugreifen und dadurch ein unvorhersehbares Verhalten entsteht.

Beispiel:

• Zwei Threads versuchen, einen globalen Zähler zu aktualisieren.
• Der endgültige Wert kann aufgrund gegenseitiger Beeinflussung falsch sein.

Beispiel: Race Condition beim Multithreading

Dieses Programm zeigt eine Race Condition, bei der mehrere Threads eine gemeinsam genutzte Variable ändern.

#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;
}

Race Conditions mit einem Mutex verhindern

Ein Mutex (gegenseitiger Ausschluss) stellt sicher, dass immer nur ein Thread auf eine Ressource zugreift.

Mutex-Funktionen:

• pthread_mutex_init() - Initialisiert einen Mutex.
• pthread_mutex_lock() - Sperrt den Mutex.
• pthread_mutex_unlock() - Entsperrt den Mutex.
• pthread_mutex_destroy() - Zerstört den Mutex.

Beispiel: Race Conditions mit einem Mutex verhindern

Dieses Programm behebt die Race Condition, indem ein Mutex den Zugriff auf den gemeinsam genutzten Zähler steuert.

#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;
}

Was ist ein Semaphor?

Ein Semaphor ist ein Zähler, der den Zugriff auf Ressourcen steuert.

Wichtige Funktionen:

• sem_init() - Initialisiert einen Semaphor.
• sem_wait() - Verringert den Wert des Semaphors.
• sem_post() - Erhöht den Wert des Semaphors.
• sem_destroy() - Zerstört den Semaphor.

Beispiel: Semaphore zur Synchronisierung verwenden

Dieses Programm verwendet einen Semaphor, um den Zugriff auf eine gemeinsam genutzte Ressource zu verwalten.

#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;
}

Bewährte Vorgehensweisen zur Thread-Synchronisierung

So vermeiden Sie Race Conditions:

• Verwenden Sie Mutexes, um gemeinsam genutzte Variablen zu schützen.
• Verwenden Sie Semaphore zur Ressourcenverwaltung.
• Minimieren Sie nach Möglichkeit die Nutzung gemeinsam genutzter Ressourcen.

Zusammenfassung

In dieser Lektion haben Sie Folgendes gelernt:

• Was Race Conditions sind und wie sie entstehen.
• Wie Sie Mutexes verwenden, um Race Conditions zu verhindern.
• Wie Semaphore den Zugriff auf gemeinsam genutzte Ressourcen verwalten helfen.

Damit ist der Abschnitt zu Multithreading und Nebenläufigkeit in C abgeschlossen.