Question Différence entre le sémaphore binaire et le mutex


Y a-t-il une différence entre un sémaphore binaire et un mutex ou sont-ils essentiellement les mêmes?


641
2017-09-15 13:23


origine


Réponses:


Elles sont NE PAS la même chose. Ils sont utilisés à des fins différentes!
Alors que les deux types de sémaphores ont un état plein / vide et utilisent la même API, leur utilisation est très différente.

Sémaphores d'exclusion mutuelle
Les sémaphores d'exclusion mutuelle sont utilisés pour protéger les ressources partagées (structure de données, fichier, etc.).

Un sémaphore Mutex est "détenu" par la tâche qui le prend. Si la tâche B tente de semGive un mutex actuellement détenu par la tâche A, l'appel de la tâche B renverra une erreur et échouera.

Les mutex utilisent toujours la séquence suivante:

  - SemTake
  - Section critique
  - SemGive

Voici un exemple simple:

  Enfiler un fil B
   Prenez Mutex
     données d'accès
     ... Prenez Mutex <== Bloquer
     ...
   Donner des données d'accès Mutex <== Débloquer
                                  ...
                                Donner Mutex

Sémaphore binaire
Les sémaphores binaires répondent à une question totalement différente:

  • La tâche B est en attente de quelque chose qui se passe (un capteur est déclenché par exemple).
  • Les déclenchements de capteur et un cycle de service d'interruption s'exécute. Il doit notifier une tâche du voyage.
  • La tâche B doit être exécutée et prendre les mesures appropriées pour le déclenchement du capteur. Puis retournez à l'attente.

   Task A                      Task B
   ...                         Take BinSemaphore   <== wait for something
   Do Something Noteworthy
   Give BinSemaphore           do something    <== unblocks

Notez qu'avec un sémaphore binaire, B peut prendre le sémaphore et A le donner.
Encore une fois, un sémaphore binaire ne protège PAS une ressource de l'accès. L'acte de donner et de prendre un sémaphore est fondamentalement découplé.
Il est généralement peu logique pour la même tâche de donner et de prendre le même sémaphore binaire.


550
2017-09-17 18:13



Mutex ne peut être libéré que par le thread qui l'a acquis, alors que vous pouvez signaler le sémaphore à partir de n'importe quel autre thread (ou processus), donc les sémaphores conviennent mieux à certains problèmes de synchronisation comme producteur-consommateur.

Sous Windows, les sémaphores binaires ressemblent plus à des objets d'événement qu'à des mutex.


392
2017-09-15 13:29



L'exemple de la toilette est une analogie agréable:

Mutex:

Est-ce une clé pour une toilette. Une personne peut   avoir la clé - occuper les toilettes - à   le temps. Lorsque vous avez terminé, la personne   donne (libère) la clé à la prochaine   personne dans la file d'attente.

Officiellement: "Les mutex sont typiquement   utilisé pour sérialiser l'accès à une section   du code de rentrée qui ne peut pas être   exécuté simultanément par plus d'un   fil. Un objet mutex ne permet qu'un   enfiler dans une section contrôlée,   forçant d'autres threads qui tentent de   accéder à cette section pour attendre   jusqu'à ce que le premier thread est sorti de   cette section. "Ref: Symbian Developer   Bibliothèque

(Un mutex est vraiment un sémaphore avec   valeur 1.)

Sémaphore:

Est-ce le nombre de toilettes identiques gratuites   clés. Exemple, disons que nous avons quatre   toilettes avec serrures et clés identiques.   Le nombre de sémaphores - le nombre de   touches - est réglé sur 4 au début   quatre toilettes sont gratuites), puis le nombre   la valeur est décrémentée que les gens sont   entrer. 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 eq.   une personne quitte les toilettes,   sémaphore est augmenté à 1 (un   clé), et donné à la prochaine personne   La queue.

Officiellement: "Un sémaphore restreint la   nombre d'utilisateurs simultanés d'un   ressource partagée jusqu'à un maximum   nombre. Les threads peuvent demander l'accès à   la ressource (décrémentant la   sémaphore), et peut signaler qu'ils   avoir fini d'utiliser la ressource   (incrémentant le sémaphore). "Ref:   Bibliothèque des développeurs Symbian


384
2017-12-06 19:53



Beaux articles sur le sujet:

De la partie 2:

Le mutex est similaire aux principes   du sémaphore binaire avec un   différence significative: le principe   de propriété. La propriété est le simple   concept que lorsque une tâche se verrouille   (acquiert) un mutex seulement il peut débloquer   (Publiez-le. Si une tâche tente de   déverrouiller un mutex il n'a pas verrouillé (donc   ne possède pas) alors une condition d'erreur   est rencontré et, surtout,   le mutex n'est pas déverrouillé. Si la   objet d'exclusion mutuelle n'a pas   la propriété alors, sans rapport avec ce qu'il   est appelé, ce n'est pas un mutex.


121
2017-10-09 05:22



Comme aucune des réponses ci-dessus ne clarifie la confusion, en voici une qui a dissipé ma confusion.

À proprement parler, un mutex est un mécanisme de verrouillage habitué   synchroniser l'accès à une ressource. Une seule tâche (peut être un fil ou   processus basé sur l'abstraction d'OS) peut acquérir le mutex. Cela signifie qu'il y a   sera la propriété associée à mutex, et seul le propriétaire peut   relâchez le verrou (mutex).

Le sémaphore est un mécanisme de signalisation ("Je suis fait, vous pouvez continuer" genre de signal). Par exemple, si vous écoutez des chansons (supposons que   une tâche) sur votre mobile et en même temps votre ami vous a appelé,   une interruption sera déclenchée sur laquelle une routine de service d'interruption   (ISR) signale à la tâche de traitement d'appel de se réveiller.

La source: http://www.geeksforgeeks.org/mutex-vs-semaphore/


82
2017-11-21 05:33



Leur sémantique de synchronisation est très différente:

  • les mutex permettent la sérialisation de l'accès à une ressource donnée, c'est-à-dire que plusieurs threads attendent un verrou, un à la fois et comme dit précédemment, le thread possède le verrou jusqu'à ce qu'il soit fait: seulement ce fil particulier peut le déverrouiller.
  • un sémaphore binaire est un compteur de valeur 0 et 1: une tâche bloquant jusqu'à ce que tout tâche fait un sem_post. Le sémaphore annonce qu'une ressource est disponible et fournit le mécanisme d'attente jusqu'à ce qu'il soit signalé comme étant disponible.

En tant que tel, on peut voir un mutex comme un jeton transmis de tâche en tâche et un sémaphore comme un feu rouge signaux quelqu'un qu'il peut continuer).


34
2017-09-24 18:23



Au niveau théorique, ils ne sont pas différents sémantiquement. Vous pouvez implémenter un mutex en utilisant des sémaphores ou vice versa (voir ici à titre d'exemple). En pratique, la mise en œuvre est différente et ils offrent des services légèrement différents.

La différence pratique (en termes de services système les entourant) est que la mise en œuvre d'un mutex vise à être un mécanisme de synchronisation plus léger. En oracle-parler, les mutex sont connus comme loquets et les sémaphores sont connus comme attentes.

Au niveau le plus bas, ils utilisent une sorte de atomique tester et définir mécanisme. Cela lit la valeur actuelle d'un emplacement de mémoire, calcule une sorte de conditionnel et écrit une valeur à cet emplacement dans une seule instruction qui ne peut pas être interrompu. Cela signifie que vous pouvez acquérir un mutex et tester pour voir si quelqu'un d'autre l'a eu avant vous.

Une implémentation typique de mutex a un processus ou un thread exécutant l'instruction test-and-set et évaluant si quelque chose d'autre a défini le mutex. Un point clé ici est qu'il n'y a pas d'interaction avec le planificateur, donc nous n'avons aucune idée (et ne s'en soucie pas) qui a mis la serrure. Ensuite, soit nous abandonnons notre tranche de temps et nous essayons à nouveau quand la tâche est re-programmée ou exécutez un spin-lock. Un verrou de spin est un algorithme comme:

Count down from 5000:
     i. Execute the test-and-set instruction
    ii. If the mutex is clear, we have acquired it in the previous instruction 
        so we can exit the loop
   iii. When we get to zero, give up our time slice.

Lorsque nous avons fini d'exécuter notre code protégé (connu sous le nom de section critique) nous venons de mettre la valeur mutex à zéro ou tout ce qui signifie «effacer». Si plusieurs tâches tentent d'acquérir le mutex, la prochaine tâche programmée après la sortie du mutex aura accès à la ressource. Généralement, vous utiliseriez des mutex pour contrôler une ressource synchronisée où l'accès exclusif n'est nécessaire que pour de très courtes périodes, normalement pour effectuer une mise à jour d'une structure de données partagée.

Un sémaphore est une structure de données synchronisée (utilisant typiquement un mutex) qui a un nombre et quelques enveloppes d'appel système qui interagissent avec le planificateur dans un peu plus de profondeur que les bibliothèques mutex. Les sémaphores sont incrémentées et décrémentées et utilisées pour bloc tâches jusqu'à ce que quelque chose d'autre soit prêt. Voir Problème de producteur / consommateur pour un exemple simple de ceci. Les sémaphores sont initialisés à une certaine valeur - un sémaphore binaire est juste un cas spécial où le sémaphore est initialisé à 1. L'affichage dans un sémaphore a pour effet de réveiller un processus d'attente.

Un algorithme de sémaphore de base ressemble à:

(somewhere in the program startup)
Initialise the semaphore to its start-up value.

Acquiring a semaphore
   i. (synchronised) Attempt to decrement the semaphore value
  ii. If the value would be less than zero, put the task on the tail of the list of tasks waiting on the semaphore and give up the time slice.

Posting a semaphore
   i. (synchronised) Increment the semaphore value
  ii. If the value is greater or equal to the amount requested in the post at the front of the queue, take that task off the queue and make it runnable.  
 iii. Repeat (ii) for all tasks until the posted value is exhausted or there are no more tasks waiting.

Dans le cas d'un sémaphore binaire, la principale différence pratique entre les deux est la nature des services du système entourant la structure de données réelle.

EDIT: Comme evan l'a fait remarquer à juste titre, les spinlocks ralentiront une machine à un seul processeur. Vous utiliseriez uniquement un verrou tournant sur une boîte multi-processeur car sur un seul processeur, le processus contenant le mutex ne le réinitialisera jamais tant qu'une autre tâche est en cours. Les spinlocks ne sont utiles que sur les architectures multiprocesseurs.


19
2017-11-22 18:58



Bien que les mutex et sémaphores soient utilisés comme primitives de synchronisation, il y a une grande différence entre eux. Dans le cas du mutex, seul le thread qui a verrouillé ou acquis le mutex peut le déverrouiller. Dans le cas d'un sémaphore, un thread en attente sur un sémaphore peut être signalé par un thread différent. Certains systèmes d'exploitation prennent en charge l'utilisation de mutex et de sémaphores entre les processus. Généralement, l'utilisation crée dans la mémoire partagée.


16
2017-08-24 06:17