Sincronizzazione e race condition

Quando più thread accedono a risorse condivise, possono verificarsi race condition, che producono risultati imprevedibili.

In questa lezione imparerà:

• Che cosa sono le race condition e come si verificano.
• Come usare i mutex per prevenire le race condition.
• Come i semafori aiutano a gestire le risorse condivise.

Che cos'è una race condition?

Una race condition si verifica quando più thread accedono contemporaneamente a dati condivisi, causando un comportamento imprevedibile.

Esempio:

• Due thread tentano di aggiornare un contatore globale.
• Il valore finale potrebbe essere errato a causa delle interferenze.

Esempio: race condition nel multithreading

Questo programma mostra una race condition in cui più thread modificano una variabile condivisa.

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

Prevenzione delle race condition con un mutex

Un mutex (mutua esclusione) garantisce che solo un thread alla volta acceda a una risorsa.

Funzioni dei mutex:

• pthread_mutex_init() - Inizializza un mutex.
• pthread_mutex_lock() - Blocca il mutex.
• pthread_mutex_unlock() - Sblocca il mutex.
• pthread_mutex_destroy() - Distrugge il mutex.

Esempio: uso di un mutex per prevenire le race condition

Questo programma risolve la race condition usando un mutex per controllare l'accesso al contatore condiviso.

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

Che cos'è un semaforo?

Un semaforo è un contatore usato per controllare l'accesso alle risorse.

Funzioni principali:

• sem_init() - Inizializza un semaforo.
• sem_wait() - Diminuisce il valore del semaforo.
• sem_post() - Aumenta il valore del semaforo.
• sem_destroy() - Distrugge il semaforo.

Esempio: uso dei semafori per la sincronizzazione

Questo programma usa un semaforo per gestire l'accesso a una risorsa condivisa.

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

Best practice per la sincronizzazione dei thread

Per evitare le race condition:

• Usi i mutex per proteggere le variabili condivise.
• Usi i semafori per la gestione delle risorse.
• Riduca al minimo l'uso di risorse condivise, quando possibile.

Riepilogo

In questa lezione ha imparato:

• Che cosa sono le race condition e come si verificano.
• Come usare i mutex per prevenire le race condition.
• Come i semafori aiutano a gestire l'accesso alle risorse condivise.

Con questo si conclude la sezione Multithreading e concorrenza in C.