C ++ mutex lås

C ++ er kjent for å være et av de raskeste programmeringsspråkene med god ytelse, høy presisjon og et tilstrekkelig minnestyringssystem. Dette programmeringsspråket støtter også samtidig utførelse av flere tråder med deling av flere ressurser mellom dem. I multithreading er tråden bare for å utføre lesedriften som ikke gjør noen problemer, siden tråden ikke blir påvirket av hva de andre trådene gjør på den tiden. Men hvis disse trådene måtte dele ressursene mellom dem, kan en tråd endre dataene på det tidspunktet som gjør problemet. For å håndtere dette problemet, har vi C ++ “mutex” som forhindrer tilgangen til flere ressurser mot koden/objektet vårt ved å gi synkroniseringen som sier at tilgangen til objektet/koden bare kan gis til en tråd på en gang, slik at flere av tråder ikke kunne få tilgang til det objektet samtidig.

Fremgangsmåte:

Vi vil bli kjent med hvordan vi kan stoppe tilgangen til flere tråder til et objekt på en enkelt tid ved hjelp. Vi vil snakke om syntaksen til Mutex -låsen, hva som er flere gjenger, og hvordan vi kan håndtere problemene forårsaket av flere tråd ved bruk av mutex -låsen. Deretter vil vi ta et eksempel på flere tråd og implementere mutex -låsen på dem.

Syntaks:

Hvis vi ønsker å lære hvordan vi kan implementere mutex -låsen slik at vi kan forhindre tilgang av flere tråder samtidig mot vårt objekt eller kode, kan vi bruke følgende syntaks:

$ std :: mutex mut_x
$ mut_x. lås ();
Void func_name ()
$ // kode vi vil skjule for flere trådene vil bli skrevet her
$ mut_x. Lås opp ();

Vi vil nå bruke denne syntaksen på dummy -eksemplet og i pseudokoden (at vi ikke bare kan kjøre som den er i kodeditoren) for å fortelle deg hvordan vi nøyaktig kan bruke denne syntaksen som nevnt i det følgende:

$ std :: mutex mut_x
Void block ()
$ mut_x. lås ();
$ std :: cout << “hello”;
$ mut_x. Lås opp ();

Eksempel:

I dette eksemplet, la oss prøve å opprette multithread -operasjonen først og deretter omgi denne operasjonen med mutex -lås og låse opp for å gi synkronisering av operasjonen til koden eller objektet som er opprettet. Mutex omhandler raseforhold som er verdiene som er ganske uforutsigbare, og de er avhengige av å bytte trådene som er tidsbevisste. For å implementere eksemplet for Mutex, må vi først importere de viktige og nødvendige bibliotekene fra depotene. De nødvendige bibliotekene er:

$ # inkluderer
$ # inkluderer
$ # inkluderer

"Iostream" -biblioteket gir oss en funksjon for å vise dataene som cout, lese dataene som CIN og avslutte uttalelsen som slutt. Vi bruker "tråd" -biblioteket for å bruke programmene eller funksjonene fra trådene. "Mutex" -biblioteket lar oss implementere både mutex -låsen og låse opp i koden. Vi bruker "# inkluderer" fordi dette tillater alle programmene relatert til biblioteket som er inkludert i koden.

Nå, etter at forrige trinn er ferdig, definerer vi mutex -klassen eller en global variabel for mutex ved hjelp av STD. Deretter oppretter vi en funksjon for mutex -lås og låser opp som vi kan ringe etterpå i koden. I dette eksemplet kaller vi denne funksjonen som blokkering. I kroppen av blokkeringsfunksjonen kaller vi først “mutex.Lås () ”og begynn å skrive logikken i koden.

Mutex.Lås () nekter tilgangen til de andre trådene for å nå vårt opprettede objekt eller kode, slik at bare en tråd kan lese objektet vårt på en gang. I logikken kjører vi en for loop som kjører på indeksen fra 0 til 9. Vi viser verdiene i løkken. Når denne logikken er opprettet i mutex -låsen etter at operasjonen er ferdig eller etter at du har forlatt logikken, kaller vi “mutex.Lås opp () ”-metode. Denne metodesamtalen lar oss låse opp det opprettede objektet fra mutex -låsen siden objektets tilgang til en enkelt tråd ble gitt tidligere, og når operasjonen på det objektet er gjort med en tråd på en gang. Vi vil nå at de andre trådene skal få tilgang til objektet eller koden også. Ellers beveger koden vår i "dødvakt" -situasjonen som får det opprettede objektet med mutex til å forbli i den låste situasjonen for alltid, og ingen annen tråd vil kunne få tilgang til det objektet. Derfor fortsetter en ufullstendig operasjon. Etter dette forlater vi blokkeringsfunksjonen og beveger oss til hoved.

I hovedsak viser vi ganske enkelt vår opprettede mutex ved å lage de tre trådene ved å bruke "std :: tråd trådnavn (kaller den allerede opprettet blokkeringsfunksjonen her vi opprettet mutex)" med navnene tråd1, tråd2 og tråd3 osv. På denne måten opprettes de tre trådene. Vi blir deretter med på disse tre trådene som skal utføres samtidig ved å ringe “trådnavn. Bli med () ”-metode. Og så returnerer vi verdien lik null. Den tidligere nevnte forklaringen av eksemplet er implementert i form av koden som kan vises i følgende figur:

I utdataene fra koden kan vi se utførelsen og visningen av alle de tre trådene en etter en. Vi kan se selv om søknaden vår faller inn under kategorien multithreading. Fortsatt har ingen av trådene overskrevet eller endret dataene og delt den modifiserte ressursen på grunn av implementeringen av mutex av "funksjonsblokken".

Konklusjon

Denne guiden gir en detaljert forklaring av konseptet med mutex -funksjonen som brukes i C++. Vi diskuterte hva som er multithreading -applikasjoner, hvilke problemer vi har for å møte i multithreading -applikasjoner, og hvorfor vi trenger å implementere mutex for multithreading -applikasjoner. Vi diskuterte deretter syntaks for mutex med dummy-eksemplet ved hjelp av pseudokoden. Deretter implementerte vi et komplett eksempel på multithreading -applikasjonene med mutex på C ++ Visual Studio.