Hvordan får du søvn i C++?

Mens en tråd kjører, er det mulig for tråden å stoppe i noen tid og deretter fortsette å løpe igjen. Dette kalles Sleeping. Programmereren må bestemme om en tråd må sove eller ikke. Hvis tråden må sove, må programmereren bestemme når og hvor (på hvilken plassering av utsagnsekvensen) må tråden sove.

Det neste spørsmålet er: “Hva er en tråd?”En tråd er som et underprogram i et C ++ -program. Et normalt enkelt C ++ -program er som en tråd. Det er hovedfunksjonen () som effektivt er den ene tråden. Hovedfunksjonen () er en funksjon på toppnivå. Et C ++ -program kan ha andre funksjoner på toppnivå. Hver av de andre funksjonene på toppnivå kan konverteres formelt til en tråd. C ++ Main () -funksjonen oppfører seg som en tråd uten noen formell konvertering (til en tråd).

C ++ Standard navneområdet har den statisk-lignende klassen, denne_thread. Denne statisk-lignende klassen har medlemsfunksjonene,

void sleep_for (rel_time)

og

void sleep_until (abs_time)

Disse funksjonene foran med "this_thread ::" kan brukes i hvilken som helst tråd, inkludert hoved- () -funksjonen. Hovedfunksjonen () trenger ingen konvertering til en tråd. Hver av disse funksjonene kan brukes til å få en tråd til å sove. Hver av disse funksjonene tar et argument. Argumentene er imidlertid av forskjellige typer.

sleep_for () bruker relativ tid som argument, mens sleep_until () bruker absolutt tid som argument. rel_time, som betyr relativ tid, er varigheten for at tråden skal sove. På den annen side, med abs_time, som betyr absolutt_tid, for funksjonen sleep_until (), er abs_time tidspunktet når tråden vil våkne opp fra søvn. I dette tilfellet begynner tråden å sove når funksjonen Sleep_until () utføres.
TIME_POINT I C ++ er tidspunktet etter UNIX -epoken. Unix -epoken er 1. januar 1970.

Denne artikkelen forklarer hvordan du får en tråd til å sove. Det begynner med et sammendrag av hvordan du koder en tråd. Det forklarer også hvordan du lager et enkelt program i C ++, sove.

Artikkelinnhold

• Trådkodingsoppsummering
• Relative og absolutte tidsobjekter
• Sov etter relativ tid
• Sove av absolutt tid
• Konklusjon

Trådkodingsoppsummering

Følgende program har to tråder: hvorav den ene er hovedfunksjonen (), og den andre er, Thr:

#inkludere
#inkludere
ved hjelp av navneområdet STD;
void funct ()
cout <<"Code A goes here." <cout <<"Code B goes here." <
int main ()

tråd Thr (Funct);
thr.bli med();
retur 0;

Utgangen er:

Kode A går her.
Kode B går hit.

Programmet begynner med inkludering av iostream -biblioteket. Deretter er det inkludering av trådbiblioteket, som er et must. Neste linje etter er en uttalelse. Denne uttalelsen sikrer at ethvert navn som brukes under det i programmet er av standard navneområdet med mindre annet er angitt. Så er det definisjonen av toppnivåfunksjonen, Funct ().

Etter at definisjonen er hovedfunksjonen (). Hoved () -funksjonen er også en funksjonsdefinisjon. Den første uttalelsen i Main () -funksjonen instantierer tråden, THR. Argumentet til THR er navnet på toppnivåfunksjonen, Funct (). I denne instantieringen kalles funksjonen, funksjonen (). Den effektive tråden er toppnivåfunksjonen. Legg merke til at hoved () -funksjonen, som en tråd, ikke har noen formell erklæring for en tråd, men funksjonen, Funct () har.

Neste uttalelse i Main () -funksjonen er uttalelsen om Join (). Denne uttalelsen må være i funksjonen til den anropende tråden. Hvis denne uttalelsen er fraværende, kan den viktigste () tråden kjøres til fullføring uten at tråden er fullført seg selv. Faktisk, hvis denne uttalelsen er fraværende, vil ikke G ++ -kompilatoren sammenstille programmet, og det vil utstede en feilmelding.

Relative og absolutte tidsobjekter
Varighet, intervall

Sleep_for () -funksjonen tar et varighetsobjekt som argument. Dette er relativ tid. Med inkludering av Chrono -biblioteket kan de relative tidsobjektene opprettes som følger:

Chrono :: timer HS (3);
Chrono :: Minutes MS (3);
Chrono :: Seconds SS (3);
Chrono :: millisekunder MSS (3);
Chrono :: Microseconds Miss (3);

Her er det 3 timer med navnet, HS; 3 minutter med navnet, MS; 3 sekunder med navnet, SS; 3 millisekunder med navnet, MSS; og 3 mikrosekunder med navnet, frøken.

1 millisekund = 1/1000 sekunder. 1 mikrosekund = 1/1000000 sekunder.

Tidspunkt

TIME_POINT I C ++, er tidspunktet etter UNIX -epoken. Unix -epoken er 1. januar 1970. Dette er absolutt tid. Funksjonen, sleep_until () bruker absolutt tidsobjekt som argument. Med inkludering av Chrono -biblioteket kan de absolutte tidsobjektene, etter nå, opprettes som følger:

Chrono :: System_Clock :: Time_Point TP = Chrono :: System_Clock :: Now () + Chrono :: timer (3);
Chrono :: System_Clock :: Time_Point TP = Chrono :: System_Clock :: Now () + Chrono :: Minutes (3);
Chrono :: System_Clock :: Time_Point TP = Chrono :: System_Clock :: Now () + Chrono :: Seconds (3);
Chrono :: System_Clock :: Time_Point TP = Chrono :: System_Clock :: Now () + Chrono :: Milliseconds (3);
Chrono :: System_Clock :: Time_Point TP = Chrono :: System_Clock :: Now () + Chrono :: Microseconds (3);

Navnet på hvert av disse objektene er TP.

Sov etter relativ tid
Hovedfunksjon

For å sove etter relativ tid eller varighet, må sleep_for () -funksjonen brukes, forut for "this_thread ::" . Varigheten begynner fra når funksjonen blir utført. Hovedfunksjonen () er hovedtråden, som ikke trenger noen erklæring. I det følgende programmet sover hovedfunksjonen i 1 sekund:

#inkludere
#inkludere
#inkludere
ved hjelp av navneområdet STD;
int main ()

cout <<"Code A goes here." <Chrono :: sekunder SS (1);
this_thread :: sleep_for (ss);
cout <<"Code B goes here." <retur 0;

Utgangen er:

Kode A går her.

Og etter ett sekund,

Kode B går hit.

er vist. Dette ene trådprogrammet har ingen tråderklæring; Fordi tråden er hovedfunksjonen (). Merk at Chrono -biblioteket, så vel som trådbiblioteket, er inkludert.

Utgangen er to strenger fra hovedfunksjonen. I mellom disse strengene er det koden:

Chrono :: sekunder SS (1);
this_thread :: sleep_for (ss);

Legg merke til hvordan søvnfunksjonen har blitt brukt.

Konvensjonell tråd

Forklaringen på konvensjonelle tråder, ligner på forklaringen ovenfor, men timingskoden er i selve trådkroppen. I det følgende programmet sover tråden i 1 sekund:

#inkludere
#inkludere
#inkludere
ved hjelp av navneområdet STD;
void funct ()
cout <<"Code A goes here." <Chrono :: sekunder SS (1);
this_thread :: sleep_for (ss);
cout <<"Code B goes here." <
int main ()

tråd Thr (Funct);
thr.bli med();
retur 0;

Utgangen er:

Kode A går her.

Og etter ett sekund,

Kode B går hit.

er vist. Det er to tråder her: den konvensjonelle tråden og hovedfunksjonen (). Merk at Chrono -biblioteket, så vel som trådbiblioteket, er inkludert.

Utgangen er to strenger i den konvensjonelle trådfunksjonskroppen. I mellom disse strengene er det koden:

Chrono :: sekunder SS (1);
this_thread :: sleep_for (ss);

Legg merke til forholdet mellom disse to uttalelsene.

Sove av absolutt tid

For å sove med absolutt tid, må Sleep_until () -funksjonen brukes, forut for "this_thread ::" . Tiden begynner fra Unix -epoken til en tid i fremtiden. Hvis det absolutte eller tidspunktet er i fortiden, ville det bli ignorert. Så tråden bør faktisk våkne på det tidspunktet i fremtiden.

Hovedfunksjon

Hovedfunksjonen () er hovedtråden, som ikke trenger noen erklæring. I det følgende programmet sover hovedfunksjonen til 1 sekund etter nå, timing fra 1. januar 1970 (Unix Epoch):

#inkludere
#inkludere
#inkludere
ved hjelp av navneområdet STD;
int main ()

cout <<"Code A goes here." <Chrono :: System_Clock :: Time_Point TP = Chrono :: System_Clock :: Now () + Chrono :: Seconds (1);
this_thread :: sleep_until (tp);
cout <<"Code B goes here." <retur 0;

Utgangen er:

Kode A går her.

Og etter ett sekund,

Kode B går hit.

er vist. Dette er et entrådprogram som ikke har noen tråderklæring; Fordi tråden er hovedfunksjonen (). Merk at Chrono -biblioteket, så vel som trådbiblioteket, er inkludert.

Utgangen er to strenger i hovedfunksjonen. I mellom disse strengene er det koden:

Chrono :: System_Clock :: Time_Point TP = Chrono :: System_Clock :: Now () + Chrono :: Seconds (1);
this_thread :: sleep_until (tp);

Legg merke til hvordan søvnfunksjonen har blitt brukt

Konvensjonell tråd

Forklaringen på konvensjonelle tråder, ligner på forklaringen ovenfor, men timingskoden er i selve trådkroppen. I det følgende programmet sover tråden til 1 sekund etter nå:

#inkludere
#inkludere
#inkludere
ved hjelp av navneområdet STD;
void funct ()
cout << "Code A goes here." <Chrono :: System_Clock :: Time_Point TP = Chrono :: System_Clock :: Now () + Chrono :: Seconds (1);
this_thread :: sleep_until (tp);
cout << "Code B goes here." <
int main ()

tråd Thr (Funct);
thr.bli med();
retur 0;

Utgangen er:

Kode A går her.

Og etter ett sekund,

Kode B går hit.

er vist. Det er to tråder her: den konvensjonelle tråden og hovedfunksjonen (). Merk at Chrono -biblioteket, så vel som trådbiblioteket, er inkludert.

Utgangen er to strenger i den konvensjonelle trådfunksjonskroppen. I mellom disse strengene er det koden:

Chrono :: System_Clock :: Time_Point TP = Chrono :: System_Clock :: Now () + Chrono :: Seconds (1);
this_thread :: sleep_until (tp);

Legg merke til forholdet mellom disse to uttalelsene.

Konklusjon

En tråd kan få sove i en varighet eller sove og våkne opp på et fremtidig tidspunkt siden UNIX -epoken. For å sove i en varighet, bruk Sleep_for () -funksjonen. For å sove og våkne, bruk funksjonen Sleep_until (). Hver av disse funksjonene må føres med dette, "this_thread ::". Et normalt enkelt C ++ -program er ett gjenget program. Tråden her er hovedfunksjonen () og trenger ingen tråddeklarasjon.