Comment les mutex empêchent-ils la corruption des données dans les programmes multithread ?

Exemple de mutex et procédure pas à pas

Dans la programmation multithread, les mutex jouent un rôle crucial dans la coordination de l'accès aux ressources partagées. Cependant, comprendre leur fonction peut être difficile pour les débutants. Examinons une explication simplifiée, en utilisant une analogie et un exemple de programme.

Analogie : la cabine téléphonique

Imaginez une rue bondée avec une seule cabine téléphonique publique. Plusieurs personnes (threads) souhaitent utiliser le téléphone (ressource partagée), mais une seule personne à la fois peut se trouver à l'intérieur (exclusion mutuelle). Pour éviter le chaos, une poignée de porte (mutex) est installée.

Lorsque la première personne entre dans la cabine et saisit la poignée, elle établit un verrou sur le mutex. Cela indique aux autres personnes que la ressource est en cours d'utilisation. Pendant que la personne est à l'intérieur, personne d'autre ne peut saisir la poignée car elle est verrouillée (exclusion mutuelle).

Interaction Thread et Mutex

Dans un programme multithread, les threads représentent les gens dans notre analogie. Un mutex est une variable qui contrôle l'accès aux ressources partagées. Pour protéger une ressource, un thread doit d'abord acquérir le verrou du mutex, qui empêche les autres threads d'accéder à la ressource.

Une fois qu'un thread a acquis le verrou, il peut accéder exclusivement à la ressource. Une fois terminé, il libère le verrou, permettant à un autre thread de l'acquérir. Cela empêche l'accès simultané aux ressources partagées, ce qui peut entraîner une corruption des données.

Exemple de programme

Voici un exemple simple en C 11 qui montre le fonctionnement des mutex :

#include <iostream>
#include <thread>
#include <mutex>

std::mutex m;
int i = 0;

void makeACallFromPhoneBooth()
{
    m.lock();
    std::cout << i << " Hello Wife" << std::endl;
    i++;
    m.unlock();
}

int main()
{
    std::thread man1(makeACallFromPhoneBooth);
    std::thread man2(makeACallFromPhoneBooth);
    std::thread man3(makeACallFromPhoneBooth);

    man1.join();
    man2.join();
    man3.join();
}

Dans cet exemple, la variable m sert de mutex. Cela garantit qu'un seul thread peut utiliser la variable partagée i à la fois. Sans le mutex, plusieurs threads pourraient modifier simultanément i, conduisant à des résultats inexacts.

Syntaxe de verrouillage

La syntaxe pthread_mutex_lock(&mutex1) acquiert le verrou sur le mutex nommé mutex1. Cela signale aux autres threads que la région de code protégée par le mutex est actuellement verrouillée.

Les threads doivent connaître les régions verrouillées afin de pouvoir éviter d'y accéder pendant que le verrou est maintenu. Si un thread tente d'accéder à une région verrouillée, il sera bloqué jusqu'à ce que le verrou soit libéré.

Conclusion

Les mutex sont des mécanismes essentiels dans la programmation multithread, garantissant que le partage les ressources sont accessibles de manière contrôlée et synchronisée. Comprendre leur fonction est crucial pour éviter la corruption des données et obtenir un multithreading efficace.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!