In applicazioni con un alto numero di utenti come quelle web si ha sempre il rischio di avere più accessi contemporanei alla stessa risorsa.

Questo può non essere un problema se il tipo di risorsa è un database o uno qualsiasi che supporti l'accesso contemporaneo da parte di più thread, ma in molti casi si deve ricorrere a file esterni o altri dispositivi che non supportano accessi multipli.

Per ovviare a questo poblema abbiamo bisogno di gestire una coda di accessi alla stessa risorsa e in questo il .NET Framework ci viene in aiuto, fornendoci una classe denominata Mutex presente nel namespace System.Threading.

Lo scopo di questa classe è di garantire l'accesso esclusivo alla risorsa condivisa di un singolo thread per volta.
I metodi chiave per questa classe sono WaitOne() e ReleaseMutex(), che come fanno intendere i nomi, servono rispettivamente a mettere il attesa il codice finchè la risorsa non è stata rilasciata e comunicare alla successiva in coda che l'operazione del thread corrente in quel metodo è conclusa.

Lo snippet seguente mostra un casistica tipica di accesso contemporaneo:

private static Mutex myMutex = new Mutex();

for(int i = 0; i < 10; i++)
{
  Thread myThread = new Thread(new ThreadStart(WriteFile));
  myThread.Name = "Thread_"+ (i + 1).ToString();
  myThread.Start();
}

private static void WriteFile()
{
  try
  {
    // Metto in coda attesa le risorse seguenti
    myMutex.WaitOne();

    Console.WriteLine("Inizio utilizzo risorsa da parte di : {0}", Thread.CurrentThread.Name);

    // Simulo una pausa che potrebbe essere un'operazione su un file.
    Thread.Sleep(500);

    Console.WriteLine("Fine utilizzo della risorsa da parte di {0}", Thread.CurrentThread.Name);
  }
  catch {}
  finally
  {
    // Rilascio le risorse sul file e do via libera al prossimo elemento in coda
    myMutex.ReleaseMutex();
  }
}

A differenza del Monitor (System.Threading.Monitor), il Mutex permette la sincronizzazione di più thread appartenenti a processi differenti e per far ciò è necessario impostare il nome del Mutex tramite un overload del costruttore.