Een mutex is een programmeerconcept dat vaak wordt gebruikt om multithreading-problemen op te lossen. Mijn vraag aan de community:
Wat is een mutex en hoe gebruik je het?
Antwoord 1, autoriteit 100%
Als ik een verhitte discussie heb op het werk, gebruik ik een rubberen kip die ik voor zulke gelegenheden in mijn bureau bewaar. De persoon die de kip vasthoudt, is de enige die mag praten. Als je de kip niet vasthoudt, kun je niet praten. Je kunt alleen aangeven dat je de kip wilt en wachten tot je hem krijgt voordat je spreekt. Als je klaar bent met spreken, kun je de kip teruggeven aan de moderator die het aan de volgende persoon zal overhandigen om te spreken. Dit zorgt ervoor dat mensen niet door elkaar heen praten en ook hun eigen ruimte hebben om te praten.
Vervang Kip door Mutex en persoon door draad en je hebt in feite het concept van een mutex.
Natuurlijk bestaat er niet zoiets als een rubberen mutex. Alleen rubberen kip. Mijn katten hadden ooit een rubberen muis, maar die aten ze op.
Natuurlijk, voordat je de rubberen kip gebruikt, moet je jezelf afvragen of je echt 5 mensen in één kamer nodig hebt en of het niet eenvoudiger is als één persoon in de kamer alleen al het werk doet. Eigenlijk is dit slechts een uitbreiding van de analogie, maar je snapt het idee.
Antwoord 2, autoriteit 7%
Een Mutex is een wederzijds uitsluitende vlag. Het fungeert als een poortwachter naar een deel van de code dat één thread toelaat en de toegang tot alle andere blokkeert. Dit zorgt ervoor dat de code die wordt beheerd slechts door één enkele thread tegelijk wordt geraakt. Zorg ervoor dat u de mutex loslaat als u klaar bent. 🙂
Antwoord 3, autoriteit 4%
Mutual Exclusion. Hier is het Wikipedia-artikel erover.
Het punt van een mutex is om twee draden te synchroniseren. Wanneer u twee threads heeft die probeert toegang te krijgen tot een enkele bron, is het algemene patroon om het eerste blok van de code te hebben die toegang probeert om de Mutex in te stellen voordat u de code invoert. Wanneer het tweede codebloktoegang toegang probeert, ziet het dat de Mutex is ingesteld en wacht totdat het eerste blok van de code is voltooid (en de MUTEX afneemt) en vervolgens doorgaat.
Specifieke details van hoe dit wordt bereikt, varieert uiteraard sterk door programmeertaal.
4, Autoriteit 3%
Wanneer u een toepassing met meerdere schroefdraad hebt, delen de verschillende threads soms een gemeenschappelijke hulpbron, zoals een variabele of soortgelijke. Deze gedeelde bron kan vaak niet tegelijkertijd worden geopend, dus er is een construct nodig om ervoor te zorgen dat slechts één draad die resource tegelijk gebruikt.
Het concept wordt “wederzijdse uitsluiting” (korte mutex) genoemd en is een manier om ervoor te zorgen dat slechts één draad in dat gebied is toegestaan, met behulp van die hulpbron enz.
Hoe ze te gebruiken is taalspecifiek, maar is vaak (zo niet altijd) op basis van een besturingssysteem Mutex.
Sommige talen hebben dit construct niet nodig, vanwege het paradigma, bijvoorbeeld functionele programmering (Haskell, ML zijn goede voorbeelden).
5
Wat is een mutex ?
De Mutex (in feite is de term Mutex kort voor wederzijdse uitsluiting), ook bekend als Spinlock is de eenvoudigste synchronisatietool die wordt gebruikt om kritieke regio’s te beschermen en zo rasomstandigheden te voorkomen. Dat is een draad die een slot moet verwerven voordat u een kritieke sectie binnengaat (in kritieke sectie delen multi-threads een gemeenschappelijke variabele, het bijwerken van een tabel, het bijwerken van een bestand enzovoort), het laat het slot los wanneer het een kritieke sectie laat.
Wat is een Raceconditie?
Er treedt een raceconditie op wanneer twee of meer threads toegang hebben tot gedeelde gegevens en ze proberen deze tegelijkertijd te wijzigen. Omdat het thread scheduling-algoritme op elk moment tussen threads kan wisselen, weet u niet in welke volgorde de threads zullen proberen toegang te krijgen tot de gedeelde gegevens. Daarom is het resultaat van de wijziging in gegevens afhankelijk van het thread scheduling-algoritme, d.w.z. beide threads “racen” om toegang te krijgen tot de gegevens/de gegevens te wijzigen.
Voorbeeld uit het echte leven:
Als ik een grote verhitte discussie op het werk heb, gebruik ik een rubber
kip die ik voor zulke gelegenheden in mijn bureau bewaar. De persoon
het vasthouden van de kip is de enige persoon die mag praten. als jij
houd de kip niet vast die je niet kunt spreken. Dat kun je alleen aangeven
je wilt de kip en wacht tot je hem krijgt voordat je spreekt. Een keer
u bent uitgepraat, kunt u de kip teruggeven aan de
moderator die het aan de volgende persoon zal overhandigen om te spreken. Dit zorgt ervoor
dat mensen niet door elkaar heen praten, en ook hun eigen
ruimte om te praten.Vervang Kip door Mutex en persoon door draad en je hebt in feite het concept van een mutex.
@Xetius
Gebruik in C#:
Dit voorbeeld laat zien hoe een lokaal Mutex-object wordt gebruikt om de toegang tot een beveiligde bron te synchroniseren. Omdat elke aanroepende thread wordt geblokkeerd totdat deze het eigendom van de mutex verwerft, moet deze de ReleaseMutex-methode aanroepen om het eigendom van de thread vrij te geven.
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
6
In C # is de gebruikte gemeenschappelijke Mutex-gebruikte de monitor . Het type is ‘systeem.threading.monitor ‘. Het kan ook impliciet worden gebruikt via de ‘slot (object) ‘verklaring. Een voorbeeld van het gebruik ervan is bij het construeren van een Singleton-klasse.
private static readonly Object instanceLock = new Object();
private static MySingleton instance;
public static MySingleton Instance
{
lock(instanceLock)
{
if(instance == null)
{
instance = new MySingleton();
}
return instance;
}
}
De lock-instructie die het private lock-object gebruikt, creëert een kritieke sectie. Vereisen dat elke thread moet wachten tot de vorige is voltooid. De eerste thread zal de sectie binnengaan en de instantie initialiseren. De tweede thread wacht, gaat naar de sectie en haalt de geïnitialiseerde instantie op.
Elke vorm van synchronisatie van een statisch lid kan de lock-instructie op dezelfde manier gebruiken.
Antwoord 7
Om MUTEX te begrijpen, moet u eerst weten wat “raceconditie” is en dan pas zult u begrijpen waarom MUTEX nodig is. Stel dat je een multi-threading programma hebt en je hebt twee threads. Nu hebt u één taak in de taakwachtrij. De eerste thread controleert de taakwachtrij en na het vinden van de taak begint deze deze uit te voeren. De tweede thread zal ook de taakwachtrij controleren en vaststellen dat er één taak in de wachtrij staat. Het zal dus ook dezelfde taakaanwijzer toewijzen. Dus wat er nu gebeurt, beide threads voeren dezelfde taak uit. Dit zal een segmentatiefout veroorzaken. Dit is het voorbeeld van een raceconditie.
De oplossing voor dit probleem is MUTEX. MUTEX is een soort slot dat één draad tegelijk vergrendelt. Als een andere thread deze wil vergrendelen, wordt de thread gewoon geblokkeerd.
Het MUTEX-onderwerp in dit pdf-bestand-link is echt het lezen waard.
Antwoord 8
Mutexen zijn handig in situaties waarin u exclusieve toegang tot een bron voor meerdere processen moet afdwingen, waar een normale vergrendeling niet helpt, omdat het alleen over threads werkt.
Antwoord 9
Mutex: Mutex staat voor Mutual Exclusion. Het betekent dat slechts één proces/thread tegelijkertijd een kritieke sectie kan binnengaan. Bij gelijktijdig programmeren van meerdere threads/processen kan het bijwerken van de gedeelde bron (elke variabele, gedeeld geheugen enz.) leiden tot een onverwacht resultaat. (Omdat het resultaat afhangt van welke thread/proces de eerste toegang krijgt).
Om zo’n onverwacht resultaat te voorkomen, hebben we een synchronisatiemechanisme nodig, dat ervoor zorgt dat slechts één thread/proces tegelijkertijd toegang krijgt tot zo’n bron.
pthread-bibliotheek biedt ondersteuning voor Mutex.
typedef union
{
struct __pthread_mutex_s
{
***int __lock;***
unsigned int __count;
int __owner;
#ifdef __x86_64__
unsigned int __nusers;
#endif
int __kind;
#ifdef __x86_64__
short __spins;
short __elision;
__pthread_list_t __list;
# define __PTHREAD_MUTEX_HAVE_PREV 1
# define __PTHREAD_SPINS 0, 0
#else
unsigned int __nusers;
__extension__ union
{
struct
{
short __espins;
short __elision;
# define __spins __elision_data.__espins
# define __elision __elision_data.__elision
# define __PTHREAD_SPINS { 0, 0 }
} __elision_data;
__pthread_slist_t __list;
};
#endif
Dit is de structuur voor het mutex-gegevenstype, d.w.z. pthread_mutex_t.
Als mutex is vergrendeld, wordt __lock ingesteld op 1. Als mutex is ontgrendeld, wordt __lock ingesteld op 0.
Dit zorgt ervoor dat er geen twee processen/threads tegelijkertijd toegang hebben tot de kritieke sectie.