Was ist ein Mutex ?
Der Mutex (der Begriff Mutex steht für gegenseitigen Ausschluss), auch als Spinlock bezeichnet, ist das einfachste Synchronisationswerkzeug, das zum Schutz kritischer Regionen und damit zur Verhinderung von Rennbedingungen verwendet wird. Das heißt, ein Thread muss eine Sperre erhalten, bevor er in einen kritischen Abschnitt eintritt (in einem kritischen Abschnitt teilen sich mehrere Threads eine gemeinsame Variable, aktualisieren eine Tabelle, schreiben eine Datei usw.) und geben die Sperre frei, wenn er den kritischen Abschnitt verlässt.
Was ist eine Rennbedingung ?
Eine Race-Bedingung tritt auf, wenn zwei oder mehr Threads auf gemeinsam genutzte Daten zugreifen können und gleichzeitig versuchen, diese zu ändern. Da der Thread-Planungsalgorithmus jederzeit zwischen Threads wechseln kann, wissen Sie nicht, in welcher Reihenfolge die Threads versuchen, auf die gemeinsam genutzten Daten zuzugreifen. Daher hängt das Ergebnis der Datenänderung vom Thread-Planungsalgorithmus ab, dh beide Threads "rennen" um auf die Daten zuzugreifen / diese zu ändern.
Beispiel aus dem wirklichen Leben:
Wenn ich bei der Arbeit eine große hitzige Diskussion habe, benutze ich ein Gummihuhn, das ich für solche Gelegenheiten in meinem Schreibtisch aufbewahre. Die Person, die das Huhn hält, ist die einzige Person, die sprechen darf. Wenn Sie das Huhn nicht halten, können Sie nicht sprechen. Sie können nur angeben, dass Sie das Huhn möchten, und warten, bis Sie es erhalten, bevor Sie sprechen. Sobald Sie mit dem Sprechen fertig sind, können Sie das Huhn dem Moderator zurückgeben, der es der nächsten Person zum Sprechen übergibt. Dies stellt sicher, dass die Menschen nicht über einander sprechen und auch ihren eigenen Raum zum Reden haben.
Ersetzen Sie Huhn durch Mutex und Person durch Faden und Sie haben im Grunde das Konzept eines Mutex.
@ Xetius
Verwendung in C #:
Dieses Beispiel zeigt, wie ein lokales Mutex-Objekt verwendet wird, um den Zugriff auf eine geschützte Ressource zu synchronisieren. Da jeder aufrufende Thread blockiert wird, bis er den Besitz des Mutex erlangt, muss er die ReleaseMutex-Methode aufrufen, um den Besitz des Threads freizugeben.
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
MSDN-Referenz-Mutex