C ++ er kendt for at være et af de hurtigste programmeringssprog med god ydeevne, høj præcision og et tilstrækkeligt hukommelsesstyringssystem. Dette programmeringssprog understøtter også samtidig udførelse af flere tråde med deling af flere ressourcer mellem dem. I multithreading er tråden kun til at udføre læseoperationen, der ikke giver problemer, da tråden ikke bliver påvirket af, hvad de andre tråde laver på det tidspunkt. Men hvis disse tråde skulle dele ressourcerne mellem dem, kan en tråd ændre dataene på det tidspunkt, hvilket gør problemet. For at håndtere dette problem har vi C++ 'Mutex', som forhindrer adgangen til flere ressourcer til vores kode/objekt ved at levere synkroniseringen, som angiver, at adgangen til objektet/koden kun kan gives til én tråd ad gangen, så flere tråde ikke ville være i stand til at få adgang til det objekt samtidigt.
Procedure:
Vi vil få at vide, hvordan vi kan stoppe adgangen af flere tråde til et objekt på én gang ved hjælp af mutex-lås. Vi vil tale om syntaksen for mutex-låsen, hvad er multiple threading, og hvordan vi kan håndtere problemerne forårsaget af multiple threading ved hjælp af mutex-låsen. Derefter vil vi tage et eksempel på flere tråde og implementere mutex-låsen på dem.
Syntaks:
Hvis vi ønsker at lære, hvordan vi kan implementere mutex-låsen, så vi kan forhindre adgangen af flere tråde til vores objekt eller kode samtidigt, kan vi bruge følgende syntaks:
$ std :: mutex mut_x
$mut_x. låse ( ) ;
Ugyldig funktionsnavn ( ) {
$ // kode vi ønsker at skjule fra flere tråde ville blive skrevet her
$mut_x. låser op ( ) ;
}
Vi vil nu bruge denne syntaks på dummy-eksemplet og i pseudokoden (som vi ikke bare kan køre som den er i kodeeditoren) for at fortælle dig, hvordan vi nøjagtigt kan bruge denne syntaks som nævnt i det følgende:
$ std :: mutex mut_x
Ugyldig blokering ( ) {
$mut_x. låse ( ) ;
$ std :: cout << 'Hej' ;
$mut_x. låser op ( ) ;
}
Eksempel:
Lad os i dette eksempel prøve at oprette multithread-operationen først og derefter omgive denne operation med mutex-lås og oplåsning for at give synkroniseringen af operationen til den oprettede kode eller objekt. Mutex beskæftiger sig med raceforhold, som er de værdier, der er ret uforudsigelige, og de er afhængige af skift af tråde, der er tidsbevidste. For at implementere eksemplet for mutex skal vi først importere de vigtige og nødvendige biblioteker fra lagrene. De nødvendige biblioteker er:
$ # inkluderer
$ # inkludere
$ # inkluderer
'iostream'-biblioteket giver os en funktion til at vise dataene som Cout, læse dataene som Cin og afslutte sætningen som endl. Vi bruger 'tråd'-biblioteket til at bruge programmerne eller funktionerne fra trådene. 'Mutex'-biblioteket giver os mulighed for at implementere både mutex-lås og oplåsning i koden. Vi bruger '# include', fordi dette tillader alle de programmer, der er relateret til biblioteket, der er inkluderet i koden.
Nu, efter det forrige trin er udført, definerer vi mutex-klassen eller en global variabel for mutex'en ved hjælp af std. Derefter opretter vi en funktion til mutex-lås og oplåsning, som vi kunne kalde efterfølgende i koden. I dette eksempel kalder vi denne funktion som blok. I hoveddelen af blokfunktionen kalder vi først 'mutex.lock()' og begynder at skrive kodens logik.
Mutex.lock() nægter adgang til de andre tråde for at nå vores oprettede objekt eller kode, så kun én tråd kan læse vores objekt ad gangen. I logikken kører vi en for-løkke, der kører på indekset fra 0 til 9. Vi viser værdierne i løkken. Når først denne logik er oprettet i mutex-låsen efter dens handling er udført eller efter at have forladt logikken, kalder vi 'mutex.unlock()'-metoden. Dette metodekald giver os mulighed for at låse det oprettede objekt op fra mutex-lås, da objektets adgang til en enkelt tråd blev givet tidligere, og når operationen på det objekt udføres af én tråd ad gangen. Vi ønsker nu, at de andre tråde også skal have adgang til det objekt eller kode. Ellers bevæger vores kode sig i 'deadlock'-situationen, hvilket får det oprettede objekt med mutex til at forblive i den låste situation for evigt, og ingen anden tråd ville være i stand til at få adgang til det objekt. Derfor fortsætter en ufuldstændig operation med at udføre. Herefter forlader vi blokfunktionen og går til hovedmenuen.
I hovedsagen viser vi blot vores oprettede mutex ved at oprette de tre tråde ved hjælp af 'std :: tråd trådnavn (kalder den allerede oprettede blokfunktion her, hvor vi oprettede mutex)' med navnene tråd1, tråd2 og tråd3 osv. På denne måde oprettes de tre tråde. Vi forbinder derefter disse tre tråde, der skal udføres samtidigt ved at kalde 'tråd_navn. join ()” metode. Og så returnerer vi værdien lig med nul. Den tidligere nævnte forklaring af eksemplet er implementeret i form af koden, der kan vises i følgende figur:
I outputtet af koden kan vi se udførelsen og visningen af alle de tre tråde én efter én. Vi kan se, selvom vores applikation falder ind under kategorien multithreading. Alligevel har ingen af trådene overskrevet eller ændret dataene og delt den ændrede ressource på grund af implementeringen af mutex af 'funktionsblokken'.
Konklusion
Denne vejledning giver en detaljeret forklaring af begrebet mutex-funktionen, der bruges i C++. Vi diskuterede, hvad er multithreading-applikationer, hvilke problemer vi skal støde på i multithreading-applikationer, og hvorfor vi skal implementere mutex for multithreading-applikationer. Vi diskuterede derefter syntaksen for mutex'et med dummy-eksemplet ved hjælp af pseudo-koden. Derefter implementerede vi et komplet eksempel på multithreading-applikationerne med mutex på C++ visual studio.