Synchronisation et conditions de concurrence

Lorsque plusieurs fils d’exécution accèdent à des ressources partagées, des conditions de concurrence peuvent survenir et entraîner des résultats imprévisibles.

Dans cette leçon, vous apprendrez :

• Ce que sont les conditions de concurrence et comment elles surviennent.
• Comment utiliser des mutex pour empêcher les conditions de concurrence.
• Comment les sémaphores aident à gérer les ressources partagées.

Une condition de concurrence survient lorsque plusieurs fils d’exécution accèdent simultanément à des données partagées, ce qui entraîne un comportement imprévisible.

Exemple :

• Deux fils d’exécution tentent de mettre à jour un compteur global.
• La valeur finale peut être incorrecte en raison des interférences.

Ce programme montre une condition de concurrence dans laquelle plusieurs fils d’exécution modifient une variable partagée.

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

Un mutex (exclusion mutuelle) garantit qu’un seul fil d’exécution accède à une ressource à la fois.

Fonctions de mutex :

• pthread_mutex_init() - Initialise un mutex.
• pthread_mutex_lock() - Verrouille le mutex.
• pthread_mutex_unlock() - Déverrouille le mutex.
• pthread_mutex_destroy() - Détruit le mutex.

Ce programme corrige la condition de concurrence en utilisant un mutex pour contrôler l’accès au compteur partagé.

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

Un sémaphore est un compteur utilisé pour contrôler l’accès aux ressources.

Fonctions principales :

• sem_init() - Initialise un sémaphore.
• sem_wait() - Diminue la valeur du sémaphore.
• sem_post() - Augmente la valeur du sémaphore.
• sem_destroy() - Détruit le sémaphore.

Ce programme utilise un sémaphore pour gérer l’accès à une ressource partagée.

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

Pour éviter les conditions de concurrence :

• Utilisez des mutex pour protéger les variables partagées.
• Utilisez des sémaphores pour gérer les ressources.
• Réduisez autant que possible l’utilisation des ressources partagées.

Dans cette leçon, vous avez appris :

• Ce que sont les conditions de concurrence et comment elles surviennent.
• Comment utiliser des mutex pour empêcher les conditions de concurrence.
• Comment les sémaphores aident à gérer l’accès aux ressources partagées.

Cette leçon conclut la section consacrée au multithreading et à la concurrence en C !