Co to jest Mutex ?
Muteks (w rzeczywistości termin mutex jest skrótem od wzajemnego wykluczenia), znany również jako spinlock, jest najprostszym narzędziem synchronizacji, które służy do ochrony krytycznych regionów, a tym samym do zapobiegania warunkom wyścigowym. Oznacza to, że wątek musi uzyskać blokadę przed wejściem do sekcji krytycznej (w sekcji krytycznej wiele wątków ma wspólną zmienną, aktualizuje tabelę, zapisuje plik i tak dalej), zwalnia blokadę, gdy opuszcza sekcję krytyczną.
Co to jest stan wyścigu ?
Wyścig występuje, gdy dwa lub więcej wątków może uzyskać dostęp do współużytkowanych danych i próbują je zmienić w tym samym czasie. Ponieważ algorytm planowania wątków może w dowolnym momencie przełączać się między wątkami, nie znasz kolejności, w której wątki będą próbowały uzyskać dostęp do udostępnionych danych. Dlatego wynik zmiany danych zależy od algorytmu szeregowania wątków, tzn. Oba wątki „ścigają się” w celu uzyskania dostępu / zmiany danych.
Przykład z życia:
Kiedy prowadzę dużą gorącą dyskusję w pracy, używam gumowego kurczaka, który trzymam na biurku na takie okazje. Osoba trzymająca kurczaka jest jedyną osobą, która może rozmawiać. Jeśli nie trzymasz kurczaka, nie możesz mówić. Możesz tylko wskazać, że chcesz kurczaka i poczekać, aż go zdobędziesz, zanim zaczniesz mówić. Kiedy skończysz mówić, możesz oddać kurczaka z powrotem moderatorowi, który przekaże go następnej osobie, która zabierze głos. Zapewnia to, że ludzie nie rozmawiają ze sobą, a także mają własną przestrzeń do rozmowy.
Zamień kurczaka na Mutex, a osobę na nić, a właściwie masz pojęcie mutex.
@Xetius
Zastosowanie w C #:
Ten przykład pokazuje, jak lokalny obiekt Mutex jest używany do synchronizowania dostępu do chronionego zasobu. Ponieważ każdy wywołujący wątek jest blokowany, dopóki nie uzyska prawa własności do muteksu, musi wywołać metodę ReleaseMutex, aby zwolnić własność wątku.
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 Reference Mutex