De verrouillage, mutex, sémaphore... quelle est la différence?

J'ai entendu ces mots relatifs à la programmation simultanée, mais quelle est la différence entre eux?

sna;stackoverflow.com/a/346678/1697099
La meilleure explication que j'ai jamais vu: crystal.uta.edu/~ylei/cse6324/data/sémaphore.pdf
Double Possible de la Différence entre le binaire sémaphore mutex et de

InformationsquelleAutor victor | 2010-02-25

443

Un lock permet à un seul thread à entrer dans la partie qui est verrouillé et que le verrou n'est pas partagé avec les autres processus.

Un mutex est la même qu'une serrure, mais il peut être à l'échelle du système (partagé par plusieurs processus).

Un sémaphore fait la même chose à un mutex, mais permet x nombre de threads d'entrer, ce qui peut être utilisé par exemple pour limiter le nombre de cpu, io ou de la ram intensive tâches en cours d'exécution en même temps.

Pour un poste plus détaillées sur les différences entre les mutex et sémaphore lire ici.

Vous avez également lire/écrire des verrous qui permet un nombre illimité de lecteurs ou de 1 écrivain à un moment donné.
- qu'en est loquet?
- je ne peux pas dire que j'ai jamais entendu parler, mais c'est ce que dit wikipedia "Loquet (base de données), (d'une durée de vie relativement courte) de verrouillage sur un système de structure de données comme un indice"
- ce qui sur le moniteur?
- dans .net monitor est juste une mise en œuvre de la serrure..
- Moniteur permet d'attendre une certaine condition (par exemple, lorsque le verrou est libéré), "moniteurs".
- même si cela est vrai ce n'est pas la vérité tout entière, la méthode Enter n'est pas seulement de surveiller il prend également un verrou, aussi, si vous regardez à la TryEnter méthodes ils n'attendez pas..
- Droite, il ya beaucoup de nuances (le même en Java). Je suis juste dire la différence entre le moniteur et le verrouiller. Surveille a la particularité d'attendre jusqu'à ce verrou est libéré.
- Surveiller également PulseOne et PulseAll (C#), et il est SemaphoreSlim (version légère) qui a AwaitAsync 🙂
- Un sémaphore est pas la même chose qu'un mutex. Ils sont utilisés de manière très différente et ont aussi des propriétés différentes (notamment en ce qui concerne la propriété). Voir par exemple barrgroup.com/Embedded-Systems/How-To/RTOS-Mutex-Semaphore pour plus de détails
- n'hésitez pas à modifier ma réponse si vous vous sentez qu'il est trompeuse ou erronée.
- J'ai toujours pensé que les verrous et les mutex ont été exactement la même chose. Par system-wide-vous dire que les mutex sont gérées par le système d'exploitation et peut être utilisé pour partager des ressources et des processus tandis que les serrures simples peuvent être mises en œuvre sans OS appels? Est-ce à dire que, lorsque quelqu'un dire mutex ils sont toujours référencement de l'OS manipulés un? Aussi une explication simple de la façon dont les moniteurs et les sémaphores travail serait également assez bon pour cette question.
- je n'ai aucune idée de la façon dont ils sont traités je ne les utilisez pas les mettre en œuvre et de mon point de vue est d'une .net et windows point de vue.. donc je ne peux pas garantir qu'ils fonctionnent de la même manière dans les différents OS es ou les langues.
- Question stupide, mais comment un sémaphore permettre à X nombre de threads d'entrer?
- peut mutex être partagé par plusieurs processus, je ne le pense pas...
- dans un environnement windows, ils peuvent, msdn.microsoft.com/en-us/library/windows/desktop/... You can use a mutex object to protect a shared resource from simultaneous access by multiple threads or processes.
- Pour une distinction plus claire entre les mutex et sémaphore, dans nanoquack du lien, Le paragraphe clé est "L'utilisation correcte d'un sémaphore est pour la signalisation d'une tâche à une autre. Un mutex est fait pour être pris et publié, toujours dans cet ordre, par chaque tâche qui utilise la ressource partagée qu'il protège. En revanche, les tâches qui utilisent les sémaphores signal ou d'attente, pas les deux."
- Ça a du sens, ce que je n'ai jamais compris, c'est que quand je veux un sémaphore à compter jusqu'à plus de 1 (binaire), la seule idée que j'ai peut arriver, c'est si vous avez plusieurs mutex, vous pouvez utiliser le sémaphore à attendre, mais une fois que vous obtenez le signal que vous auriez à essayer toutes les mutex de toute façon?
- J'ai été surpris de la réponse qui est mauvais, c'est la plus upvoted un.. s'il vous plaît supprimer votre réponse pour d'autres personnes à ne pas confondre à propos de mutex et sémaphore.
- la réponse pourrait obtenir le sémaphore partie de mal, mais le reste est pas mal? Semble exagéré pour l'enlever? Pourquoi ne pas le signaler comme étant incorrecte ou même mieux de le modifier et de le rendre correct? C'est une communauté sans l'aide de la communauté cet endroit n'existerait pas!
InformationsquelleAutor Peter
94

Il y a beaucoup d'idées fausses au sujet de ces mots.

C'est à partir d'un post précédent (https://stackoverflow.com/a/24582076/3163691) qui s'adapte superbe ici:

1) Section Critique= objet Utilisateur utilisé pour permettre l'exécution de juste un thread actif de beaucoup d'autres dans un délai d'un processus de. Les autres threads sélectionnés (@ l'acquisition de cet objet) sont mis à sommeil.

[Sans interprocessus capacité, très primitive de l'objet].

2) Mutex, Sémaphore (aka Mutex)= objet de Noyau utilisé pour permettre l'exécution de juste un thread actif de beaucoup d'autres, entre les différents processus. Les autres threads sélectionnés (@ l'acquisition de cet objet) sont mis à sommeil. Cet objet prend en charge thread à la propriété, le fil notification de résiliation, la récursivité (plusieurs 'acquérir' des appels de même thread) et "inversion de priorité évitement".

[Interprocessus capacité, très sûr à utiliser, une sorte de "haut niveau" de la synchronisation de l'objet].

3) Comptage Sémaphore (aka Sémaphore)= objet de Noyau utilisé pour permettre l'exécution de un groupe de threads actifs de beaucoup d'autres. Les autres threads sélectionnés (@ l'acquisition de cet objet) sont mis à sommeil.

[Interprocessus capacité cependant pas très sûr à utiliser car il manque suivantes mutex attributs: fil notification de résiliation, la récursivité?, 'inversion de priorité évitement"?, etc].

4) Et maintenant, à parler de "spinlocks", d'abord quelques définitions:

Région critique= Une région de mémoire partagée par 2 ou plusieurs processus.

Lock= Une variable dont la valeur permet ou interdit l'entrée à une "critique de la région". (Il pourrait être mis en œuvre comme un simple indicateur booléen').

Occupé attente= Continuellement test d'une variable jusqu'à une certaine valeur apparaît.

Enfin:

Spin-lock (aka Spinlock)= Un de verrouillage qui utilise occupé attente. (L'acquisition de la de verrouillage est faite par xchg ou similaire opérations atomiques).

[Sans fil de couchage, utilisé surtout au niveau du noyau seulement. Ineffcient pour le niveau de l'Utilisateur code].

Un dernier commentaire, je ne suis pas sûr, mais je suis prêt à parier beaucoup d'argent que les 3 premiers synchronisation d'objets (#1, #2 et #3) faire usage de cette simple bête (#4) dans le cadre de leur mise en œuvre.

Une bonne journée!.

Références:

-En Temps réel des Concepts pour les Systèmes Embarqués par les Qing Li avec Caroline Yao (CMP Livres).

-Systèmes d'Exploitation modernes (3e) par Andrew Tanenbaum (Pearson Internationale de l'Éducation).

-Programmation d'Applications pour Microsoft Windows (4e) par Jeffrey Richter (Microsoft Programmation de la Série).

Aussi, vous pouvez prendre un coup d'oeil à regarder:
https://stackoverflow.com/a/24586803/3163691
- Effectivement section critique est pas un objet de noyau, donc plus léger et incapable de synchronisation entre processus.
- Vladislavs Burakovs: Vous avez raison! Pardonnez ma rédaction. Je vais le corriger par souci de cohérence.
- Pour une distinction plus claire entre les mutex et sémaphore, comme nanoquack mentionne ailleurs, voir barrgroup.com/Embedded-Systems/How-To/RTOS-Mutex-Semaphore - Le paragraphe clé est "L'utilisation correcte d'un sémaphore est pour la signalisation d'une tâche à une autre. Un mutex est fait pour être pris et publié, toujours dans cet ordre, par chaque tâche qui utilise la ressource partagée qu'il protège. En revanche, les tâches qui utilisent les sémaphores signal ou d'attente, pas les deux."
- Re conjecture d'autres verrouiller des mécanismes de construire sur [inefficace] spinlock: rare; autant que je sache seulement besoin de quelques les opérations atomiques plus de sommeil files d'attente. Même lorsque spinlock est à l'intérieur du noyau, des solutions modernes de minimiser son impact comme décrit dans la Wikipédia - Spinlock - Alternatives - ".. l'utilisation d'une approche hybride appelé "adaptive mutex". L'idée est d'utiliser un spinlock lorsque vous essayez d'accéder à une ressource verrouillée par un actuellement en cours d'exécution d'un thread, mais pour dormir si le fil n'est pas en cours d'exécution. (Le dernier est toujours le cas sur un seul processeur de systèmes)."
- Je vous mets au défi de fournir une "solution" sans "spinlock" pour le problème de "collisions" à essayer de "insérer" un ID de thread à un sommeil de la file d'attente'. De toute façon, Wikipedia, texte conclut que spinlock est utilisé lors de la mise en œuvre!!!.
- Le Wikipedia de texte ne dit pas ni n'implique que les spinlock est utilisé dans le cadre de ces autres simultanéité des mécanismes. [Malheureusement, il est muet sur le sujet - il ne clarifie pas si spinlock est utilisé;] Ni étais-je dire que spinlock est jamais nécessaire. Je pense qu'il n'est pas nécessaire, ni pour mettre en œuvre mutex ni sémaphore - cependant cette réponse précise que spinlock est partie d'un efficace "hybride" de la mise en œuvre de mutex sur les Processeurs multi-core; j'ai donc eu tort. [Je suppose qu'on ne doit jamais spinlock dans le code de l'application, appelez le noyau funcs.]
- Je veux dire, dans le code de l'application, l'appel des fonction noyau qui a le faible niveau de connaissances pour décider de spinlock ou pas. E. g. aussi loin que le code de l'application est concerné, il est un verrou, un mutex, un sémaphore, ou l'utilisation d'interchange des instructions. Si les circonstances sont en droit de spinlock pour un bref moment, pour voir si un autre cpu core sorti un mutex ou sémaphore, puis laissez-le noyau de le faire.
InformationsquelleAutor fante
20

Prendre un coup d'oeil à Le Multithreading Tutoriel par Jean-Kopplin.

Dans la section de Synchronisation Entre les Threads, il explique la différence entre événement, de le verrouiller un mutex, sémaphore, waitable minuterie

Un mutex peuvent être détenus par un seul thread à la fois, permettant à des threads
coordonner mutuellement un accès exclusif à une ressource partagée

Objets section critique fournir la synchronisation similaire à celle
fournis par mutex objets, sauf que les objets section critique peut être
utilisé uniquement par les threads d'un même processus

Autre différence entre les mutex et un section critique est que si
la critique de l'objet de la section est actuellement détenue par un autre thread,
EnterCriticalSection() attend indéfiniment propriété tandis que la
WaitForSingleObject(), qui est utilisé avec un mutex, vous permet de
spécifier un délai

Un sémaphore maintient un nombre entre zéro et un maximum de valeur,
limiter le nombre de threads qui sont à la fois l'accès à un
ressource partagée.

InformationsquelleAutor onmyway133
18

La plupart des problèmes peuvent être résolus en utilisant (i) bloque juste, (ii) juste sémaphores, ..., ou (iii) une combinaison des deux! Comme vous l'avez découvert, ils sont très similaires: les deux éviter des conditions de course, les deux ont acquire()/release() opérations, à la fois la cause de zéro ou plus de fils d'être bloqué ou que l'on soupçonne...
Vraiment, la différence se situe uniquement sur comment ils verrouillage et déverrouillage de l'.
- Un de verrouillage (ou mutex) a deux états (0 ou 1). Il peut être soit déverrouillé ou verrouillé. Ils sont souvent utilisés pour s'assurer que seul un thread entre dans une section critique à la fois.
- Un sémaphore possède de nombreux états (0, 1, 2, ...). Il peut être verrouillé (état 0), ou déverrouillé (états 1, 2, 3, ...). Un ou plusieurs sémaphores sont souvent utilisés ensemble pour s'assurer que seul un thread entre dans une section critique, précisément lorsque le nombre d'unités d'une ressource a/n'a pas atteint une valeur particulière (soit via le compte à rebours de cette valeur ou de comptage jusqu'à cette valeur).
Pour les deux écluses/sémaphores, en essayant d'appeler acquire() tandis que le primitif est à l'état 0 provoque l'invocation thread est suspendu. Pour les serrures, les tentatives visant à acquérir le verrou est dans l'état 1 sont couronnées de succès. Pour les sémaphores, les tentatives visant à acquérir le verrou dans les états {1, 2, 3, ...} sont couronnées de succès.

Pour les écluses de l'état l'état 0, si même thread qui avait déjà appelé acquire(), maintenant des appels à la libération, puis la sortie est réussi. Si un différents fil essayé -- c'est jusqu'à la mise en œuvre/bibliothèque de ce qui se passe (généralement la tentative ignoré ou une erreur est renvoyée). Pour les sémaphores à l'état 0, tout thread peut appeler la libération et elle sera couronnée de succès (quel que soit le thread précédent utilisé acquérir de mettre le feu à l'état 0).

De la discussion qui précède, nous pouvons voir que les serrures ont une notion de propriétaire (le seul fil que l'on peut appeler la libération est le propriétaire), alors que les sémaphores n'ont pas de propriétaire (n'importe quel thread peut appeler release sur un sémaphore).

Ce qui provoque beaucoup de confusion, c'est que, dans la pratique, ils sont de nombreuses variations de ce haut niveau de définition.

Des variations importantes à considérer:
- Quelle devrait être la acquire()/release() être appelé? -- [Varie massivement]
- Votre serrure/sémaphore utiliser une "file d'attente" ou un "set" pour rappeler les threads en attente?
- Peut verrouillage/sémaphore être partagé avec les threads d'autres processus?
- Est votre serrure "réentrant"? -- [Normalement oui].
- Est votre serrure "bloquant/non-blocage"? -- [Normalement non-bloquants sont utilisés comme des verrous de blocage (aka spin-serrures) cause occupé attente].
- Comment vous assurer que les opérations sont "atomique"?
Ces dépend de votre ouvrage /maître de conférences /langue /bibliothèque /environnement.

Voici un rapide tour en constatant à quel point certaines langues répondre à ces détails.

C, C++ (pthreads)
- Un mutex est mis en œuvre par pthread_mutex_t. Par défaut, ils ne peuvent pas être partagés avec les autres processus (PTHREAD_PROCESS_PRIVATE), cependant mutex ont un attribut appelé pshared. Lorsqu'il est défini, de sorte que le mutex est partagée entre plusieurs processus (PTHREAD_PROCESS_SHARED).
- Un de verrouillage est la même chose qu'un mutex.
- Un sémaphore est mis en œuvre par sem_t. Semblable à mutex, sémaphores peuvent être partagées entre les threasds de nombreux processus ou maintenu privé pour les threads d'un même processus. Cela dépend de la pshared argument fourni à sem_init.
python (threading.py)
- Un de verrouillage (threading.RLock) est essentiellement le même que le C/C++ pthread_mutex_ts. Les deux sont à la fois réentrant. Cela signifie qu'ils ne peuvent être déverrouillés par le même thread qui l'a enfermé. C'est le cas que sem_t sémaphores, threading.Semaphore les sémaphores et les theading.Lock les verrous sont non réentrant -- car c'est le cas tout thread peut exécuter déverrouiller la serrure /bas du sémaphore.
- Un mutex est le même qu'un verrou (le terme n'est pas utilisé souvent en python).
- Un sémaphore (threading.Semaphore) est essentiellement le même que sem_t. Bien qu'avec sem_t, une file d'attente d'id de thread est utilisé pour retenir l'ordre dans lequel les threads s'est retrouvé bloqué lors de la tentative de verrouillage lorsqu'il est verrouillé. Lorsqu'un thread déverrouille d'un sémaphore, le première fil dans la file d'attente (si il y en a un) est choisie pour être le nouveau propriétaire. Le fil de l'identifiant est retiré de la file d'attente et le sémaphore devient à nouveau verrouillé. Cependant, avec threading.Semaphore, un ensemble est utilisé à la place d'une file d'attente, donc l'ordre dans lequel les threads s'est retrouvé bloqué n'est pas stocké -- tout fil dans l'ensemble peut être choisi pour être le prochain propriétaire.
Java (java.util.simultanées)
- Un de verrouillage (java.util.concurrent.ReentrantLock) est essentiellement le même que le C/C++ pthread_mutex_t's, et Python threading.RLock en ce qu'il met en œuvre également un réentrant de verrouillage. Le partage des écluses entre les processus est plus difficile en Java en raison de la JVM agir en tant qu'intermédiaire. Si un thread tente de déverrouiller une serrure, il n'est pas propre, un IllegalMonitorStateException est levée.
- Un mutex est le même qu'un verrou (le terme n'est pas souvent utilisé en Java).
- Un sémaphore (java.util.concurrent.Semaphore) est essentiellement le même que sem_t et threading.Semaphore. Le constructeur de Java sémaphores accepter un équité paramètre booléen qui contrôle si l'utilisation d'un ensemble (false) ou une file d'attente (true) pour stocker les threads en attente.
En théorie, les sémaphores sont souvent évoqués, mais dans la pratique, les sémaphores ne sont pas utilisés. Un sémaphore ne détiennent l'état de un entier, de sorte que souvent, c'est plutôt rigide et nombreux sont nécessaires à la fois -- causer des difficultés dans la compréhension du code. Aussi, le fait que tout thread peut lancer un sémaphore est parfois indésirable. Plus orienté objet /de plus haut niveau des primitives de synchronisation /abstractions telles que "les variables de condition" et de "moniteurs" sont utilisés à la place.

InformationsquelleAutor James Lawson

Je vais essayer de le couvrir avec des exemples:

De verrouillage: Un exemple où vous utiliseriez lock sera partagé dictionnaire dans lequel les éléments (qui doit avoir les clés uniques) sont ajoutés.

Le verrou doit s'assurer qu'un thread ne pas entrer dans le mécanisme de code qui est la vérification de l'élément en cours dans le dictionnaire tandis qu'un autre thread (qui est dans la section critique) a déjà passé cette case et est l'ajout de l'article. Si un autre thread tente d'accéder à un blocage de code, il faudra attendre (est bloqué jusqu'à ce que l'objet est libéré.

private static readonly Object obj = new Object();

lock (obj) //after object is locked no thread can come in and insert item into dictionary on a different thread right before other thread passed the check...
{
    if (!sharedDict.ContainsKey(key))
    {
        sharedDict.Add(item);
    }
}

Sémaphore:
Disons que vous avez un pool de connexions, alors un seul thread peut réserver un élément dans la piscine en attendant le sémaphore pour obtenir une connexion. Il utilise ensuite la connexion et lorsque le travail est terminé libère la connexion par la libération du sémaphore.

Exemple de Code que j'adore c'est un de videur donné par @Patric - ici, il va:

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;

namespace TheNightclub
{
    public class Program
    {
        public static Semaphore Bouncer { get; set; }

        public static void Main(string[] args)
        {
            //Create the semaphore with 3 slots, where 3 are available.
            Bouncer = new Semaphore(3, 3);

            //Open the nightclub.
            OpenNightclub();
        }

        public static void OpenNightclub()
        {
            for (int i = 1; i <= 50; i++)
            {
                //Let each guest enter on an own thread.
                Thread thread = new Thread(new ParameterizedThreadStart(Guest));
                thread.Start(i);
            }
        }

        public static void Guest(object args)
        {
            //Wait to enter the nightclub (a semaphore to be released).
            Console.WriteLine("Guest {0} is waiting to entering nightclub.", args);
            Bouncer.WaitOne();          

            //Do some dancing.
            Console.WriteLine("Guest {0} is doing some dancing.", args);
            Thread.Sleep(500);

            //Let one guest out (release one semaphore).
            Console.WriteLine("Guest {0} is leaving the nightclub.", args);
            Bouncer.Release(1);
        }
    }
}

Mutex Il est assez bien Semaphore(1,1) et souvent utilisé dans le monde entier (application large sinon sans doute lock est plus approprié). On pourrait utiliser le Mutex lors de la suppression d'un nœud d'un accessibles dans le monde entier de la liste (la dernière chose que vous voulez un autre thread pour faire quelque chose pendant que vous êtes en train de supprimer le nœud). Lorsque vous acquérir Mutex si différents thread tente d'acquérir le même Mutex il sera mis en sommeil jusqu'à MÊME thread que celui qui a acquis le Mutex libère.

Bon exemple sur la création mondiale de mutex est par @deepee

class SingleGlobalInstance : IDisposable
{
    public bool hasHandle = false;
    Mutex mutex;

    private void InitMutex()
    {
        string appGuid = ((GuidAttribute)Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(GuidAttribute), false).GetValue(0)).Value.ToString();
        string mutexId = string.Format("Global\\{{{0}}}", appGuid);
        mutex = new Mutex(false, mutexId);

        var allowEveryoneRule = new MutexAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.FullControl, AccessControlType.Allow);
        var securitySettings = new MutexSecurity();
        securitySettings.AddAccessRule(allowEveryoneRule);
        mutex.SetAccessControl(securitySettings);
    }

    public SingleGlobalInstance(int timeOut)
    {
        InitMutex();
        try
        {
            if(timeOut < 0)
                hasHandle = mutex.WaitOne(Timeout.Infinite, false);
            else
                hasHandle = mutex.WaitOne(timeOut, false);

            if (hasHandle == false)
                throw new TimeoutException("Timeout waiting for exclusive access on SingleInstance");
        }
        catch (AbandonedMutexException)
        {
            hasHandle = true;
        }
    }


    public void Dispose()
    {
        if (mutex != null)
        {
            if (hasHandle)
                mutex.ReleaseMutex();
            mutex.Dispose();
        }
    }
}

puis à utiliser comme:

using (new SingleGlobalInstance(1000)) //1000ms timeout on global lock
{
    //Only 1 of these runs at a time
    GlobalNodeList.Remove(node)
}

Espère que cela vous fait gagner du temps.

InformationsquelleAutor Matas Vaitkevicius

7

Wikipedia a une grande section sur la les différences entre les Sémaphores et les Mutex:

Un mutex est essentiellement la même chose qu'un sémaphore binaire et
parfois utilise la même base de mise en œuvre. Les différences entre les
eux sont les suivants:

Mutex ont un concept d'un propriétaire, qui est le processus
qui a verrouillé le mutex. Seul le processus qui a verrouillé le mutex peut
le déverrouiller. En revanche, un sémaphore n'a pas de notion de propriétaire. Tout
le processus peut déverrouiller un sémaphore.

À la différence des sémaphores, mutex fournir
inversion de priorité à la sécurité. Depuis le mutex connaît son propriétaire actuel, il
est possible de promouvoir la priorité du propriétaire toutes les fois qu'un
de priorité plus élevée tâche démarre en attente du mutex.

Mutex également fournir
la suppression de la sécurité, où le processus qui détient le mutex ne peut pas être
accidentellement supprimé. Les sémaphores ne fournissent pas cette.

InformationsquelleAutor andy boot
4

Ma compréhension est qu'un mutex est uniquement pour une utilisation au sein d'un seul processus, mais à travers ses nombreux fils, alors qu'un sémaphore peut être utilisé dans de multiples processus, et à travers leurs séries de fils.

Aussi, un mutex est binaire (c'est soit verrouillé ou non), alors qu'un sémaphore a une notion de comptage, ou une file d'attente de plus d'un verrouillage et déverrouillage des demandes.

Quelqu'un pourrait-il vérifier mon explication? Je parle dans le contexte de Linux, plus précisément de Red Hat Enterprise Linux (RHEL) de la version 6, qui utilise un noyau 2.6.32.
- Je pense que votre réponse est juste.
- Maintenant, ce pourrait être différente dans les différents systèmes d'exploitation, mais dans windows un Mutex peut être utilisé par plusieurs processus au moins l' .net objet Mutex..
- stackoverflow.com/questions/9389730/... "les Threads du même processus ou dans d'autres processus peuvent partager les mutex." donc pas un mutex ne doit pas être spécifiques à un processus.
InformationsquelleAutor Bruce Penswick
2

À l'aide de la programmation en C sous Linux variante comme une base de cas pour les exemples.

De verrouillage:

• En général, un très simple de construire binaire dans l'opération soit verrouillé ou déverrouillé

• Pas de notion de thread à la propriété, la priorité, de séquençage etc.

• En général, un verrou de rotation où le fil en permanence pour les serrures de disponibilité.

• En général, s'appuie sur des opérations atomiques par exemple, Test-and-set, compare-and-swap, d'extraction et d'ajouter etc.

• En général, nécessite un support matériel pour opération atomique.

Verrous De Fichier:

• Généralement utilisé pour coordonner l'accès à un fichier par plusieurs processus.

• Plusieurs processus peuvent tenir le verrou en lecture cependant lorsqu'un processus détient le verrou d'écriture aucun autre processus n'est autorisé à acquérir, de lecture ou d'écriture de verrouillage.

• Exemple : troupeau, fcntl etc..

Mutex:

• Mutex appels de fonction pour habitude de travailler dans l'espace du noyau et du système d'appels.

• Il utilise la notion de propriété. Seul le thread qui détient actuellement le mutex pouvez le déverrouiller.

• Mutex n'est pas récursive (Exception: PTHREAD_MUTEX_RECURSIVE).

• Généralement utilisé en Association avec les Variables de Condition et passés comme arguments, par exemple pthread_cond_signal, pthread_cond_wait etc.

• Certains systèmes UNIX permettent de mutex pour être utilisé par plusieurs processus, même si cela peut ne pas être appliquée sur tous les systèmes.

Sémaphore:

• C'est un noyau maintenu entier dont la valeur n'est pas autorisé à tomber en dessous de zéro.

• Il peut être utilisé pour synchroniser les processus.

• La valeur du sémaphore peut être réglé à une valeur supérieure à 1, auquel cas la valeur indique le nombre de ressources disponibles.

• Un sémaphore dont la valeur est limitée à 1 et 0 est appelé un sémaphore binaire.

InformationsquelleAutor Judayle Dsouza

Vous devez vous connecter pour publier un commentaire.

C, C++ (pthreads)

python (threading.py)

Java (java.util.simultanées)