pthreads mutex vs sémaphore
Quelle est la différence entre les sémaphores et les mutex fournis par la bibliothèque pthread?
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.
Je vais parler de Mutex vs Binary-Semaphore. Vous utilisez évidemment mutex pour empêcher les données d'un thread d'être accédées par un autre thread en même temps.
(Supposons que vous venez d'appeler lock () et que vous êtes en train d'accéder à des données. 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, s'il s'agit du même code de thread exécuté sur une instance de thread différente, il frappe le verrou, puis le verrou () doit 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 mutex (de sorte que l'autre thread qui est bloqué dans le verrouillage mutex se débloque et permette au contrôle de accéder aux données).
Avez-vous déjà autorisé un autre thread à déverrouiller le même mutex et à son tour, permettre au thread qui attend déjà (blocage) dans le verrou mutex de débloquer et d'accéder aux données? (J'espère que vous avez ce que je dis ici.)
Conformément à la définition universelle convenue,
- avec "mutex" cela ne peut pas arriver. Aucun autre thread ne peut déverrouiller le verrou de votre thread
- avec "binaire-sémaphore" cela peut arriver. Tout autre fil peut déverrouiller le verrou de votre fil
Donc, si vous êtes très particulier à propos de l'utilisation d'un sémaphore binaire au lieu d'un mutex, alors vous devez être très prudent dans la "délimitation" des verrous et des 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 de "premier déverrouillage".
mutex est utilisé pour éviter la condition de concurrence entre plusieurs threads.
tandis que le sémaphore est utilisé comme élément de synchronisation utilisé sur 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 traitées par le même.
L'exemple des toilettes
Mutex:
Est la clé des toilettes. Une personne peut avoir la clé - occuper les toilettes - à la fois. Une fois terminé, la personne remet (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 rentrant qui ne peut pas être exécutée simultanément par plusieurs threads. Un objet mutex autorise uniquement un thread dans une section contrôlée, forçant d'autres threads qui tentent d'accéder à cette section d'attendre que le premier thread soit sorti de cette section. "
(Un mutex est vraiment un sémaphore de valeur 1.)
Sémaphore:
Est le nombre de clés de toilettes identiques et 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 réglé sur 4 au début (les quatre toilettes sont gratuites), puis la valeur de comptage est décrémentée lorsque 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, quand éq. une personne quitte les toilettes, le sémaphore est porté à 1 (une clé libre) et remis à 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 maximal. Les threads peuvent demander l'accès à la ressource (décrémenter le sémaphore) et peuvent signaler qu'ils ont fini d'utiliser la ressource (incrémenter le sémaphore)."
La différence entre semaphore et mutex est la différence entre mécanisme et modèle. La différence réside dans leur objectif (intention) et dans leur fonctionnement (comportemental).
Les mutex, barrier, pipeline sont modèles de programmation parallèle. Mutex est utilisé (prév) pour protéger un critical section et assurez-vous mutual exclusion. Barrier fait attendre les agents (thread/processus).
L'une des caractéristiques (comportement) du modèle mutex est que seuls les agents autorisés (processus ou thread) peuvent entrer dans une section critique et seuls ces agents peuvent obtenir volontairement hors de cela.
Il y a des cas où mutex autorise un seul agent à la fois. Il existe des cas où il autorise plusieurs agents (plusieurs lecteurs) et interdit certains autres agents (écrivains).
semaphore est un mécanisme qui peut être utilisé (destiné) pour implémenter différents modèles. C'est (comportement) généralement un flag (éventuellement protégé par exclusion mutuelle). (Un fait intéressant est que même le modèle mutex peut être utilisé pour implémenter le sémaphore).
Dans la culture populaire, semaphores sont des mécanismes fournis par les noyaux et mutexes sont fournis par la bibliothèque de l'espace utilisateur.
Notez qu'il existe des idées fausses sur semaphores et mutexes. Il indique que semaphores sont utilisés pour synchronization. Et mutexes a ownership. Cela est dû aux livres OS populaires. Mais la vérité est que tous les mutex, sémaphores et barrières sont utilisés pour la synchronisation. L'intention de mutex n'est pas ownership mais mutual exclusion. Cette idée fausse a donné lieu à une question d'interview populaire demandant la différence entre mutexes et binary-semaphores.
Sommaire,
- mutex, exclusion mutuelle
- sémaphore, implémenter des modèles de conception parallèles
- mutex, seuls les agents autorisés entrent dans la section critique et seuls ceux-ci peuvent sortir
- sémaphore, entrez si le drapeau indique go, sinon attendez que quelqu'un change le drapeau
Dans la perspective de la conception, mutex ressemble plus à state-pattern où l'algorithme sélectionné par l'état peut changer l'état. Le binary-semaphore ressemble plus à strategy-pattern où l'algorithme externe peut changer l'état et éventuellement l'algorithme/la stratégie sélectionnée pour s'exécuter.
Ces deux articles expliquent de grands détails sur mutex vs sémaphores Aussi this la réponse de débordement de pile indique la réponse similaire.
Le sémaphore est plus utilisé comme indicateur, pour lequel vous n'avez vraiment pas besoin d'apporter RTOS/OS. Le sémaphore peut être accidentellement ou délibérément modifié par d'autres threads (par exemple en raison d'un mauvais codage). Lorsque vous thread utilise mutex, il possède les ressources. Aucun autre thread ne peut y accéder avant que la ressource ne soit libre.
Les mutex ne peuvent être appliqués qu'aux threads d'un même processus et ne fonctionnent pas entre les processus comme le font les sémaphores.