Például, ha olyan konzolalkalmazást fejlesztünk, ahol tájékoztatnunk kell a felhasználót a sorrendben végrehajtandó feladatokról, az információs üzeneteknek ésszerű ideig fenn kell maradniuk, hogy a felhasználónak legyen ideje elolvasni azokat, mielőtt törlődnek, és a program a következő parancsra lép.
Ebből a Linuxhint cikkből megtudhatja, hogyan használhatja a sleep() függvényt valós idejű késleltetések létrehozására. Megmutatjuk ennek a funkciónak a szintaxisát és leírását, valamint a POSIX által kínált lehetőségeket a másodpercnél rövidebb töredékek késleltetéséhez. Ezután gyakorlati példák, kódok és képek segítségével megmutatjuk, hogyan lehet késleltetni egy program végrehajtását és a jelek hatását erre a funkcióra.
A Sleep() függvény szintaxisa C nyelvben
aláírás nélküli int alvás ( aláírás nélküli int mp )
A Sleep() függvény leírása C nyelvben
A sleep() függvény alvó állapotba helyezi a folyamatot vagy szálat a „sec” bemeneti argumentumban megadott ideig, amely egy előjel nélküli egész szám. A sleep() függvény meghívása után a hívási folyamat addig alszik, amíg időt nem vesz igénybe, vagy jelet nem kap.
Ezt a funkciót gyakran használják 1 másodpercnél hosszabb késleltetések kikényszerítésére valós idejű folyamatok végrehajtása során. 1 másodpercnél rövidebb késleltetések esetén a POSIX biztosítja a mikroszekundumos felbontású usleep() függvényt, amely ugyanazt a metódushívást használja, mint a sleep(). Az 1 mikroszekundumnál rövidebb késleltetésekhez létezik a nanosleep() függvény is 1 nanoszekundumos felbontással, de más hívási módszerrel, ahol a „timespec” struktúrákat használja bemeneti argumentumként a késleltetési idő beállításához.
Ha a sleep() függvény az egész megadott időt felhasználta, akkor eredményként 0-t ad vissza. Ha a végrehajtást megszakítja egy jel érkezése a megadott idő letelte előtt, visszaadja az addig hátralévő másodperceket.
A sleep() függvényt az „unistd.h” fejléc határozza meg. Használatához ezt a fájlt bele kell foglalnunk a kódba az alábbiak szerint:
#include
Hogyan lehet késéseket bevezetni egy folyamatba a Sleep() függvény segítségével
Ebben a példában létrehozunk egy időzítőt, amely egy végtelen ciklusból áll, amelyben kinyomtatjuk az „Eltelt idő” üzenetet a parancskonzolon, majd a folyamat eltelt másodperceit. Ezen ciklusok mindegyike 2 másodpercenként ismétlődik a sleep() függvény okozta késleltetés miatt.
Ehhez veszünk egy üres fájlt „.c” kiterjesztéssel, és hozzáadjuk az „stdio.h” és „unistd.h” fejlécet. Ezután megnyitunk egy üres main() függvényt, és definiáljuk benne az int típusú változó másodperceket, amelyeket az eltelt idő számlálójaként fogunk használni.
A fejlécek beszúrása és a változó deklarálása után egy végtelen ciklust nyitunk, és a benne található printf() függvényt használva megjelenítjük az üzenetet és az időértéket. A következő sorban megnöveljük az időváltozót 2-vel, majd meghívjuk a sleep() függvényt 2-es bemeneti argumentummal. Ily módon ez a ciklus másodpercenként megismétlődik, és egy számlálót kapunk, amely az eltelt időt mutatja a képernyőn. Most pedig nézzük meg ennek az alkalmazásnak a kódját. Lássuk a példa teljes kódját:
#include#include
üres fő- ( )
{
int másodpercig = 0 ;
míg ( 1 )
{
printf ( 'Eltelt idő: %i \n ' , másodpercig ) ;
másodpercig += 2 ;
alvás ( 2 ) ;
}
}
A következőkben egy képet fogunk látni ennek a kódnak a fordításával és végrehajtásával. Amint látjuk, a program 2 másodpercenként kiírja a képernyőre a folyamat végrehajtása óta eltelt másodperceket.
A jelek hatása a Sleep() függvényre
Ebben a példában a jelek hatását szeretnénk megfigyelni egy folyamatra, amelyet a sleep() függvény segítségével alvó állapotba helyezünk. Ehhez készítünk egy egyszerű alkalmazást, amely egy main() függvényből és a 36-os jel kezelőjéből áll.
A main() függvény első sorában deklaráljuk a fennmaradó int típusú változót, ahol tároljuk a sleep() függvény által visszaadott értéket. Ezután a signal() függvénnyel a kezelőt a 36-os jelhez kötjük. A következő sorban megjelenítjük a folyamat PID-jét, amelyet azután arra használunk, hogy egy második shellből jelet küldjünk a folyamatnak. Végül meghívjuk a sleep() függvényt, és a bemeneti argumentumát 60 másodpercre állítjuk, ami elég hosszú ahhoz, hogy jelet küldjön egy második shellről. A fennmaradó változót kimeneti argumentumként küldjük a sleep()-nek.
A 36-os jelhez csatolt kezelő egy kódsorból áll, ahol a printf() függvény kiírja a „Felmaradó idő:” üzenetet, majd azt az értéket, amelyet a sleep() ad vissza, amikor a jel megérkezik a folyamathoz. Nézzük meg ennek a példának a kódját.
#include#include
#include
#include
üres kezelő ( int többi ) ;
üres fő- ( )
{
int többi ;
jel ( 36 , kezelő ) ;
printf ( 'Folyamatazonosító: %i \n ' , getpid ( ) ) ;
többi = alvás ( 60 ) ;
}
üres kezelő ( int többi )
{
printf ( 'Felmaradó idő: %i \n ' , többi ) ;
}
A következő képen látható ennek a kódnak a fordítása és végrehajtása:
Ahhoz, hogy lássuk a jelek hatását ebben a folyamatban, lefordítjuk ezt a kódot, és lefuttatjuk. Ezután egy második terminálról a következő szintaxisú jelet küldjük:
megöl - n jel PIDA következő képen látható a kód végrehajtása az előző konzolban, valamint a következő konzolról küldött jel érkezésének hatásai. Amint látható, a jel elnyomta a sleep() függvény hatását azáltal, hogy felébresztette a folyamatot:
Következtetés
Ebben a Linuxhint cikkben megmutattuk, hogyan használhatod a sleep() függvényt egy folyamat meghatározott számú másodpercre történő alvó állapotba helyezésére. Megmutattuk a szintaxist, valamint a függvény leírását és a hívási metódust is.
Gyakorlati példák, kódrészletek és képek segítségével megmutattuk, hogyan lehet alvó állapotba helyezni egy folyamatot, és mi befolyásolja a jel érkezését az alvási folyamatban a sleep() függvény segítségével.