mutex est utilisé pour éviter les conditions de concurrence entre plusieurs threads.
tandis que le sémaphore est utilisé comme élément de synchronisation utilisé dans plusieurs processus.
mutex ne peut pas être remplacé par un sémaphore binaire car un processus attend le sémaphore tandis que l'autre processus libère le sémaphore. Dans le cas où mutex, l'acquisition et la libération sont gérées par le même.
Je vais parler de Mutex vs Binary-Semaphore. Vous utilisez évidemment le mutex pour empêcher les données d'un thread d'être accessibles par un autre thread en même temps.
(Supposons que vous venez d'appeler lock() et que vous êtes en train d'accéder à une donnée. Cela signifie que vous ne vous attendez pas à ce qu'un autre thread (ou une autre instance du même code de thread) accède aux mêmes données verrouillées par le même mutex. Autrement dit, si c'est le même code de thread qui est exécuté sur une instance de thread différente, frappe le verrou, alors le lock() devrait bloquer le flux de contrôle.)
Cela s'applique à un thread qui utilise un code de thread différent, qui accède également aux mêmes données et qui est également verrouillé par le même mutex.
Dans ce cas, vous êtes toujours en train d'accéder aux données et vous pouvez prendre, disons, 15 secondes supplémentaires pour atteindre le déverrouillage du mutex (afin que l'autre thread bloqué dans le verrouillage du mutex se débloque et permette au contrôle de accéder aux données).
Avez-vous déjà permis à un autre thread de déverrouiller simplement le même mutex et, à son tour, d'autoriser le thread qui attend déjà (bloquant) dans le verrou mutex à débloquer et à accéder aux données ? (J'espère que vous avez compris ce que je dis ici.)
Selon la définition universelle convenue,
- avec "mutex", cela ne peut pas arriver. Aucun autre fil ne peut déverrouiller le verrouillage de votre fil
- avec "binary-semaphore", cela peut arriver. Tout autre fil peut déverrouiller le verrou de votre fil
Donc, si vous êtes très particulier sur l'utilisation du sémaphore binaire au lieu du mutex, alors vous devriez être très prudent dans la "portée" des verrous et déverrouillages, je veux dire, que chaque flux de contrôle qui frappe chaque verrou doit frapper un appel de déverrouillage et aussi il ne devrait pas y avoir de "premier déverrouillage", mais plutôt "premier verrouillage".
L'exemple des toilettes
Mute :
Est une clé pour une toilette. Une personne peut avoir la clé - occuper les toilettes - à la fois. Une fois terminé, la personne donne (libère) la clé à la personne suivante dans la file d'attente.
"Les mutex sont généralement utilisés pour sérialiser l'accès à une section de code réentrant qui ne peut pas être exécutée simultanément par plus d'un thread. Un objet mutex n'autorise qu'un seul thread dans une section contrôlée, forçant les autres threads qui tentent d'accéder à cette section attendre que le premier fil soit sorti de cette section."
(Un mutex est en réalité un sémaphore de valeur 1.)
Sémaphore :
Est le nombre de clés de toilettes identiques gratuites. Par exemple, disons que nous avons quatre toilettes avec des serrures et des clés identiques. Le nombre de sémaphores - le nombre de clés - est défini sur 4 au début (les quatre toilettes sont gratuites), puis la valeur de comptage est décrémentée au fur et à mesure que les gens entrent. Si toutes les toilettes sont pleines, c'est-à-dire. il n'y a plus de clés libres, le nombre de sémaphores est 0. Maintenant, lorsque l'éq. une personne quitte les toilettes, le sémaphore passe à 1 (une clé gratuite) et est donné à la personne suivante dans la file d'attente.
"Un sémaphore limite le nombre d'utilisateurs simultanés d'une ressource partagée jusqu'à un nombre maximum. Les threads peuvent demander l'accès à la ressource (en décrémentant le sémaphore), et peuvent signaler qu'ils ont fini d'utiliser la ressource (en incrémentant le sémaphore)."
Source
les sémaphores ont un compteur synchronisé et les mutex sont juste binaires (vrai/faux).
Un sémaphore est souvent utilisé comme mécanisme définitif pour répondre au nombre d'éléments d'une ressource en cours d'utilisation -- par exemple, un objet qui représente n threads de travail peut utiliser un sémaphore pour compter le nombre de threads de travail disponibles.
La vérité est que vous pouvez représenter un sémaphore par un INT qui est synchronisé par un mutex.