Quand devrions-nous utiliser un mutex et quand devrions-nous utiliser un sémaphore

Question

Quand devrions-nous utiliser le mutex et quand devrions-nous utiliser le sémaphore?

Answer 1

Voici comment je me souviens de quand utiliser quoi -

Sémaphore: L'utilisation d'un sémaphore lorsque vous (thread) qui veulent dormir jusqu'à un autre thread vous dit de se réveiller. Sémaphore de down se produit dans un thread (producteur) et un sémaphore " up " (pour les mêmes sémaphore) arrive dans un autre thread (le consommateur) par exemple: producteur-consommateur problème, producteur veut dormir au moins jusqu'à un tampon est vide, seule le thread consommateur peut dire quand un tampon est vide.

Mutex: Utiliser un mutex lorsque vous (thread) voulez exécuter du code qui ne doit pas être exécuté par n'importe quel autre thread en même temps. Mutex "vers le bas" se passe dans un thread et mutex "up" doit se produire dans le même thread plus tard. par exemple: Si vous êtes à la suppression d'un nœud d'une liste liée, vous ne voulez pas un autre thread pour muck autour avec des pointeurs alors que vous êtes en train de supprimer le nœud. Lorsque vous achetez un mutex et sont occupés à la suppression d'un nœud, si un autre thread tente d'acquérir le même mutex, il sera mis en sommeil jusqu'à ce que vous relâchez le mutex.

Spinlock: Utiliser un spinlock lorsque vous voulez vraiment utiliser un mutex, mais votre fils n'est pas autorisé à dormir. par exemple: Un gestionnaire d'interruption au sein de noyau de système d'exploitation ne doit jamais dormir. Si elle ne le système freeze / crash. Si vous avez besoin d'insérer un nœud de communes à l'échelle mondiale liée liste à partir du gestionnaire d'interruption, d'acquérir un spinlock - insérer un nœud à libération spinlock.

Answer 2

Un mutex est une exclusion mutuelle sémaphore, une variante particulière d'un sémaphore qui permet uniquement d'un casier à l'heure et dont les restrictions à la propriété peut être plus stricte que la normale sémaphore.

En d'autres termes, c'est équivalent à une normale de comptage sémaphore avec un décompte de l'un et de l'exigence qu'il ne peut être libéré par le même thread qui l'a enfermé.

Un sémaphore, d'autre part, a un comte et peut être verrouillé par que de nombreux casiers en même temps. Et il ne peut pas avoir une condition qu'il soit publié par le même thread qui l'a réclamé (mais si pas, vous devez soigneusement la piste qui a actuellement la responsabilité, à l'instar de la mémoire allouée).

Donc, si vous avez un certain nombre d'instances d'une ressource (par exemple trois lecteurs de bande), vous pouvez utiliser un sémaphore avec un nombre de 3. Notez que cela ne vous dit pas lequel de ces lecteurs de bande que vous avez, que vous avez un certain nombre.

Aussi avec les sémaphores, il est possible qu'un seul casier pour verrouiller plusieurs instances d'une ressource, comme une bande-à-bande de copie. Si vous avez une ressource (disons un emplacement de mémoire que vous ne voulez pas corrompus), un mutex est plus approprié.

Des opérations équivalentes sont:

Counting semaphore          Mutual exclusion semaphore
--------------------------  --------------------------
  Claim/decrease (P)                  Lock
  Release/increase (V)                Unlock

De côté: dans le cas où vous êtes déjà demandé à l'étrange lettres utilisées pour la revendication et de libérer les sémaphores, c'est parce que l'inventeur était néerlandais. Probeer te verlagen les moyens pour essayer et diminuent tandis que les verhogen les moyens d'augmenter.

Answer 3

Il est très important de comprendre qu'un mutex n'est pas un sémaphore avec le comte de 1!

C'est la raison il ya des choses comme les sémaphores binaires (qui sont vraiment les sémaphores avec le comte 1).

La différence entre un Mutex et Binaire-Sémaphore est le principe de la propriété:

Un mutex est acquis par une tâche et, par conséquent, doit également être libéré par la même tâche. Cela permet de résoudre plusieurs problèmes avec les sémaphores binaires (Accidentelle version récursive de l'impasse et de l'inversion de priorité).

Mise en garde: j'ai écrit "rend possible", si et comment ces problèmes sont résolus est jusqu'à l'OS de la mise en œuvre.

Parce que le mutex doit être libéré par la même tâche, il n'est pas très bon pour la synchronisation des tâches. Mais si elle est combinée avec les variables de condition, vous avez de très puissants blocs de construction pour la construction de tous types de cib primitives.

Donc, ma recommandation est la suivante: si vous avez correctement mis en œuvre les mutex et les variables de condition (comme avec POSIX pthreads) utiliser ces.

Utiliser les sémaphores seulement si elles correspondent exactement le problème que vous essayez de résoudre, n'essayez pas de construire d'autres primitives (par exemple rw-serrures de sémaphores, utiliser les mutex et les variables de condition pour ces derniers)

Il y a beaucoup de malentendus mutex et les sémaphores. La meilleure explication que j'ai trouvé pour l'instant est dans cette Partie 3 de l'article:

Mutex par rapport aux Sémaphores – Partie 1: les Sémaphores

Mutex par rapport aux Sémaphores – Partie 2: Le Mutex

Mutex par rapport aux Sémaphores – Partie 3 (dernière partie): Problèmes de l'Exclusion Mutuelle

Answer 4

Alors que @opaxdiablo réponse est tout à fait correcte, je tiens à souligner que le scénario de l'utilisation de ces deux choses est tout à fait différent. Le mutex est utilisé pour protéger des parties de code de s'exécuter simultanément, les sémaphores sont utilisés pour un fil pour le signal d'un autre thread à exécuter.

/* Task 1 */
pthread_mutex_lock(mutex_thing);
    // Safely use shared resource
pthread_mutex_unlock(mutex_thing);



/* Task 2 */
pthread_mutex_lock(mutex_thing);
   // Safely use shared resource
pthread_mutex_lock(mutex_thing);

Le sémaphore scénario est différent:

/* Task 1 - Producer */
sema_post(&sem);   // Send the signal

/* Task 2 - Consumer */
sema_wait(&sem);   // Wait for signal

Voir http://www.netrino.com/node/202 pour de plus amples explications

Answer 5

En essayant de ne pas paraître loufoque, mais ne peut pas aider moi-même.

Votre question devrait être quelle est la différence entre les mutex et les sémaphores ? Et pour être plus précis de la question, " quelle est la relation entre les mutex et les sémaphores ?'

(J'aurais ajouté à cette question mais je suis cent pour cent sûr certains excès de zèle modérateur de fermer comme en double, sans comprendre la différence entre la différence et la relation.)

Dans la terminologie des objets, nous pouvons observer que :

de l'observation.1 Sémaphore contient mutex

de l'observation.2 Mutex n'est pas sémaphore et le sémaphore n'est pas mutex.

Il y a quelques sémaphores qui va agir comme si ils sont mutex, appelé les sémaphores binaires, mais ils sont en train d'halluciner PAS mutex.

Il est un ingrédient spécial appelé Signalisation (posix utilise condition_variable pour ce nom), nécessaire pour rendre un Sémaphore de mutex. Pensez-y comme une notification de source. Si deux ou plusieurs threads sont souscrits à la même notification-source, il est alors possible d'envoyer un message à UN ou à TOUS les, de réveil.

Il pourrait y avoir un ou plusieurs compteurs associés avec les sémaphores, qui sont gardés par des mutex. Le plus simple scénario pour un sémaphore, il y a un seul compteur qui peut être 0 ou 1.

C'est là que la confusion se déverse comme la pluie de la mousson.

Un sémaphore avec un compteur qui peut être 0 ou 1 n'est PAS mutex.

Mutex a deux états (0,1) et une propriété(tâche). Sémaphore a un mutex, certains compteurs et une variable de condition.

Maintenant, utilisez votre imagination, et chaque combinaison de l'utilisation de compteur et quand le signal peut faire une sorte de Sémaphore.

1. Seul compteur avec la valeur 0 ou 1 et de signalisation lorsque la valeur passe à 1 ET ouvre alors l'un des gars de l'attente sur le signal == sémaphore Binaire

2. Seul compteur avec une valeur de 0 à N et de signalisation lorsque la valeur passe à moins de N, et les verrous/attend lorsque les valeurs N == Comptage sémaphore

3. Seul compteur avec une valeur de 0 à N et de signalisation lorsque la valeur de N, et les verrous/attend lorsque les valeurs est inférieur à N == Barrière sémaphore (eh bien, si ils ne sont pas de l'appeler, alors qu'ils le devraient.)

Maintenant à votre question, lors de l'utilisation de ce. (OU plutôt correct question de version.3 lors de l'utilisation de mutex et quand utiliser les binaires-sémaphore, car il n'y a pas de comparaison à des non-binaire-sémaphore.) L'utilisation de mutex quand 1. vous voulez un comportement personnalisé, qui n'est pas fourni par sémaphore binaire, tels sont les spin-lock ou fast-lock ou récursive-écluses. Habituellement, vous pouvez personnaliser les mutex avec des attributs, mais la personnalisation sémaphore n'est rien, mais l'écriture de nouvelles sémaphore. 2. vous souhaitez léger OU plus primitive

Utiliser les sémaphores, quand ce que vous voulez, c'est exactement celui-ci.

Si vous ne comprenez pas ce qui est fourni par votre mise en œuvre de binary-sémaphore, puis à mon humble avis, l'utilisation de mutex.

Et enfin lire un livre plutôt que de compter seulement sur soi.