Halimbawa, kung bubuo kami ng console application kung saan kailangan naming ipaalam sa user ang mga gawain na isasagawa nang sunud-sunod, ang mga mensahe ng impormasyon ay dapat manatili sa isang makatwirang oras upang magkaroon ng oras ang user na basahin ang mga ito bago sila ma-clear at ang programa ay nagpapatuloy sa susunod na utos.
Sa artikulong ito ng Linuxhint, matututunan mo kung paano gamitin ang sleep() function para gumawa ng mga pagkaantala sa real time. Ipapakita namin sa iyo ang syntax at paglalarawan ng function na ito, pati na rin ang mga opsyon na ibinibigay ng POSIX upang lumikha ng mga pagkaantala na may mga fraction na wala pang isang segundo. Pagkatapos, gamit ang mga praktikal na halimbawa, code, at larawan, ipapakita namin sa iyo kung paano ipagpaliban ang pagpapatupad ng isang programa at ang mga epekto ng mga signal sa function na ito.
Syntax ng Sleep() Function sa C Language
hindi pinirmahan int matulog ( hindi pinirmahan int sec )
Paglalarawan ng Sleep() Function sa C Language
Ang sleep() function ay naglalagay ng proseso o thread sa sleep para sa oras sa mga segundo na tinukoy sa 'sec' input argument na isang unsigned integer. Kapag tinawag na ang sleep() function, matutulog ang proseso ng pagtawag hanggang sa mag-time out ito o makatanggap ng signal.
Ang function na ito ay kadalasang ginagamit upang ipatupad ang mahabang pagkaantala ng higit sa 1 segundo sa pagsasagawa ng mga real-time na proseso. Para sa mga pagkaantala na mas mababa sa 1 segundo, ang POSIX ay nagbibigay ng microsecond resolution function, usleep(), na gumagamit ng parehong method call bilang sleep(). Para sa mga pagkaantala na mas mababa sa 1 microsecond, mayroon ding nanosleep() function na may resolution na 1 nanosecond, ngunit may ibang paraan ng pagtawag kung saan ginagamit nito ang mga istrukturang 'timespec' bilang input argument upang itakda ang oras ng pagkaantala.
Kung naubos na ng sleep() function ang lahat ng tinukoy na oras, ibabalik nito ang 0 bilang resulta. Kung ang pagpapatupad ay naantala ng pagdating ng isang senyas bago lumipas ang tinukoy na oras, ibabalik nito ang natitirang bilang ng mga segundo hanggang sa oras na iyon.
Tinukoy ang function na sleep() sa header na 'unistd.h'. Upang magamit ito, kailangan naming isama ang file na ito sa code tulad ng sumusunod:
#include
Paano Magpakilala ng Mga Pagkaantala sa isang Proseso gamit ang Sleep() Function
Sa halimbawang ito, gumawa kami ng timer na binubuo ng walang katapusang loop kung saan ipi-print namin ang mensaheng 'Nakalipas na oras' sa command console, na sinusundan ng mga lumipas na segundo ng proseso. Ang bawat isa sa mga loop na ito ay inuulit bawat 2 segundo dahil sa pagkaantala na sanhi ng sleep() function.
Upang gawin ito, kumuha kami ng isang walang laman na file na may extension na '.c' at idagdag ang mga header na 'stdio.h' at 'unistd.h' dito. Pagkatapos, magbubukas kami ng walang laman na main() function at tukuyin dito ang variable na segundo ng uri int na gagamitin namin bilang counter para sa lumipas na oras.
Kapag naipasok na ang mga header at idineklara ang variable, magbubukas kami ng infinite loop at ginagamit ang printf() function dito upang ipakita ang mensahe at ang halaga ng oras. Sa susunod na linya, dinaragdagan namin ang variable ng oras ng 2 at pagkatapos ay tinatawag ang sleep() function na may halagang 2 bilang input argument. Sa ganitong paraan, inuulit ang cycle na ito bawat segundo at nakakakuha kami ng counter na nagpapakita ng lumipas na oras sa screen. Ngayon, tingnan natin ang code para sa application na ito. Tingnan natin ang kumpletong code para sa halimbawang ito:
#include#include
walang bisa pangunahing ( )
{
int segundo = 0 ;
habang ( 1 )
{
printf ( 'Nakalipas na oras: %i \n ' , segundo ) ;
segundo += 2 ;
matulog ( 2 ) ;
}
}
Sa mga sumusunod, makikita natin ang isang larawan na may compilation at execution ng code na ito. Tulad ng nakikita natin, bawat 2 segundo, ini-print ng programa ang mga lumipas na segundo sa screen mula noong isagawa ang proseso.
Epekto ng Signals sa Sleep() Function
Sa halimbawang ito, gusto naming obserbahan ang epekto ng mga signal sa isang proseso na pinapatulog gamit ang sleep() function. Para magawa ito, gumawa kami ng simpleng application na binubuo ng main() function at handler para sa signal 36.
Sa unang linya ng main() function, ipinapahayag namin ang natitirang variable ng uri int kung saan iniimbak namin ang value na ibinalik ng sleep() function. Pagkatapos, ginagamit namin ang signal() function para i-bind ang handler sa signal 36. Sa susunod na linya, ipinapakita namin ang PID ng proseso na gagamitin namin para magpadala ng signal mula sa pangalawang shell papunta sa proseso. Sa wakas, tinatawag namin ang function na sleep() at itinakda ang input argument nito sa 60 segundo, sapat na tagal upang magpadala ng signal mula sa pangalawang shell. Ipinapadala namin ang natitirang variable bilang output argument sa sleep().
Ang handler na naka-attach sa signal 36 ay binubuo ng isang linya ng code kung saan ang printf() function ay nagpi-print ng 'Time remaining:' na mensahe na sinusundan ng value na ibinalik ng sleep() sa oras na dumating ang signal sa proseso. Dito, tingnan natin ang code para sa halimbawang ito.
#include#include
#include
#include
walang bisa handler ( int natitira ) ;
walang bisa pangunahing ( )
{
int natitira ;
hudyat ( 36 , handler ) ;
printf ( 'ID ng Proseso: %i \n ' , makulit ( ) ) ;
natitira = matulog ( 60 ) ;
}
walang bisa handler ( int natitira )
{
printf ( 'Natitirang oras: %i \n ' , natitira ) ;
}
Ang sumusunod na larawan na nakikita namin ay nagpapakita ng compilation at execution ng code na ito:
Upang makita ang epekto ng mga signal sa prosesong ito, pinagsama-sama namin ang code na ito at patakbuhin ito. Pagkatapos, mula sa pangalawang terminal, nagpapadala kami ng signal na may sumusunod na syntax:
pumatay - n signal PIDAng sumusunod na larawan na nakikita namin ay nagpapakita ng pagpapatupad ng code sa nakaraang console at ang mga epekto ng pagdating ng isang signal na ipinadala mula sa sumusunod na console. Gaya ng nakikita mo, pinigilan ng signal ang epekto ng sleep() function sa pamamagitan ng paggising sa proseso:
Konklusyon
Sa artikulong ito ng Linuxhint, ipinakita namin sa iyo kung paano gamitin ang function na sleep() upang i-sleep ang isang proseso para sa isang tinukoy na bilang ng mga segundo. Ipinakita rin namin sa iyo ang syntax pati na rin ang paglalarawan ng function at ang paraan ng pagtawag.
Gamit ang mga praktikal na halimbawa, mga snippet ng code, at mga larawan, ipinakita namin sa iyo kung paano i-sleep ang isang proseso at kung ano ang nakakaapekto sa pagdating ng signal sa proseso ng sleeping gamit ang sleep() function.