¿Qué es un mutex ?
El mutex (de hecho, el término mutex es la abreviatura de exclusión mutua), también conocido como spinlock, es la herramienta de sincronización más simple que se utiliza para proteger las regiones críticas y evitar así las condiciones de carrera. Es decir, un subproceso debe adquirir un bloqueo antes de entrar en una sección crítica (en la sección crítica, varios subprocesos comparten una variable común, actualizar una tabla, escribir un archivo, etc.), libera el bloqueo cuando sale de la sección crítica.
¿Qué es una condición de carrera ?
Una condición de carrera ocurre cuando dos o más subprocesos pueden acceder a datos compartidos e intentan cambiarlos al mismo tiempo. Debido a que el algoritmo de programación de subprocesos puede intercambiar entre subprocesos en cualquier momento, no conoce el orden en que los subprocesos intentarán acceder a los datos compartidos. Por lo tanto, el resultado del cambio en los datos depende del algoritmo de programación de subprocesos, es decir, ambos subprocesos "compiten" para acceder / cambiar los datos.
Ejemplo de la vida real:
Cuando estoy teniendo una gran discusión en el trabajo, uso un pollo de goma que guardo en mi escritorio para esas ocasiones. La persona que sostiene el pollo es la única persona a la que se le permite hablar. Si no sostienes el pollo no puedes hablar. Solo puedes indicar que quieres el pollo y esperar hasta que lo consigas antes de hablar. Una vez que haya terminado de hablar, puede devolver el pollo al moderador, que lo entregará a la siguiente persona para que hable. Esto garantiza que las personas no hablen entre sí y que también tengan su propio espacio para hablar.
Reemplaza Chicken con Mutex y person con thread y básicamente tienes el concepto de mutex.
@Xetius
Uso en C #:
Este ejemplo muestra cómo se usa un objeto Mutex local para sincronizar el acceso a un recurso protegido. Debido a que cada subproceso de llamada se bloquea hasta que adquiere la propiedad del mutex, debe llamar al método ReleaseMutex para liberar la propiedad del subproceso.
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 Referencia Mutex