Synchronizacja i sytuacje wyścigu

Gdy wiele wątków korzysta ze współdzielonych zasobów, mogą wystąpić warunki wyścigu prowadzące do nieprzewidywalnych rezultatów.

W tej lekcji dowiedzą się Państwo:

• Czym są warunki wyścigu i jak powstają.
• Jak używać muteksów, aby zapobiegać warunkom wyścigu.
• Jak semafory pomagają zarządzać współdzielonymi zasobami.

Warunek wyścigu występuje, gdy wiele wątków jednocześnie uzyskuje dostęp do współdzielonych danych, co prowadzi do nieprzewidywalnego działania programu.

Przykład:

• Dwa wątki próbują zaktualizować globalny licznik.
• Wartość końcowa może być nieprawidłowa z powodu wzajemnego zakłócania się wątków.

Ten program pokazuje warunek wyścigu, w którym wiele wątków modyfikuje współdzieloną zmienną.

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

Muteks (mechanizm wzajemnego wykluczania) gwarantuje, że w danym momencie tylko jeden wątek uzyskuje dostęp do zasobu.

Funkcje muteksów:

• pthread_mutex_init() - Inicjalizuje muteks.
• pthread_mutex_lock() - Blokuje muteks.
• pthread_mutex_unlock() - Odblokowuje muteks.
• pthread_mutex_destroy() - Niszczy muteks.

Ten program eliminuje warunek wyścigu, używając muteksu do kontrolowania dostępu do współdzielonego licznika.

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

Semafor to licznik używany do kontrolowania dostępu do zasobów.

Najważniejsze funkcje:

• sem_init() - Inicjalizuje semafor.
• sem_wait() - Zmniejsza wartość semafora.
• sem_post() - Zwiększa wartość semafora.
• sem_destroy() - Niszczy semafor.

Ten program używa semafora do zarządzania dostępem do współdzielonego zasobu.

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

Aby uniknąć warunków wyścigu:

• Używaj muteksów do ochrony współdzielonych zmiennych.
• Używaj semaforów do zarządzania zasobami.
• W miarę możliwości ograniczaj korzystanie ze współdzielonych zasobów.

W tej lekcji poznali Państwo:

• Czym są warunki wyścigu i jak powstają.
• Jak używać muteksów, aby zapobiegać warunkom wyścigu.
• Jak semafory pomagają zarządzać dostępem do współdzielonych zasobów.

To kończy sekcję dotyczącą wielowątkowości i współbieżności w języku C!