Quand doit-on utiliser les mutex et quand doit-on utiliser un sémaphore

Un mutex est une exclusion mutuelle de l'objet, similaire à un feu, mais qui ne permet qu'un casier à l'heure et dont les restrictions à la propriété peuvent être plus strictes que d'un sémaphore.

Il peut être considéré comme équivalent à une normale de comptage sémaphore (avec un nombre d'une) et de l'exigence qu'il ne peut être libéré par le même thread qui l'a enfermé^a.

Un sémaphore, d'autre part, a l'arbitraire d'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.

---

^a ... ou bien il peut être considéré comme quelque chose de totalement différent d'un sémaphore, qui peut être plus sûr étant donné leur presque-toujours-différentes utilisations.

Tandis 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

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, la question devrait être, " 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 :

observation.1 Sémaphore contient mutex

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 y a 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, à 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.

Mutex est de protéger la ressource partagée.

Sémaphore est de répartir les fils.

Mutex:

Imaginez qu'il y a quelques billets à vendre. Nous pouvons simuler un cas où beaucoup de gens acheter les billets en même temps: chaque personne est un thread pour acheter des billets. Évidemment, nous devons utiliser le mutex pour protéger les billets parce que c'est la ressource partagée.

Sémaphore:

Imaginez que nous avons besoin de faire un calcul comme ci-dessous:

c = a + b;

Aussi, nous avons besoin d'une fonction geta() pour calculer a, une fonction getb() pour calculer b et une fonction getc() de faire le calcul c = a + b.

Évidemment, nous ne pouvons pas faire la c = a + b sauf geta() et getb() ont été fini.

Si ces trois fonctions sont les trois fils, nous avons besoin d'envoyer les trois threads.

int a, b, c;
void geta()
{
    a = calculatea();
    semaphore_increase();
}

void getb()
{
    b = calculateb();
    semaphore_increase();
}

void getc()
{
    semaphore_decrease();
    semaphore_decrease();
    c = a + b;
}

t1 = thread_create(geta);
t2 = thread_create(getb);
t3 = thread_create(getc);
thread_join(t3);

Avec l'aide du sémaphore, le code ci-dessus peut faire en sorte que t3 de ne pas faire son travail jusqu'à t1 et t2 ont fait leur travail.

En un mot, le sémaphore est de faire des threads de s'exécuter comme un logicial de l'ordre alors que les mutex est de protéger la ressource partagée.

Donc ils ne sont PAS la même chose même si certaines personnes disent toujours que le mutex est un spécial sémaphore avec la valeur initiale 1. Vous pouvez le dire comme ça aussi, mais veuillez noter qu'elles sont utilisées dans différents cas. Ne pas remplacer l'un par l'autre, même si vous pouvez le faire.

Un mutex est un cas particulier d'un sémaphore. Un sémaphore permet à plusieurs threads pour entrer dans la section critique. Lors de la création d'un sémaphore à vous de décider comment peut threads sont autorisés dans la section critique. Bien sûr, votre code doit être capable de gérer plusieurs accès à la section critique.