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 kjøring av flere tråder med deling av flere ressurser mellom dem. I multithreading er tråden kun for å utføre leseoperasjonen som ikke gir 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 seg, kan en tråd endre dataene på det tidspunktet som gjør problemet. For å håndtere dette problemet har vi C++ 'Mutex' som forhindrer tilgang av flere ressurser til koden/objektet vårt ved å gi synkroniseringen som sier at tilgangen til objektet/koden kan gis til kun én tråd om gangen, slik at flere tråder ikke vil 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 gang ved å bruke mutex-lås. Vi vil snakke om syntaksen til mutex-låsen, hva er multiple threading, og hvordan vi kan håndtere problemene forårsaket av multiple threading ved å bruke mutex-låsen. Deretter vil vi ta et eksempel på flere tråder 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 til flere tråder samtidig til objektet eller koden vår, kan vi bruke følgende syntaks:
$ std :: mutex mut_x
$mut_x. låse ( ) ;
Ugyldig funksjonsnavn ( ) {
$ // kode vi ønsker å skjule fra flere tråder vil bli skrevet her
$mut_x. låser opp ( ) ;
}
Vi vil nå bruke denne syntaksen på dummy-eksemplet og i pseudokoden (som vi ikke bare kan kjøre som den er i kodeeditoren) for å fortelle deg hvordan vi nøyaktig kan bruke denne syntaksen som nevnt i det følgende:
$ std :: mutex mut_x
Ugyldig blokkering ( ) {
$mut_x. låse ( ) ;
$ std :: cout << 'Hallo' ;
$mut_x. låser opp ( ) ;
}
Eksempel:
I dette eksemplet, la oss prøve å lage flertrådsoperasjonen først og deretter omgi denne operasjonen med mutex-lås og opplåsing 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 av tråder 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 setningen som endl. Vi bruker 'tråd'-biblioteket til å bruke programmene eller funksjonene fra trådene. 'Mutex'-biblioteket lar oss implementere både mutex-låsen og -låsen i koden. Vi bruker '# include' fordi dette tillater alle programmene relatert til biblioteket inkludert i koden.
Nå, etter at forrige trinn er gjort, definerer vi mutex-klassen eller en global variabel for mutexen ved å bruke std. Deretter lager vi en funksjon for mutex-lås og opplåsing som vi kan ringe etterpå i koden. I dette eksemplet kaller vi denne funksjonen som blokk. I hoveddelen av blokkfunksjonen kaller vi først 'mutex.lock()' og begynner å skrive logikken til koden.
Mutex.lock() nekter tilgangen til de andre trådene for å nå vårt opprettede objekt eller kode slik at bare én tråd kan lese objektet vårt om gangen. I logikken kjører vi en for-løkke 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 utført eller etter å ha avsluttet logikken, kaller vi 'mutex.unlock()'-metoden. Dette metodekallet lar oss låse opp det opprettede objektet fra mutex-lås siden objektets tilgang til én enkelt tråd ble gitt tidligere og når operasjonen på det objektet er utført av én tråd om gangen. Vi vil nå at de andre trådene også skal få tilgang til det objektet eller koden. Ellers beveger koden vår seg i 'deadlock'-situasjonen som fører til at det opprettede objektet med mutex forblir i den låste situasjonen for alltid, og ingen annen tråd vil kunne få tilgang til det objektet. Derfor fortsetter en ufullstendig operasjon å utføre. Etter dette går vi ut av blokkfunksjonen og går til hovedmenyen.
I hovedsak viser vi ganske enkelt den opprettede mutexen vår ved å lage de tre trådene ved å bruke 'std :: thread thread_name (kaller den allerede opprettede blokkfunksjonen her der vi opprettet mutexen)' med navnene thread1, thread2 og thread3, etc. På denne måten opprettes de tre trådene. Vi slår deretter sammen disse tre trådene for å kjøres samtidig ved å kalle 'thread_name. join ()»-metoden. 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 utgangen av koden kan vi se utførelsen og visningen av alle de tre trådene én etter én. Vi kan se selv om applikasjonen vår faller inn under kategorien multithreading. Likevel har ingen av trådene overskrevet eller modifisert dataene og delt den modifiserte ressursen på grunn av implementeringen av mutexen til 'funksjonsblokken'.
Konklusjon
Denne veiledningen gir en detaljert forklaring av konseptet med mutex-funksjonen som brukes i C++. Vi diskuterte hva multithreading-applikasjonene er, hvilke problemer vi må møte i multithreading-applikasjoner, og hvorfor vi trenger å implementere mutex for multithreading-applikasjoner. Vi diskuterte deretter syntaksen for mutexen med dummyeksemplet ved å bruke pseudokoden. Deretter implementerte vi et komplett eksempel på multithreading-applikasjonene med mutex på C++ visual studio.