Qu'est ce qu'un mutex?

un mutex est un concept de programmation fréquemment utilisé pour résoudre des problèmes de multi-filetage. Ma question à la communauté:

qu'est Ce qu'un mutex et comment l'utilisez-vous?

494
demandé sur bmurphy1976 2008-08-29 19:59:25

9 réponses

quand j'ai une grande discussion animée au travail, j'utilise un poulet en caoutchouc que je garde dans mon bureau pour de telles occasions. La personne qui tient le poulet est la seule personne autorisée à parler. Si tu ne tiens pas le poulet, tu ne peux pas parler. Vous pouvez seulement indiquer que vous voulez le poulet et attendre jusqu'à ce que vous obtenez avant de parler. Une fois que vous avez fini de parler, vous pouvez remettre le poulet au modérateur qui le remettra à la personne suivante pour parler. Cela garantit que les gens ne parlent pas les uns des autres, et ont aussi leur propre espace pour parler.

remplacer poulet avec Mutex et personne avec fil et vous avez essentiellement le concept d'un mutex.

bien sûr, il n'y a pas de mutex en caoutchouc. Seulement du poulet en caoutchouc. Mes chats avaient une souris en caoutchouc, mais ils l'ont mangée.

bien sûr, avant d'utiliser le poulet en caoutchouc, vous devez vous demander si vous avez vraiment besoin de 5 personnes dans une chambre et ne serait-ce pas plus facile avec une seule personne seule dans la pièce pour faire tout le travail. En fait, c'est juste étendre l'analogie, mais vous avez l'idée.

1736
répondu Xetius 2016-06-04 21:21:30

un Mutex est un drapeau mutuellement exclusif. Il agit comme un gardien de porte à une section de code permettant un thread dedans et bloquant l'accès à tous les autres. Cela garantit que le code contrôlée ne seront touchés par un seul thread à la fois. Juste être sûr pour libérer le mutex lorsque vous avez terminé. :)

88
répondu Craig 2008-08-29 16:06:26

Exclusion Mutuelle. Voici L'entrée Wikipédia:

http://en.wikipedia.org/wiki/Mutual_exclusion

le point d'un mutex est de synchroniser deux fils. Lorsque vous avez deux threads tentent d'accéder à une ressource unique, la tendance générale est d'avoir le premier bloc de code d'accès pour définir le mutex avant d'entrer dans le code. Lorsque le deuxième bloc de code tente l'accès, il voit que le mutex est réglé et attend jusqu'à ce que le premier bloc de code soit terminé (et désactive le mutex), puis continue.

les détails de la façon dont cela est accompli varient évidemment beaucoup selon le langage de programmation.

64
répondu TheSmurf 2008-08-29 16:05:38

lorsque vous avez une application multi-threadée, les différents threads partagent parfois une ressource commune, telle qu'une variable ou similaire. Cette source partagée est souvent inaccessible en même temps, donc une construction est nécessaire pour s'assurer qu'un seul thread utilise cette ressource à la fois.

le concept est appelé" exclusion mutuelle " (mutex court), et est un moyen de s'assurer qu'un seul thread est autorisé à l'intérieur de cette zone, en utilisant cette ressource, etc.

comment les utiliser est spécifique au langage, mais est souvent (si pas toujours) basé sur un système opératoire mutex.

certains langages n'ont pas besoin de cette construction, en raison du paradigme, par exemple la programmation fonctionnelle (Haskell, ML sont de bons exemples).

Maintenant, allez demander à google comment les utiliser! :)

38
répondu Mats Fredriksson 2008-08-29 16:04:47

dans C#, le mutex commun utilisé est le Moniteur . Le type est ' système.Le filetage.Moniteur ". Il peut également être utilisé implicitement via la déclaration ' lock(Object) ". Un exemple de son utilisation est lors de la construction d'une classe Singleton.

private static readonly Object instanceLock = new Object();
private static MySingleton instance;
public static MySingleton Instance
{
    lock(instanceLock)
    {
        if(instance == null)
        {
            instance = new MySingleton();
        }
        return instance;
    }
}

la déclaration de verrouillage utilisant l'objet de verrouillage privé crée une section critique. Exigeant que chaque thread attende jusqu'à ce que le précédent soit terminé. Première fil d'entrer dans la section et initialiser l'instance. Le second thread attendra, entrera dans la section, et obtiendra l'instance initialisée.

Toute sorte de synchronisation d'un membre statique peut utiliser l'instruction verrouillage de la même façon.

25
répondu Anthony Mastrean 2015-04-08 02:07:45

pour comprendre MUTEX, vous devez d'abord savoir ce qu'est la" condition de la race " et ensuite seulement vous comprendrez pourquoi MUTEX est nécessaire. Supposons que vous ayez un programme multi-threading et que vous ayez deux threads. Maintenant, tu as un boulot dans la file d'attente. Le premier thread vérifiera la file d'attente des travaux et, après avoir trouvé le travail, il commencera à l'exécuter. Le second thread vérifiera également la file d'attente des travaux et constatera qu'il y a un travail dans la file d'attente. Ainsi, il assignera également le même pointeur de travail. Donc, maintenant, ce qui il arrive que les deux threads exécutent le même travail. Cela provoquera un défaut de segmentation. C'est l'exemple d'une condition de concurrence.

la solution à ce problème est MUTEX. MUTEX est une sorte de serrure qui verrouille un fil à la fois. Si un autre thread veut verrouiller, le thread obtient tout simplement bloqué.

le lien" MUTEX topic dans ce fichier pdf vaut vraiment la peine d'être lu.

14
répondu user3751012 2014-06-27 09:57:06
Les Mutex

sont utiles dans les situations où vous avez besoin d'imposer un accès exclusif à une ressource à travers plusieurs processus, où un lock régulier ne vous aidera pas, car il ne fonctionne que sur les threads.

11
répondu 18hrs 2008-09-02 18:57:47

Il ya quelques grandes réponses ici, voici une autre grande analogie pour expliquer ce que mutex est:

prendre en considération unique des toilettes avec un clé . Lorsque quelqu'un entre, ils prennent la clé des toilettes occupé . Si quelqu'un d'autre a besoin d'utiliser les toilettes, il doit attendre dans une file d'attente 151980920". Lorsque la personne dans les toilettes est fait , ils passent à la clé à la personne suivante dans la file d'attente. Faire sens, non?

Convertir toilettes dans l'histoire d'un ressource partagée , et le clé à un mutex . Prendre la clé de la toilette (acquérir un verrou) vous autorise à l'utiliser. S'il n'y a pas de clé (la serrure est verrouillée), vous devez attendre. Lorsque la clé est retournée par la personne ( relâcher la serrure vous êtes libre de les acquérir maintenant.

10
répondu Chen A. 2017-10-09 08:54:31

Qu'est-ce qu'un Mutex ?

le mutex (en fait, le terme mutex signifie exclusion mutuelle) aussi connu sous le nom de spinlock est l'outil de synchronisation le plus simple qui est utilisé pour protéger les régions critiques et ainsi prévenir les conditions de course. Qui est un thread doit acquérir une serrure avant d'entrer dans une section critique (dans la section critique, multi threads partagent une variable commune, la mise à jour d'une table, l'écriture d'un fichier et ainsi de suite), il déverrouille la serrure quand elle sort de la section critique.

Qu'est-ce qu'un condition de Race ?

une condition de course se produit lorsque deux ou plusieurs threads peuvent accéder aux données partagées et qu'ils essaient de les modifier en même temps. Parce que l'algorithme d'ordonnancement des threads peut échanger entre les threads à tout moment, vous ne connaissez pas l'ordre dans lequel les threads tenteront d'accéder aux données partagées. Par conséquent, le résultat de la la modification des données dépend de l'algorithme de programmation des threads, c'est-à-dire que les deux threads sont "en course" pour accéder aux données ou les modifier.

exemple de la vie réelle:

quand j'ai une grande discussion animée au travail, j'utilise un caoutchouc le poulet que je garde dans mon bureau pour de telles occasions. Personne tenir le poulet est la seule personne autorisée à parler. Si vous ne tenez pas le poulet que vous ne pouvez pas parler. Vous pouvez indiquer seulement que vous voulez le poulet et attendez de l'avoir avant de parler. Lorsque vous avez fini de parler, vous pouvez remettre le poulet retour à la modérateur qui le remettra à la personne suivante pour parler. Cela garantit que les gens ne parlent pas les uns des autres, et ont aussi leurs propres de l'espace pour en parler.

remplacer poulet avec Mutex et personne avec fil et vous avez essentiellement le concept d'un mutex.

@Xetius

Usage en C#:

cet exemple montre comment un objet Mutex local est utilisé pour synchroniser l'accès à une ressource protégée. Parce que chaque thread d'appel est bloqué jusqu'à ce qu'il acquière la propriété du mutex, il doit appeler la méthode ReleaseMutex pour libérer la propriété du thread.

using System;
using System.Threading;

class Example
{
    // Create a new Mutex. The creating thread does not own the mutex.
    private static Mutex mut = new Mutex();
    private const int numIterations = 1;
    private const int numThreads = 3;

    static void Main()
    {
        // Create the threads that will use the protected resource.
        for(int i = 0; i < numThreads; i++)
        {
            Thread newThread = new Thread(new ThreadStart(ThreadProc));
            newThread.Name = String.Format("Thread{0}", i + 1);
            newThread.Start();
        }

        // The main thread exits, but the application continues to
        // run until all foreground threads have exited.
    }

    private static void ThreadProc()
    {
        for(int i = 0; i < numIterations; i++)
        {
            UseResource();
        }
    }

    // This method represents a resource that must be synchronized
    // so that only one thread at a time can enter.
    private static void UseResource()
    {
        // Wait until it is safe to enter.
        Console.WriteLine("{0} is requesting the mutex", 
                          Thread.CurrentThread.Name);
        mut.WaitOne();

        Console.WriteLine("{0} has entered the protected area", 
                          Thread.CurrentThread.Name);

        // Place code to access non-reentrant resources here.

        // Simulate some work.
        Thread.Sleep(500);

        Console.WriteLine("{0} is leaving the protected area", 
            Thread.CurrentThread.Name);

        // Release the Mutex.
        mut.ReleaseMutex();
        Console.WriteLine("{0} has released the mutex", 
            Thread.CurrentThread.Name);
    }
}
// The example displays output like the following:
//       Thread1 is requesting the mutex
//       Thread2 is requesting the mutex
//       Thread1 has entered the protected area
//       Thread3 is requesting the mutex
//       Thread1 is leaving the protected area
//       Thread1 has released the mutex
//       Thread3 has entered the protected area
//       Thread3 is leaving the protected area
//       Thread3 has released the mutex
//       Thread2 has entered the protected area
//       Thread2 is leaving the protected area
//       Thread2 has released the mutex

Référence MSDN Mutex

2
répondu habib 2018-07-03 02:53:20