Che cos'è un Mutex ?
Il mutex (in effetti, il termine mutex è l'abbreviazione di mutua esclusione) noto anche come spinlock è lo strumento di sincronizzazione più semplice che viene utilizzato per proteggere le regioni critiche e quindi prevenire le condizioni di gara. Cioè un thread deve acquisire un blocco prima di entrare in una sezione critica (nella sezione critica più thread condividono una variabile comune, aggiornando una tabella, scrivendo un file e così via), rilascia il blocco quando lascia la sezione critica.
Che cos'è una condizione di gara ?
Una condizione di competizione si verifica quando due o più thread possono accedere ai dati condivisi e tentano di modificarli contemporaneamente. Poiché l'algoritmo di pianificazione dei thread può passare da un thread all'altro in qualsiasi momento, non si conosce l'ordine in cui i thread tenteranno di accedere ai dati condivisi. Pertanto, il risultato della modifica dei dati dipende dall'algoritmo di pianificazione dei thread, ovvero entrambi i thread stanno "correndo" per accedere / modificare i dati.
Esempio di vita reale:
Quando sto avendo una grande discussione accesa sul lavoro, uso un pollo di gomma che tengo nella mia scrivania proprio per queste occasioni. La persona che tiene il pollo è l'unica persona a cui è permesso parlare. Se non tieni il pollo non puoi parlare. Puoi solo indicare che vuoi il pollo e aspettare fino a quando non lo prendi prima di parlare. Una volta che hai finito di parlare, puoi restituire il pollo al moderatore che lo consegnerà alla persona successiva per parlare. Questo assicura che le persone non parlino l'una sull'altra e abbiano anche il loro spazio per parlare.
Sostituisci Chicken con Mutex e persona con thread e fondamentalmente hai il concetto di mutex.
@Xetius
Utilizzo in C #:
Questo esempio mostra come un oggetto Mutex locale viene utilizzato per sincronizzare l'accesso a una risorsa protetta. Poiché ogni thread chiamante viene bloccato fino a quando non acquisisce la proprietà del mutex, è necessario chiamare il metodo ReleaseMutex per rilasciare la proprietà del 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
Mutex di riferimento MSDN