C++ är känt för att vara ett av de snabbaste programmeringsspråken med bra prestanda, hög precision och ett adekvat minneshanteringssystem. Detta programmeringsspråk stöder också samtidig exekvering av flera trådar med delning av flera resurser mellan dem. I multithreading är tråden bara för att utföra läsoperationen som inte ger några problem eftersom tråden inte påverkas av vad de andra trådarna gör vid den tiden. Men om dessa trådar var tvungna att dela resurserna mellan sig, kan en tråd ändra data vid den tidpunkten vilket gör problemet. För att hantera detta problem har vi C++ 'Mutex' som förhindrar åtkomst av flera resurser till vår kod/objekt genom att tillhandahålla synkroniseringen som säger att åtkomsten till objektet/koden kan ges till endast en tråd åt gången, så att flera trådar inte skulle kunna komma åt det objektet samtidigt.
Procedur:
Vi kommer att få veta hur vi kan stoppa åtkomsten av flera trådar till ett objekt samtidigt med mutex-lås. Vi kommer att prata om syntaxen för mutex-låset, vad är multiple threading och hur vi kan hantera problemen som orsakas av multiple threading med hjälp av mutex-låset. Sedan tar vi ett exempel på flera trådar och implementerar mutex-låset på dem.
Syntax:
Om vi vill lära oss hur vi kan implementera mutex-låset så att vi kan förhindra åtkomst av flera trådar samtidigt till vårt objekt eller vår kod, kan vi använda följande syntax:
$ std :: mutex mut_x
$mut_x. låsa ( ) ;
Ogiltigt func_name ( ) {
$ // kod som vi vill dölja från de flera trådarna skulle skrivas här
$mut_x. låser upp ( ) ;
}
Vi kommer nu att använda denna syntax på dummy-exemplet och i pseudokoden (som vi inte bara kan köra som den är i kodredigeraren) för att låta dig veta hur vi exakt kan använda denna syntax som nämns i följande:
$ std :: mutex mut_x
Ogiltigt block ( ) {
$mut_x. låsa ( ) ;
$ std :: cout << 'Hallå' ;
$mut_x. låser upp ( ) ;
}
Exempel:
I det här exemplet, låt oss försöka skapa flertrådsoperationen först och sedan omge denna operation med mutex lås och upplåsning för att tillhandahålla synkronisering av operationen till koden eller objektet som skapats. Mutex behandlar rasförhållanden som är de värden som är ganska oförutsägbara och de är beroende av att trådarna byts som är tidsmedvetna. För att implementera exemplet för mutex måste vi först importera de viktiga och nödvändiga biblioteken från arkiven. De obligatoriska biblioteken är:
$ # inkluderar
$ # inkludera
$ # inkluderar
'iostream'-biblioteket ger oss en funktion för att visa data som Cout, läsa data som Cin och avsluta uttalandet som endl. Vi använder 'tråd'-biblioteket för att använda programmen eller funktionerna från trådarna. 'Mutex'-biblioteket tillåter oss att implementera både mutex-låset och -upplåsningen i koden. Vi använder '# include' eftersom detta tillåter alla program relaterade till biblioteket som ingår i koden.
Nu, efter att föregående steg är gjort, definierar vi mutex-klassen eller en global variabel för mutexen med hjälp av std. Sedan skapar vi en funktion för mutex-låsning och upplåsning som vi kan anropa efteråt i koden. I det här exemplet namnger vi den här funktionen som block. I blockfunktionens kropp anropar vi först 'mutex.lock()' och börjar skriva kodens logik.
Den mutex.lock() nekar åtkomst av de andra trådarna att nå vårt skapade objekt eller kod så att endast en tråd kan läsa vårt objekt åt gången. I logiken kör vi en for-loop som körs på index från 0 till 9. Vi visar värdena i loopen. När den här logiken har skapats i mutex-låset efter att dess operation är klar eller efter att ha lämnat logiken, anropar vi metoden 'mutex.unlock()'. Det här metodanropet tillåter oss att låsa upp det skapade objektet från mutex-låset eftersom objektets åtkomst till en enskild tråd gavs tidigare och när operationen på det objektet görs av en tråd åt gången. Vi vill nu att de andra trådarna ska få tillgång till det objektet eller koden också. Annars rör sig vår kod i 'deadlock'-situationen vilket gör att det skapade objektet med mutex förblir i den låsta situationen för alltid och ingen annan tråd skulle kunna komma åt det objektet. Därför fortsätter en ofullständig operation att utföras. Efter detta avslutar vi blockfunktionen och går till huvudet.
I huvudsak visar vi helt enkelt vår skapade mutex genom att skapa de tre trådarna med 'std :: tråd trådnamn (kallar den redan skapade blockfunktionen här där vi skapade mutexen)' med namnen tråd1, tråd2 och tråd3, etc. På så sätt skapas de tre trådarna. Vi sammanfogar sedan dessa tre trådar för att exekveras samtidigt genom att anropa 'thread_name. join ()”-metoden. Och sedan returnerar vi värdet lika med noll. Den tidigare nämnda förklaringen av exemplet implementeras i form av koden som kan visas i följande figur:
I utgången av koden kan vi se exekveringen och visningen av alla tre trådarna en efter en. Vi kan se även om vår applikation faller under kategorin multithreading. Ändå har ingen av trådarna skrivit över eller modifierat data och delat den modifierade resursen på grund av implementeringen av mutexet för 'funktionsblocket'.
Slutsats
Den här guiden ger en detaljerad förklaring av konceptet för mutex-funktionen som används i C++. Vi diskuterade vad som är multithreading-applikationer, vilka problem vi har att stöta på i multithreading-applikationer och varför vi behöver implementera mutex för multithreading-applikationer. Vi diskuterade sedan syntaxen för mutexet med dummyexemplet med pseudokoden. Sedan implementerade vi ett komplett exempel på multithreading-applikationerna med mutex på C++ visual studio.