C ++ STDMUTEX/

Ved å bruke mutex -nøkkelordet, kan vi låse variabelen vår fra å få tilgang til flere tråder samtidig. Mutex brukes til å gi synkronisering i C ++, noe som betyr at bare en tråd kan motta objektet på en gang. Tråder har ikke tilgang til det låste kodestykket når låsen er opprettet. Koden er låst ved hjelp av mutexes. Så selv om tråd 2 er planlagt mens tråd 1 fremdeles bruker den delte ressursen, vil ikke tråd 2 kunne få tilgang til den delen av koden. Som et resultat er synkronisert tilgang til delte ressurser i koden sikret.

Arbeid av mutex i C++

Tenk på en situasjon der en tråd kjører en del av koden som en mutex har låst. Hvis planleggeren bestemmer seg for å endre konteksten, er alle de andre trådene som er forberedt på å utføre samme sone ikke blokkeres. Bare en tråd av alle de andre ville være i stand til å oppnå dette, men hvis denne tråden forsøkte å utføre en låst del av koden, ville den igjen gå i dvale.

Det vil bli gjentatte kontekstbrytere, men inntil mutex -låsen over den låste koden er frigjort, vil ingen tråd kunne utføre den. En tråd som låste en mutex, kan ikke frigjøre den.

Derfor sørger dette for at når en tråd låser en del av koden, kan ingen annen tråd utføre den regionen før den låste tråden låser den opp.

Så mens du fungerer på delte ressurser, sørger dette systemet for at trådene blir synkronisert.

Ved å påkalle de to følgende funksjonene blir en mutex initialisert og en lås oppnås deretter: Den første metoden initialiserer en mutex og den andre funksjonen muliggjør låsing av en avgjørende del av koden.

# Int pthread_mutex_init (pthread_mutex_trylock *begrenser mutex, const pthread_mutexattribute_trylock *Begrensningsattributt):
Gir en mutex med egenskapene definert av attributtet og en referanse til en annen mutex. Standard mutex -egenskap (ikke -rekursiv) brukes hvis attributtet er null. Hvis Pthread Mutex init () er vellykket, returnerer den 0 og initialiserer og låser opp Mutex's State. Pthread mutex init () returnerer -1 hvis den ikke lykkes.

# int pthread_mutex_lock (pthread_mutex_trylock *mutex):
Klassifiserer en mutex og låser et mutex -objekt. Den eksisterende tråden skal vente på at mutex skal låse opp hvis den tidligere har blitt låst av en annen tråd. En mutex er låst av tråden som låste den, og den tråden fortsetter å være Mutexs eier til den tråden låser den opp. Måten en lås brukes på kan variere avhengig av om mutex har den rekursive karakteristikken eller ikke. Når den samme tråden låser samme type mutex mer enn en gang, økes tellingen og det opprettes ingen ventende tråd.

For å redusere tellingen til null, må den å eie tråden ringe et like stort antall samtaler til pthread_mutex_unlock ().Hvis vellykket, returnerer Pthread_Mutex_lock () -funksjonen 0. Pthread_mutex_lock () returnerer -1 hvis det mislykkes.

Ved å utføre de to handlingene som er angitt nedenfor, kan mutex låses opp og ødelegges. Låsen kan åpnes ved hjelp av den første teknikken, og den kan også ødelegges slik at den ikke kan brukes i fremtiden.

# int pthread_mutex_unlock (pthread_mutex_trylock *mutex):
Mutex -objektet blir utgitt. Hvis flere eller flere tråder står i kø for å blokkere mutex, tvinger Pthread mutex unlock () en av trådene til å gjøre det. Den tvinger den også til å flykte fra pThread mutex lock () med objektet mutex den hadde mottatt tidligere. Mutex låses opp med mindre ingen tråder venter og den har ingen eier for øyeblikket. Bruken av låsen kan endre seg hvis mutex har den rekursive karakteristikken.

Når den samme tråden låser en gitt mutex mer enn en gang, reduseres tellingen ved lås opp og det opprettes ingen ventende tråd for å opprettholde låsen. Mutex fjernes og eventuelle ventende tråder blir lagt ut hvis tellingen er nede til null. Pthread_mutex_unlock () returnerer 0 hvis vellykket. Pthread_mutex_unlock () returnerer -1 i tilfelle feil.

int pthread_mutex_destroy (pthread_mutex_trylock *mutex): fjerner et mutex -objekt. Noen ganger blir det referert til som en mutex -identifikator fra systemet. Mutexes brukes til å ivareta delte ressurser. MUTEX initialiseres med en feilaktig verdi, men PTHREAD MUTEX INIT muliggjør re-initialisering (). Den vellykkede returverdien av pthread_mutex_destroy () er 0. Pthread_mutex_destroy () returnerer -1 i tilfelle feil.

Eksempel på mutex i C++

En illustrasjon av hvordan trådsynkronisering oppnås med mutexes.

Her har vi først gitt tråd -ID -størrelsen “3”. Deretter har vi initialisert variabel telleren som registrerer frekvensen med trådene som kjøres. Deretter opprettet vi objektlåsen for pthread_mutex_lock. Etter det etablerte vi en funksjon “mutex_func” der vi har tatt låsreferansen og initialisert variabelen “m” med null. Den trinnvise verdien legges inn i tellervariabelen.

Nå har vi definert hovedfunksjonen til dette skriptet. De to variablene er erklært, en for mutex som "m" og en for svikt i mutex som "feil". Når metoden “Mutex Func ()” bruker den delte ressursen ”-telleren”, er den samme mutex låst. Den identiske mutex låses opp etter funksjonen “mutex_func ()”. Mutex blir slettet når begge trådene har fullført hovedfunksjonen. Merk at bare to oppgaver utføres henholdsvis.

I utgangen kan du merke at en tråd har startet. Når den løpende tråden ikke er ødelagt, er den andre oppgaven som ikke har startet, oppgaven. Derfor er begge jobbene og sluttlogger til stede denne gangen. Dermed aktiverte bruk av mutex trådsynkronisering.

Konklusjon

Vi kan låse objektet som inneholder den essensielle funksjonaliteten til applikasjonen vår ved å bruke en mutex. I tillegg unngår dette inkonsekvente data, som er avgjørende for sanntidsapplikasjoner. Som hvordan synkronisering implementeres på andre programmeringsspråk, brukes Mutex. Vi har innlemmet et eksempel for å forklare konseptet STD :: mutex i C ++ programmeringsspråket også.