ఉదాహరణకు, మేము ఒక కన్సోల్ అప్లికేషన్‌ను అభివృద్ధి చేస్తున్నట్లయితే, ఆ క్రమంలో అమలు చేయబడే టాస్క్‌ల గురించి వినియోగదారుకు తెలియజేయాల్సిన అవసరం ఉన్నట్లయితే, సమాచార సందేశాలు సహేతుకమైన సమయం వరకు కొనసాగాలి, తద్వారా వినియోగదారు వాటిని క్లియర్ చేయడానికి ముందు వాటిని చదవడానికి సమయం ఉంటుంది మరియు ప్రోగ్రామ్ తదుపరి ఆదేశానికి వెళుతుంది.
ఈ Linuxhint కథనంలో, నిజ సమయంలో ఆలస్యాన్ని సృష్టించడానికి నిద్ర() ఫంక్షన్‌ను ఎలా ఉపయోగించాలో మీరు నేర్చుకుంటారు. మేము ఈ ఫంక్షన్ యొక్క సింటాక్స్ మరియు వివరణను అలాగే సెకను కంటే తక్కువ భిన్నాలతో ఆలస్యం సృష్టించడానికి POSIX అందించే ఎంపికలను మీకు చూపుతాము. ఆపై, ఆచరణాత్మక ఉదాహరణలు, కోడ్‌లు మరియు చిత్రాలను ఉపయోగించి, ప్రోగ్రామ్ యొక్క అమలును మరియు ఈ ఫంక్షన్‌పై సిగ్నల్‌ల ప్రభావాలను ఎలా ఆలస్యం చేయాలో మేము మీకు చూపుతాము.
సి లాంగ్వేజ్‌లో స్లీప్() ఫంక్షన్ యొక్క సింటాక్స్
సంతకం చేయలేదు int నిద్ర ( సంతకం చేయలేదు int సెకను )
సి భాషలో స్లీప్() ఫంక్షన్ యొక్క వివరణ
స్లీప్() ఫంక్షన్ 'సెకను' ఇన్‌పుట్ ఆర్గ్యుమెంట్‌లో పేర్కొనబడిన సెకన్లలో ప్రక్రియ లేదా థ్రెడ్‌ను నిద్రపోయేలా చేస్తుంది, ఇది సంతకం చేయని పూర్ణాంకం. స్లీప్() ఫంక్షన్‌ని పిలిచిన తర్వాత, కాలింగ్ ప్రక్రియ సమయం ముగిసే వరకు లేదా సిగ్నల్ అందుకునే వరకు నిద్రపోతుంది.
నిజ-సమయ ప్రక్రియల అమలులో 1 సెకను కంటే ఎక్కువ ఆలస్యాన్ని అమలు చేయడానికి ఈ ఫంక్షన్ తరచుగా ఉపయోగించబడుతుంది. 1 సెకను కంటే తక్కువ ఆలస్యం కోసం, POSIX మైక్రోసెకండ్ రిజల్యూషన్ ఫంక్షన్‌ను అందిస్తుంది, usleep(), ఇది స్లీప్() వలె అదే పద్ధతి కాల్‌ని ఉపయోగిస్తుంది. 1 మైక్రోసెకన్ కంటే తక్కువ ఆలస్యం కోసం, 1 నానోసెకన్ల రిజల్యూషన్‌తో నానోస్లీప్() ఫంక్షన్ కూడా ఉంది, అయితే ఇది ఆలస్యం సమయాన్ని సెట్ చేయడానికి “టైంస్‌పెక్” స్ట్రక్చర్‌లను ఇన్‌పుట్ ఆర్గ్యుమెంట్‌లుగా ఉపయోగించే వేరే కాల్ పద్ధతితో ఉంటుంది.
స్లీప్() ఫంక్షన్ పేర్కొన్న సమయం మొత్తాన్ని వినియోగించినట్లయితే, అది ఫలితంగా 0ని అందిస్తుంది. పేర్కొన్న సమయం ముగిసేలోపు సిగ్నల్ రాకతో అమలుకు అంతరాయం కలిగితే, అది ఆ సమయం వరకు మిగిలిన సెకన్ల సంఖ్యను అందిస్తుంది.
నిద్ర() ఫంక్షన్ 'unistd.h' హెడర్‌లో నిర్వచించబడింది. దీన్ని ఉపయోగించడానికి, మేము ఈ ఫైల్‌ని కోడ్‌లో ఈ క్రింది విధంగా చేర్చాలి:
#
స్లీప్() ఫంక్షన్‌తో ప్రక్రియలో ఆలస్యాలను ఎలా పరిచయం చేయాలి
ఈ ఉదాహరణలో, మేము కమాండ్ కన్సోల్‌లో “గడిచిన సమయం” సందేశాన్ని ప్రింట్ చేసే అనంతమైన లూప్‌తో కూడిన టైమర్‌ను సృష్టిస్తాము, ఆ తర్వాత ప్రక్రియ యొక్క గడిచిన సెకన్లు. స్లీప్() ఫంక్షన్ వల్ల ఏర్పడే ఆలస్యం కారణంగా ఈ లూప్‌లు ప్రతి 2 సెకన్లకు పునరావృతమవుతాయి.
దీన్ని చేయడానికి, మేము '.c' పొడిగింపుతో ఖాళీ ఫైల్‌ని తీసుకుంటాము మరియు దానిలో 'stdio.h' మరియు 'unistd.h' హెడర్‌లను జోడిస్తాము. అప్పుడు, మేము ఖాళీ మెయిన్() ఫంక్షన్‌ని తెరిచి అందులో టైప్ ఇంట్ యొక్క వేరియబుల్ సెకనులను నిర్వచిస్తాము, దానిని మనం గడిచిన సమయానికి కౌంటర్‌గా ఉపయోగిస్తాము.
హెడర్‌లు చొప్పించబడిన తర్వాత మరియు వేరియబుల్ డిక్లేర్ చేయబడిన తర్వాత, మేము అనంతమైన లూప్‌ను తెరిచి, సందేశాన్ని మరియు సమయ విలువను ప్రదర్శించడానికి దానిలోని printf() ఫంక్షన్‌ని ఉపయోగిస్తాము. తదుపరి పంక్తిలో, మేము టైమ్ వేరియబుల్‌ను 2 ద్వారా పెంచుతాము మరియు ఆపై 2 విలువతో స్లీప్() ఫంక్షన్‌ను ఇన్‌పుట్ ఆర్గ్యుమెంట్‌గా పిలుస్తాము. ఈ విధంగా, ఈ చక్రం ప్రతి సెకనుకు పునరావృతమవుతుంది మరియు మేము స్క్రీన్‌పై గడిచిన సమయాన్ని ప్రదర్శించే కౌంటర్‌ని పొందుతాము. ఇప్పుడు, ఈ అప్లికేషన్ కోసం కోడ్‌ను చూద్దాం. ఈ ఉదాహరణ కోసం పూర్తి కోడ్‌ని చూద్దాం:
##
శూన్యం ప్రధాన ( )
{
int సెకన్లు = 0 ;
అయితే ( 1 )
{
printf ( 'గడిచిన సమయం: %i \n ' , సెకన్లు ) ;
సెకన్లు += 2 ;
నిద్ర ( 2 ) ;
}
}
కింది వాటిలో, మేము ఈ కోడ్ యొక్క సంకలనం మరియు అమలుతో చిత్రాన్ని చూస్తాము. మేము చూడగలిగినట్లుగా, ప్రతి 2 సెకన్లకు, ప్రోగ్రామ్ ప్రక్రియ యొక్క అమలు నుండి స్క్రీన్‌పై గడిచిన సెకన్లను ప్రింట్ చేస్తుంది.
స్లీప్() ఫంక్షన్‌పై సిగ్నల్స్ ప్రభావం
ఈ ఉదాహరణలో, మేము స్లీప్() ఫంక్షన్‌ని ఉపయోగించి నిద్రపోయే ప్రక్రియపై సిగ్నల్స్ ప్రభావాన్ని గమనించాలనుకుంటున్నాము. దీన్ని చేయడానికి, మేము మెయిన్() ఫంక్షన్ మరియు సిగ్నల్ 36 కోసం హ్యాండ్లర్‌ను కలిగి ఉన్న ఒక సాధారణ అప్లికేషన్‌ను సృష్టిస్తాము.
మెయిన్() ఫంక్షన్ యొక్క మొదటి పంక్తిలో, మేము స్లీప్() ఫంక్షన్ ద్వారా తిరిగి వచ్చే విలువను నిల్వ చేసే టైప్ int యొక్క మిగిలిన వేరియబుల్‌ను ప్రకటిస్తాము. అప్పుడు, హ్యాండ్లర్‌ను సిగ్నల్ 36కి బంధించడానికి మేము సిగ్నల్() ఫంక్షన్‌ని ఉపయోగిస్తాము. తదుపరి లైన్‌లో, మేము ప్రాసెస్ యొక్క PIDని ప్రదర్శిస్తాము, ఆ తర్వాత రెండవ షెల్ నుండి ప్రాసెస్‌కి సిగ్నల్‌ని పంపడానికి ఉపయోగిస్తాము. చివరగా, మేము స్లీప్() ఫంక్షన్‌ని పిలుస్తాము మరియు దాని ఇన్‌పుట్ ఆర్గ్యుమెంట్‌ను 60 సెకన్లకు సెట్ చేస్తాము, రెండవ షెల్ నుండి సిగ్నల్‌ను పంపడానికి సరిపోతుంది. మేము మిగిలిన వేరియబుల్‌ని స్లీప్()కి అవుట్‌పుట్ ఆర్గ్యుమెంట్‌గా పంపుతాము.
సిగ్నల్ 36కి జోడించబడిన హ్యాండ్లర్ కోడ్ లైన్‌ను కలిగి ఉంటుంది, ఇక్కడ printf() ఫంక్షన్ “మిగిలిన సమయం:” సందేశాన్ని ప్రింట్ చేస్తుంది, దాని తర్వాత సిగ్నల్ ప్రాసెస్‌కి వచ్చే సమయంలో నిద్ర() ద్వారా తిరిగి వస్తుంది. ఇక్కడ, ఈ ఉదాహరణ కోసం కోడ్‌ను చూద్దాం.
##
#
#include
శూన్యం హ్యాండ్లర్ ( int మిగిలి ఉంది ) ;
శూన్యం ప్రధాన ( )
{
int మిగిలి ఉంది ;
సిగ్నల్ ( 36 , హ్యాండ్లర్ ) ;
printf ( 'ప్రాసెస్ ID: %i \n ' , గెట్పిడ్ ( ) ) ;
మిగిలి ఉంది = నిద్ర ( 60 ) ;
}
శూన్యం హ్యాండ్లర్ ( int మిగిలి ఉంది )
{
printf ( 'మిగిలిన సమయం: %i \n ' , మిగిలి ఉంది ) ;
}
మేము చూసే క్రింది చిత్రం ఈ కోడ్ యొక్క సంకలనం మరియు అమలును చూపుతుంది:
ఈ ప్రక్రియలో సిగ్నల్స్ ప్రభావాన్ని చూడడానికి, మేము ఈ కోడ్‌ని కంపైల్ చేసి దాన్ని అమలు చేస్తాము. తరువాత, రెండవ టెర్మినల్ నుండి, మేము ఈ క్రింది వాక్యనిర్మాణంతో ఒక సంకేతాన్ని పంపుతాము:
చంపేస్తాయి - n సిగ్నల్ PIDమేము చూసే క్రింది చిత్రం మునుపటి కన్సోల్‌లోని కోడ్ యొక్క అమలును మరియు క్రింది కన్సోల్ నుండి పంపబడిన సిగ్నల్ రాక యొక్క ప్రభావాలను చూపుతుంది. మీరు చూడగలిగినట్లుగా, ప్రక్రియను మేల్కొలపడం ద్వారా సిగ్నల్ నిద్ర() ఫంక్షన్ యొక్క ప్రభావాన్ని అణిచివేసింది:
ముగింపు
ఈ Linuxhint కథనంలో, ఒక ప్రక్రియను నిర్దిష్ట సెకన్లపాటు నిద్రపోయేలా చేయడానికి స్లీప్() ఫంక్షన్‌ను ఎలా ఉపయోగించాలో మేము మీకు చూపించాము. మేము మీకు సింటాక్స్ అలాగే ఫంక్షన్ యొక్క వివరణ మరియు కాలింగ్ పద్ధతిని కూడా చూపించాము.
ఆచరణాత్మక ఉదాహరణలు, కోడ్ స్నిప్పెట్‌లు మరియు చిత్రాలను ఉపయోగించి, స్లీప్() ఫంక్షన్‌ని ఉపయోగించి స్లీపింగ్ ప్రాసెస్‌లో సిగ్నల్ రాకను ప్రభావితం చేసే ప్రక్రియను ఎలా నిద్రావస్థలో ఉంచాలో మేము మీకు చూపించాము.