C ++ STD Atomic

Vi bruker "STD Atomic" hvis vi vil beholde atomisiteten til operasjonen i C++. Atomicity er konseptet som vi får takle når vi jobber i multithreading -operasjoner/applikasjoner der til og med de enkle funksjonene som å lese og skrive i utførelse av samtidig kan lage problemer eller udefinert atferd i koden. For å håndtere en slik situasjon, har C ++ definert “STD :: Atomic” -biblioteket som garanterer en konsistens som er sekvensiell nok for utførelse av lesing og skriving for forskjellige distinkte objekter som skildrer den veldefinerte atferden. Hvis den ene tråden skriver på et tidspunkt, leser den andre tråden på den tiden.

Fremgangsmåte:

Denne artikkelen vil utforske hva Atomicity er og hvordan vi kan bruke begrepene STD Atomic for å håndtere den udefinerte atferden i kodene våre. Vi vil diskutere de forskjellige funksjonene til STD Atomic og implementere de forskjellige eksemplene for STD Atomic. Funksjonen under STD Atomic som vi vil implementere på de forskjellige eksemplene er gitt som følger:

• Enkleste lesing og skriving av verdier
• Slipp og skaffer deg bestilling med minne (modell)
• Utvekslingsmodell
• Hente operasjon

Enkleste lesing og skriving av verdier

La oss opprette en multithread -applikasjon i dette eksemplet der vi lager to tråder: den ene tråden for å lese verdiene og den andre tråden for å skrive verdiene. Ved hjelp av dette eksemplet vil vi prøve å få begrepet STD Atomics, hva er den udefinerte atferden mens vi kjører multithread -applikasjoner, og hvordan STD -atomic eliminerer den udefinerte atferden.

For det starter vi ganske enkelt koden ved å tilordne to forskjellige verdier til to forskjellige variabler av type heltall. Først initialiserer vi variabelen “A” og “B” med heltalldatatypene. Deretter lager vi funksjonen som er skrevet i tomrommet. I denne funksjonen tildeler vi verdiene til både “a” og “b”, e.g. 25 og 20, henholdsvis.

Deretter oppretter vi lesefunksjonen. I lesefunksjonen blir verdiene til “A” og “B” lest med “Std :: Cout <

Produksjon:

Utgangen til dette eksemplet skildrer den udefinerte oppførselen til applikasjonen, da kodeutgangen er enten 0 eller 10. Dette skjedde fordi trådene utførte samtidig og lesekommandoen kan ha blitt gjort under utførelsen av skrivekommandoen. På denne måten fikk vi et ufullstendig resultat i produksjonen.

STD Atomic kan løse dette problemet og kan gjøre den udefinerte atferden i applikasjonen godt definert. For å implementere dette, gjør vi ganske enkelt en liten endring mens vi initialiserer og setter verdiene og datatypene til de definerte variablene ved å bruke “STD :: Atomic”. Vi definerer variabelen “A” og “B” som atomvariablene med “STD :: Atomic Variable Name”. Vi gjør også en liten endring i skrivefunksjonen der vi tidligere bare tildelte verdiene til A og B ved å bruke den tildelende operatøren "=". Men her tildeler vi verdiene ved å bruke “variabelnavnet. butikk (verdi) ”-metode. Vi bruker “variabelnavnet. Last () ”i lesefunksjonen. Resten er den samme som i forrige eksempel.

Verdiene i utgangen blir lest og skrevet på en veldefinert måte. Og multitReading støttes også her.

Slipp og skaffer deg bestilling med minne (modell)

Minnemodellen kan ha stor innvirkning på lese- og skrivefunksjonene til STD Atomic. Minnemodellen er en standardfunksjon som sørger for sekvensiell bestillingskonsistens. En av de mest interessante atommodellene er utgivelsen og anskaffelse av modellen der vi kan lagre minnestillingsutgivelsen for den første tråden og minneordren som er anskaffet for den andre tråden, noe som betyr at enhver butikk/skriv enten atomisk eller ikke-atom er gjort Først i den første tråden før den andre tråden, jeg.e. laste.

Så i eksemplet kan vi til og med endre den ene atomvariabelen “A” til ikke-atom, og den andre variabelen “B” holdes atomisk atomisk. I skrivefunksjonen lagrer vi den ikke-atomiske variabelen “A” ganske enkelt ved å tilordne den hvilken som helst verdi, e.g. 30. Og vi lagrer verdien for atomvariabelen “B” på riktig måte ved å bruke “B. butikk (verdi, std :: memory_order_release) ”. Det samme gjøres i lesefunksjonen også der vi bruker “Std :: cout <

Produksjon:

Operasjonens atomisitet opprettholdes fremdeles med utgivelsen og ervervet minnemodell selv når vi hadde en ikke-atomisk X-variabel. Dette skjedde på grunn av Y’ene (atomisk.butikk) som sørget for at vedlikeholdet av sekvensiell konsistens.

Utvekslingsmodell

Utveksling betyr når vi bytter verdien av en variabel (atomisk) til en annen verdi. I bytte blir verdien først byttet, og deretter blir den forrige verdien som blir byttet av den nye returnert. Når verdien er utvekslet, reflekterer den over enhver etterfølgende operasjon til den verdien. La oss implementere denne utvekslingen av atomvariabler ved hjelp av et eksempel.

I dette eksemplet introduserer vi først den globale atomvariable Foobar som har en viss verdi lik "15". I hovedsak lager vi en tråd som tråd1 og tildeler den en heltallverdi lik 2. Deretter setter vi indeksen fra 0 til 100 ganger for sløyfen. Deretter erstatter vi verdien av Foobar -variabelen til 2 ved å bruke “Foobar. utveksling (verdi) ”. Etter det kommer vi ut av løkken og laster verdien av Foobar -variabelen for å skrive den ut. Etter å ha lastet Foobar -verdien, utveksler vi nå verdien med 18 med ".utveksling (verdi som skal erstattes med) ”metode. Og så igjen, last Foobars verdier og vis dem ved hjelp av utskriftsmetoden.

Her i dette eksemplet må tråden utveksle verdiene for hundre ganger, og verdien av Foobar byttes fra 15 til 28. Enhver operasjon etter denne utvekslingen returnerer den samme verdien som kan sees i utgangen.

Hente

Fetch er den samme som utvekslingsfunksjonen som skriver verdiene og returnerer de tidligere hentet verdiene. Denne operasjonen henter verdien Tha lagres før noen operasjon ble brukt på den. Nå implementerer vi Fetch Add og Fetch Trekker i dette eksemplet. Vi definerer en atomvariabel med datatypen usignert røye som "telling" og initialiserer tellingen med null. Deretter oppretter vi to funksjoner - en for henting add og en annen for å hente trekk. Vi kjører disken til økning 1 for ADD og reduserer 1 for å trekke fra i begge disse funksjonene. Deretter skriver vi ut disse verdiene fra både fetch_add og fetch_sub -funksjoner i hovedsak.

Fetch_add -funksjonen returnerte 0 og 1 som de tidligere verdiene før økning. På samme måte returnerte Fetch_sub 2 og 1 som de tidligere lagrede verdiene før subtraksjon eller reduksjon av den.

Konklusjon

Vi implementerte de grunnleggende operasjonene i “STD :: Atomic” i denne artikkelen. Vi lærte hvordan vi kan takle problemene i multithreading -applikasjoner ved hjelp av STD Atomic. Vi implementerte de forskjellige eksemplene i C ++ for de forskjellige funksjonene som Fetch, Exchange, Reading/Writing og Memory Model of the STD Atomic for å sikre sekvensiell konsistens og veldefinerte atferd for koden for multithread-applikasjoner.