O que é um Mutex ?
O mutex (de fato, o termo mutex é abreviação de exclusão mútua), também conhecido como spinlock, é a ferramenta de sincronização mais simples usada para proteger regiões críticas e, assim, evitar condições de corrida. Ou seja, um encadeamento deve adquirir um bloqueio antes de entrar em uma seção crítica (na seção crítica, vários encadeamentos compartilham uma variável comum, atualizando uma tabela, gravando um arquivo etc.), ele libera o bloqueio quando sai da seção crítica.
O que é uma condição de corrida ?
Uma condição de corrida ocorre quando dois ou mais encadeamentos podem acessar dados compartilhados e eles tentam alterá-los ao mesmo tempo. Como o algoritmo de agendamento de encadeamentos pode alternar entre encadeamentos a qualquer momento, você não sabe a ordem em que os encadeamentos tentarão acessar os dados compartilhados. Portanto, o resultado da alteração nos dados depende do algoritmo de agendamento de threads, ou seja, os dois threads estão "correndo" para acessar / alterar os dados.
Exemplo da vida real:
Quando estou tendo uma grande discussão acalorada no trabalho, uso um frango de borracha que guardo na minha mesa para essas ocasiões. A pessoa que segura o frango é a única pessoa que pode falar. Se você não segurar o frango, não poderá falar. Você só pode indicar que deseja o frango e esperar até obtê-lo antes de falar. Depois de terminar de falar, você pode devolver o frango ao moderador, que o entregará à próxima pessoa a falar. Isso garante que as pessoas não falem umas com as outras e também tenham seu próprio espaço para conversar.
Substitua Chicken por Mutex e person por thread e você basicamente tem o conceito de mutex.
@Xetius
Uso em C #:
Este exemplo mostra como um objeto Mutex local é usado para sincronizar o acesso a um recurso protegido. Como cada segmento de chamada é bloqueado até adquirir a propriedade do mutex, ele deve chamar o método ReleaseMutex para liberar a propriedade do segmento.
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
Referência MSDN Mutex