Was ist ein Mutex?

Question

Ein Mutex ist ein Programmierkonzept, das häufig zur Lösung von Multithreading-Problemen verwendet wird. Meine Frage an die Community:

Was ist ein Mutex und wie verwendet man ihn?

Answer 1

Hier gibt es einige gute Antworten, hier ist eine weitere gute Analogie, um zu erklären, was Mutex ist:

Erwägen Sie einzeln Toilette mit Schlüssel . Wenn jemand eintritt, nimmt er den Schlüssel und die Toilette ist besetzt . Wenn jemand anders auf die Toilette muss, muss er in einer Warteschlange . Wenn die Person auf der Toilette ist fertig geben sie den Schlüssel an die nächste Person in der Warteschlange weiter. Macht doch Sinn, oder?

Konvertieren Sie die Toilette in der Geschichte zu einem gemeinsame Ressource und die Schlüssel zu einer Mutex . Wenn Sie den Schlüssel zur Toilette mitnehmen (ein Schloss erwerben), können Sie sie benutzen. Wenn es keinen Schlüssel gibt (das Schloss ist verschlossen), müssen Sie warten. Wenn der Schlüssel von der Person zurückgegeben wird ( die Sperre aufheben ) können Sie es jetzt erwerben.

Answer 2

In C# ist der übliche Mutex die Monitor . Der Typ ist ''. System.Threading.Monitor '. Sie kann auch implizit über die Option '' verwendet werden. sperren(Objekt) ' Erklärung. Ein Beispiel für ihre Verwendung ist die Konstruktion einer Singleton-Klasse.

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;
    }
}

Die Sperranweisung mit dem privaten Sperrobjekt erzeugt einen kritischen Abschnitt. Dadurch muss jeder Thread warten, bis der vorherige beendet ist. Der erste Thread betritt den Abschnitt und initialisiert die Instanz. Der zweite Thread wartet, betritt den Abschnitt und erhält die initialisierte Instanz.

Jede Art von Synchronisierung eines statischen Mitglieds kann die Lock-Anweisung in ähnlicher Weise verwenden.

Answer 3

Um MUTEX zu verstehen, müssen Sie zunächst wissen, was eine "Race Condition" ist, und erst dann werden Sie verstehen, warum MUTEX benötigt wird. Nehmen wir an, Sie haben ein Multithreading-Programm mit zwei Threads. Nun haben Sie einen Auftrag in der Auftragswarteschlange. Der erste Thread überprüft die Auftragswarteschlange und beginnt nach dem Auffinden des Auftrags mit dessen Ausführung. Der zweite Thread prüft ebenfalls die Auftragswarteschlange und stellt fest, dass sich ein Auftrag in der Warteschlange befindet. Daher weist er auch denselben Auftragszeiger zu. Was nun passiert, ist, dass beide Threads denselben Auftrag ausführen. Dies führt zu einem Segmentierungsfehler. Dies ist ein Beispiel für eine Race Condition.

Die Lösung für dieses Problem ist MUTEX. MUTEX ist eine Art von Sperre, die jeweils einen Thread sperrt. Wenn ein anderer Thread ihn sperren will, wird der Thread einfach blockiert.

Das Thema MUTEX in dieser pdf-Datei Link ist wirklich lesenswert.

Answer 4

Mutexe sind in Situationen nützlich, in denen Sie den exklusiven Zugriff auf eine Ressource über mehrere Prozesse hinweg erzwingen müssen, wo eine reguläre Sperre nicht helfen würde, da sie nur über Threads hinweg funktioniert.

Answer 5

Mutex: Mutex steht für Mut ual Ex chen. Dies bedeutet, dass nur ein Prozess/Thread zu einem bestimmten Zeitpunkt in den kritischen Bereich eintreten kann. Bei der gleichzeitigen Programmierung können mehrere Threads/Prozesse, die eine gemeinsame Ressource (eine Variable, einen gemeinsamen Speicher usw.) aktualisieren, zu einem unerwarteten Ergebnis führen. (Da das Ergebnis davon abhängt, welcher Thread/Prozess den ersten Zugriff erhält).

Um ein solches unerwartetes Ergebnis zu vermeiden, benötigen wir einen Synchronisationsmechanismus, der sicherstellt, dass jeweils nur ein Thread/Prozess Zugriff auf eine solche Ressource erhält.

pthread-Bibliothek bietet Unterstützung für Mutex.

typedef union
{
  struct __pthread_mutex_s
  {
    ***int __lock;***
    unsigned int __count;
    int __owner;
#ifdef __x86_64__
    unsigned int __nusers;
#endif
int __kind;
#ifdef __x86_64__
    short __spins;
    short __elision;
    __pthread_list_t __list;
# define __PTHREAD_MUTEX_HAVE_PREV      1
# define __PTHREAD_SPINS             0, 0
#else
    unsigned int __nusers;
    __extension__ union
    {
      struct
      {
        short __espins;
        short __elision;
# define __spins __elision_data.__espins
# define __elision __elision_data.__elision
# define __PTHREAD_SPINS         { 0, 0 }
      } __elision_data;
      __pthread_slist_t __list;
    };
#endif

Dies ist die Struktur für den Mutex-Datentyp, d.h. pthread_mutex_t. Wenn der Mutex gesperrt ist, wird __lock auf 1 gesetzt. Wenn er entsperrt ist, wird __lock auf 0 gesetzt.

Dadurch wird sichergestellt, dass keine zwei Prozesse/Threads gleichzeitig auf den kritischen Abschnitt zugreifen können.