De exemplu, dacă dezvoltăm o aplicație de consolă în care trebuie să informăm utilizatorul cu privire la sarcinile care vor fi executate în succesiune, mesajele de informare ar trebui să persistă pentru un timp rezonabil, astfel încât utilizatorul să aibă timp să le citească înainte de a fi șters și programul trece la următoarea comandă.
În acest articol Linuxhint, veți învăța cum să utilizați funcția sleep() pentru a crea întârzieri în timp real. Vă vom arăta sintaxa și descrierea acestei funcții, precum și opțiunile pe care POSIX le oferă pentru a crea întârzieri cu fracțiuni mai mici de o secundă. Apoi, folosind exemple practice, coduri și imagini, vă vom arăta cum să întârziați execuția unui program și efectele semnalelor asupra acestei funcții.
Sintaxa funcției Sleep() în limbajul C
nesemnat int dormi ( nesemnat int sec )
Descrierea funcției Sleep() în limbajul C
Funcția sleep() pune procesul sau firul de execuție în stare de repaus pentru timpul în secunde care este specificat în argumentul de intrare „sec”, care este un întreg fără semn. Odată ce funcția sleep() este apelată, procesul de apelare inactivează până când expiră sau primește un semnal.
Această funcție este adesea folosită pentru a impune întârzieri mari de mai mult de 1 secundă în execuția proceselor în timp real. Pentru întârzieri mai mici de 1 secundă, POSIX oferă funcția de rezoluție în microsecunde, usleep(), care utilizează același apel de metodă ca sleep(). Pentru întârzierile mai mici de 1 microsecundă, există și funcția nanosleep() cu o rezoluție de 1 nanosecundă, dar cu o metodă de apel diferită în care utilizează structurile „timespec” ca argumente de intrare pentru a seta timpul de întârziere.
Dacă funcția sleep() a consumat tot timpul specificat, returnează 0 ca rezultat. Dacă execuția este întreruptă de sosirea unui semnal înainte de expirarea timpului specificat, acesta returnează numărul de secunde rămas până la acel moment.
Funcția sleep() este definită în antetul „unistd.h”. Pentru a-l folosi, trebuie să includem acest fișier în cod, după cum urmează:
#include
Cum să introduceți întârzieri într-un proces cu funcția Sleep().
În acest exemplu, creăm un cronometru care constă dintr-o buclă infinită în care tipărim mesajul „Timp scurs” în consola de comandă, urmat de secundele scurse ale procesului. Fiecare dintre aceste bucle se repetă la fiecare 2 secunde din cauza întârzierii cauzate de funcția sleep().
Pentru a face acest lucru, luăm un fișier gol cu extensia „.c” și adăugăm anteturile „stdio.h” și „unistd.h”. Apoi, deschidem o funcție main() goală și definim în ea variabilele secunde de tip int pe care le vom folosi ca numărător pentru timpul scurs.
Odată ce anteturile sunt inserate și variabila este declarată, deschidem o buclă infinită și folosim funcția printf() din ea pentru a afișa mesajul și valoarea timpului. Pe linia următoare, creștem variabila de timp cu 2 și apoi apelăm funcția sleep() cu valoarea 2 ca argument de intrare. În acest fel, acest ciclu se repetă în fiecare secundă și obținem un contor care afișează pe ecran timpul scurs. Acum, să aruncăm o privire la codul acestei aplicații. Să vedem codul complet pentru acest exemplu:
#include#include
gol principal ( )
{
int secunde = 0 ;
in timp ce ( 1 )
{
printf ( „Timp scurs: %i \n ' , secunde ) ;
secunde += 2 ;
dormi ( 2 ) ;
}
}
În cele ce urmează, vom vedea o imagine cu compilarea și execuția acestui cod. După cum putem vedea, la fiecare 2 secunde, programul imprimă pe ecran secundele scurse de la execuția procesului.
Efectul semnalelor asupra funcției Sleep().
În acest exemplu, dorim să observăm efectul semnalelor asupra unui proces care este adormit folosind funcția sleep(). Pentru a face acest lucru, creăm o aplicație simplă care constă dintr-o funcție main() și un handler pentru semnalul 36.
În prima linie a funcției main(), declarăm variabila rămasă de tip int unde stocăm valoarea returnată de funcția sleep(). Apoi, folosim funcția signal() pentru a lega handler-ul la semnalul 36. Pe linia următoare, afișăm PID-ul procesului pe care apoi îl folosim pentru a trimite un semnal de la un al doilea shell către proces. În cele din urmă, apelăm funcția sleep() și setăm argumentul său de intrare la 60 de secunde, suficient de lung pentru a trimite un semnal de la un al doilea shell. Trimitem variabila rămasă ca argument de ieșire la sleep().
Handler-ul care este atașat semnalului 36 constă dintr-o linie de cod în care funcția printf() tipărește mesajul „Timp rămas:” urmat de valoarea returnată de sleep() în momentul în care semnalul ajunge la proces. Aici, să ne uităm la codul pentru acest exemplu.
#include#include
#include
#include
gol manipulator ( int rămas ) ;
gol principal ( )
{
int rămas ;
semnal ( 36 , manipulator ) ;
printf ( „ID proces: %i \n ' , getpid ( ) ) ;
rămas = dormi ( 60 ) ;
}
gol manipulator ( int rămas )
{
printf ( „Timp rămas: %i \n ' , rămas ) ;
}
Următoarea imagine pe care o vedem arată compilarea și execuția acestui cod:
Pentru a vedea efectul semnalelor în acest proces, compilam acest cod și îl rulăm. Apoi, de la un al doilea terminal, trimitem un semnal cu următoarea sintaxă:
ucide - n semnal PIDUrmătoarea imagine pe care o vedem arată execuția codului în consola anterioară și efectele sosirii unui semnal care este trimis de la următoarea consola. După cum puteți vedea, semnalul a suprimat efectul funcției sleep() prin trezirea procesului:
Concluzie
În acest articol Linuxhint, v-am arătat cum să utilizați funcția sleep() pentru a pune un proces în repaus pentru un anumit număr de secunde. De asemenea, v-am arătat sintaxa, precum și descrierea funcției și metoda de apelare.
Folosind exemple practice, fragmente de cod și imagini, v-am arătat cum să puneți un proces în stare de repaus și ce afectează sosirea unui semnal asupra unui proces de adormire folosind funcția sleep().