Qu'est-ce qu'un Mutex ?
Le mutex (en fait, le terme mutex est l'abréviation d'exclusion mutuelle) également connu sous le nom de spinlock est l'outil de synchronisation le plus simple utilisé pour protéger les régions critiques et ainsi empêcher les conditions de concurrence. C'est-à-dire qu'un thread doit acquérir un verrou avant d'entrer dans une section critique (dans une section critique, plusieurs threads partagent une variable commune, mettant à jour une table, écrivant un fichier, etc.), il libère le verrou lorsqu'il quitte la section critique.
Qu'est-ce qu'une condition de course ?
Une condition de concurrence critique se produit lorsque deux threads ou plus peuvent accéder aux données partagées et qu'ils essaient de les modifier en même temps. Étant donné que l'algorithme de planification des threads peut à tout moment basculer entre les threads, vous ne connaissez pas l'ordre dans lequel les threads tenteront d'accéder aux données partagées. Par conséquent, le résultat de la modification des données dépend de l'algorithme de programmation des threads, c'est-à-dire que les deux threads sont "en course" pour accéder / modifier les données.
Exemple réel:
Lorsque j'ai une grande discussion animée au travail, j'utilise un poulet en caoutchouc que je garde dans mon bureau pour de telles occasions. La personne qui tient le poulet est la seule personne autorisée à parler. Si vous ne tenez pas le poulet, vous ne pouvez pas parler. Vous pouvez seulement indiquer que vous voulez le poulet et attendre de l'avoir avant de parler. Une fois que vous avez fini de parler, vous pouvez remettre le poulet au modérateur qui le remettra à la prochaine personne à parler. Cela garantit que les gens ne se parlent pas entre eux et ont également leur propre espace pour parler.
Remplacez Poulet par Mutex et personne avec du fil et vous avez fondamentalement le concept d'un mutex.
@Xetius
Utilisation en C #:
Cet exemple montre comment un objet Mutex local est utilisé pour synchroniser l'accès à une ressource protégée. Étant donné que chaque thread appelant est bloqué jusqu'à ce qu'il acquière la propriété du mutex, il doit appeler la méthode ReleaseMutex pour libérer la propriété du 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 de référence MSDN