Javascript అనేది ఒకే-థ్రెడ్ భాష అయినప్పటికీ, Node.js ఆపరేటింగ్ సిస్టమ్‌కు టాస్క్‌లను కేటాయించగలదు, అదే సమయంలో బహుళ టాస్క్‌లను ప్రాసెస్ చేయడానికి అనుమతిస్తుంది. ఆపరేటింగ్ సిస్టమ్‌లోని కార్యకలాపాలు బహుళ-థ్రెడ్‌లుగా ఉన్నందున అనేక పనులు ఒకే సమయంలో పూర్తి చేయాలి. ప్రతి ఆపరేషన్‌తో అనుబంధించబడిన కాల్బ్యాక్ ఈవెంట్ క్యూకి జోడించబడుతుంది మరియు పేర్కొన్న పని పూర్తయినప్పుడు అమలు చేయడానికి Node.js ద్వారా షెడ్యూల్ చేయబడుతుంది.
సమర్థవంతమైన మరియు విశ్వసనీయమైన Node.js కోడ్‌ని వ్రాయడానికి, వినియోగదారు తప్పనిసరిగా ఈవెంట్ లూప్‌ల గురించి దృఢమైన అవగాహన కలిగి ఉండాలి. ఇది పనితీరు సమస్యలను సమర్థవంతంగా పరిష్కరించడంలో కూడా సహాయపడుతుంది. Node.jsలోని ఈవెంట్ లూప్ మెమరీని ఆదా చేస్తుంది మరియు ప్రతి ఒక్కటి పూర్తయ్యే వరకు వేచి ఉండాల్సిన అవసరం లేకుండా ఒకేసారి బహుళ పనులను చేయడానికి మిమ్మల్ని అనుమతిస్తుంది. 'అసమకాలిక' అనే పదం ఇన్‌కమింగ్ అభ్యర్థనలను నిరోధించకుండా నేపథ్యంలో అమలు చేసే ఏదైనా జావాస్క్రిప్ట్ ఫంక్షన్‌ను సూచిస్తుంది.
ఈవెంట్ లూప్‌లకు నేరుగా వెళ్లే ముందు జావాస్క్రిప్ట్ ప్రోగ్రామింగ్ లాంగ్వేజ్‌లోని వివిధ అంశాలను చూద్దాం.
అసమకాలిక ప్రోగ్రామింగ్ భాషగా జావాస్క్రిప్ట్
అసమకాలిక ప్రోగ్రామింగ్ యొక్క భావనలను చూద్దాం. జావాస్క్రిప్ట్ వెబ్, మొబైల్ మరియు డెస్క్‌టాప్ అప్లికేషన్‌లలో ఉపయోగించబడుతుంది, అయితే జావాస్క్రిప్ట్ అనేది సింగిల్-థ్రెడ్, సింక్రోనస్ కంప్యూటర్ ప్రోగ్రామింగ్ లాంగ్వేజ్ అని గమనించాలి.
భావనను అర్థం చేసుకోవడానికి ఒక సాధారణ కోడ్ ఉదాహరణ ఇవ్వబడింది.
ఫంక్షన్ పద్ధతి 1 ( ) {
కన్సోల్. లాగ్ ( 'ఫంక్షన్ 1' )
}
ఫంక్షన్ పద్ధతి 2 ( ) {
కన్సోల్. లాగ్ ( 'ఫంక్షన్ 2' )
}
పద్ధతి1 ( )
పద్ధతి2 ( )
ఈ కోడ్‌లో, రెండు సాధారణ ఫంక్షన్‌లు సృష్టించబడతాయి మరియు మొదట method1 అని పిలుస్తారు, కనుక ఇది మొదట method1ని లాగ్ చేసి తర్వాత తదుపరిదానికి వెళుతుంది.
అవుట్‌పుట్
జావాస్క్రిప్ట్ సింక్రోనస్ ప్రోగ్రామింగ్ లాంగ్వేజ్‌గా
జావాస్క్రిప్ట్ అనేది సింక్రోనస్ ప్రోగ్రామింగ్ లాంగ్వేజ్ మరియు ఒక్కో పంక్తిని ఒకేసారి ఎగ్జిక్యూట్ చేస్తూ పై నుండి క్రిందికి కదులుతున్న ప్రతి పంక్తిని దశలవారీగా అమలు చేస్తుంది. పైన ఇచ్చిన ఉదాహరణ కోడ్‌లో, method1 ముందుగా టెర్మినల్‌లో లాగిన్ చేసి, ఆపై method2లో లాగిన్ చేయబడింది.
నిరోధించే భాషగా జావాస్క్రిప్ట్
సింక్రోనస్ లాంగ్వేజ్ జావాస్క్రిప్ట్‌ను నిరోధించే కార్యాచరణను కలిగి ఉంటుంది. కొనసాగుతున్న ప్రక్రియను పూర్తి చేయడానికి ఎంత సమయం పట్టినా పర్వాలేదు కానీ మునుపటి ప్రక్రియ పూర్తయ్యే వరకు కొత్త ప్రక్రియ ప్రారంభించబడదు. పై కోడ్ ఉదాహరణలో, method1లో చాలా కోడ్ స్క్రిప్ట్ ఉందని అనుకుందాం, దానికి ఎంత సమయం పట్టినా 10 సెకన్లు లేదా ఒక నిమిషం మెథడ్2 మెథడ్1లోని అన్ని కోడ్‌లు అమలు చేయబడే వరకు అమలు చేయబడదు.
బ్రౌజ్ చేస్తున్నప్పుడు వినియోగదారులు దీనిని అనుభవించి ఉండవచ్చు. బ్యాక్-ఎండ్‌లోని బ్రౌజర్‌లో వెబ్ అప్లికేషన్ ఎగ్జిక్యూట్ అయినప్పుడు భారీ కోడ్ భాగం ఎగ్జిక్యూట్ చేయబడుతోంది కాబట్టి బ్రౌజర్ కంట్రోల్ యాక్సెస్‌ని యూజర్‌కు తిరిగి ఇచ్చే ముందు కొంత సమయం వరకు స్తంభింపజేసినట్లు కనిపిస్తుంది. ఈ ప్రవర్తనను నిరోధించడం అంటారు. ప్రస్తుత అభ్యర్థన ప్రాసెస్ చేయబడే వరకు బ్రౌజర్ తదుపరి ఇన్‌కమింగ్ అభ్యర్థనలను అందించదు.
జావాస్క్రిప్ట్ అనేది ఒకే-థ్రెడ్ భాష
జావాస్క్రిప్ట్‌లో ప్రోగ్రామ్‌ను అమలు చేయడానికి థ్రెడ్ ఫంక్షనాలిటీ ఉపయోగించబడుతుంది. థ్రెడ్‌లు ఒక సమయంలో ఒక పనిని మాత్రమే చేయగలవు. ఇతర ప్రోగ్రామింగ్ భాషలు బహుళ-థ్రెడింగ్‌కు మద్దతిస్తాయి మరియు బహుళ టాస్క్‌లను సమాంతరంగా అమలు చేయగలవు, జావాస్క్రిప్ట్ ఏదైనా కోడ్ స్క్రిప్ట్‌ని అమలు చేయడానికి ఒక థ్రెడ్ మాత్రమే కలిగి ఉంటుంది.
జావాస్క్రిప్ట్‌లో వేచి ఉంది
ఈ విభాగంలోని పేరు నుండి స్పష్టంగా, తదుపరి కొనసాగడానికి మా అభ్యర్థన ప్రాసెస్ చేయబడే వరకు వేచి ఉండాలి. నిరీక్షణకు చాలా నిమిషాలు పట్టవచ్చు, ఈ సమయంలో తదుపరి అభ్యర్థనను స్వీకరించరు. కోడ్ స్క్రిప్ట్ వేచి ఉండకుండా కొనసాగితే, కోడ్ లోపాన్ని ఎదుర్కొంటుంది. కోడ్‌ను అసమకాలికంగా చేయడానికి జావాస్క్రిప్ట్‌లో లేదా ప్రత్యేకంగా Node.jsలో కొంత కార్యాచరణను అమలు చేయాలి.
ఇప్పుడు మనం జావాస్క్రిప్ట్ యొక్క విభిన్న అంశాలను అర్థం చేసుకున్నాము, కొన్ని సాధారణ ఉదాహరణల ద్వారా సింక్రోనస్ మరియు ఎసిన్క్రోనస్‌ని అర్థం చేసుకుందాం.
జావాస్క్రిప్ట్‌లో కోడ్ యొక్క సింక్రోనస్ ఎగ్జిక్యూషన్
సిన్క్రోనస్ అంటే కోడ్ వరుసగా లేదా మరింత సరళంగా దశల వారీగా ఎగువ నుండి ప్రారంభించి, లైన్ ద్వారా క్రిందికి కదులుతుంది.
అర్థం చేసుకోవడానికి సహాయపడే ఒక ఉదాహరణ క్రింద ఇవ్వబడింది:
// application.jsకన్సోల్. లాగ్ ( 'ఒకటి' )
కన్సోల్. లాగ్ ( 'రెండు' )
కన్సోల్. లాగ్ ( 'మూడు' )
ఈ కోడ్‌లో, మూడు console.log స్టేట్‌మెంట్‌లు ప్రతి ఒక్కటి ప్రింట్ చేస్తున్నాయి. ముందుగా కన్సోల్‌లో “వన్” అని ప్రింట్ చేయబోయే మొదటి స్టేట్‌మెంట్ 1 ms (అంచనా) కోసం కాల్ స్టాక్‌లోకి పంపబడుతుంది, ఆపై అది టెర్మినల్‌కు లాగిన్ చేయబడుతుంది. ఆ తర్వాత, రెండవ స్టేట్‌మెంట్ కాల్ స్టాక్‌లోకి నెట్టబడుతుంది మరియు ఇప్పుడు సమయం 2 ms మునుపటి నుండి ఒకటి జోడించబడింది మరియు అది కన్సోల్‌కు 'రెండు'ని లాగ్ చేస్తుంది. చివరగా, చివరి స్టేట్‌మెంట్ కాల్ స్టాక్‌లోకి నెట్టబడింది, ప్రస్తుతానికి సమయం 3ms మరియు అది కన్సోల్‌లో 'త్రీ'ని లాగ్ చేస్తుంది.
కింది ఆదేశాన్ని అమలు చేయడం ద్వారా పై కోడ్‌ను అమలు చేయవచ్చు:
నోడ్ అప్లికేషన్. jsఅవుట్‌పుట్
పనితీరు పైన వివరంగా వివరించబడింది మరియు దానిని పరిగణనలోకి తీసుకోవడం ద్వారా అవుట్‌పుట్ రెప్పపాటులో కన్సోల్‌లోకి లాగిన్ చేయబడుతుంది:
జావాస్క్రిప్ట్‌లో కోడ్ యొక్క అసమకాలిక అమలు
ఇప్పుడు మనం కాల్‌బ్యాక్‌లను పరిచయం చేయడం ద్వారా మరియు కోడ్‌ను అసమకాలికంగా చేయడం ద్వారా అదే కోడ్‌ను రీఫాక్టర్ చేద్దాం. పై కోడ్‌ని ఇలా రీఫ్యాక్టర్ చేయవచ్చు:
// application.jsప్రింట్ వన్ ఫంక్షన్ ( తిరిగి కాల్ చేయండి ) {
సమయం ముగిసింది ( ఫంక్షన్ ( ) {
కన్సోల్. లాగ్ ( 'ఒకటి' ) ;
తిరిగి కాల్ చేయండి ( ) ;
} , 1000 ) ;
}
ఫంక్షన్ printTwo ( తిరిగి కాల్ చేయండి ) {
సమయం ముగిసింది ( ఫంక్షన్ ( ) {
కన్సోల్. లాగ్ ( 'రెండు' ) ;
తిరిగి కాల్ చేయండి ( ) ;
} , 2000 ) ;
}
ప్రింట్ త్రీ ఫంక్షన్ ( ) {
సమయం ముగిసింది ( ఫంక్షన్ ( ) {
కన్సోల్. లాగ్ ( 'మూడు' ) ;
} , 3000 ) ;
}
కన్సోల్. లాగ్ ( 'కార్యక్రమం ప్రారంభం' ) ;
ప్రింట్ వన్ ( ఫంక్షన్ ( ) {
ప్రింట్ రెండు ( ఫంక్షన్ ( ) {
ప్రింట్ త్రీ ( ) ;
} ) ;
} ) ;
కన్సోల్. లాగ్ ( 'కార్యక్రమం ముగింపు' ) ;
పై కోడ్‌లో:
- 'ఒకటి', 'రెండు' మరియు 'మూడు' ప్రింట్ చేయడానికి మూడు విధులు ప్రకటించబడ్డాయి, ప్రతి ఫంక్షన్ కోడ్ యొక్క వరుస అమలును అనుమతించే కాల్బ్యాక్ పరామితిని కలిగి ఉంటుంది.
- setTimeout ఫంక్షన్‌ని ఉపయోగించి గడువు ముగిసింది మరియు నిర్దిష్ట ఆలస్యం తర్వాత ప్రింటింగ్ కోసం console.log స్టేట్‌మెంట్ ఉంది.
- 'ప్రోగ్రామ్ ప్రారంభం' మరియు 'ప్రోగ్రామ్ ముగింపు' అనే రెండు సందేశాలు ప్రింట్ చేయబడ్డాయి, ఇవి ప్రోగ్రామ్ ప్రారంభం మరియు ముగింపును సూచిస్తాయి.
- 'ప్రోగ్రామ్ ప్రారంభం' అని ప్రింట్ చేయడం ద్వారా ప్రోగ్రామ్ ప్రారంభమవుతుంది, ఆ తర్వాత ప్రింట్‌వన్ ఫంక్షన్ 1-సెకన్ ఆలస్యంతో అమలు చేయబడుతుంది, ఆపై ప్రింట్ టూ ఫంక్షన్ 2-సెకన్ల ఆలస్యంతో అమలు చేయబడుతుంది మరియు చివరకు ప్రింట్ త్రీ ఫంక్షన్ 3-సెకన్లతో అమలు చేయబడుతుంది. ఆలస్యం.
- వన్, టూ మరియు త్రీని ప్రింట్ చేయడానికి ముందు “ప్రోగ్రామ్ ముగింపు” స్టేట్‌మెంట్‌ను లాగ్ చేసే సెట్‌టైమ్‌అవుట్స్ ఫంక్షన్‌ల లోపల అసమకాలిక కోడ్ అమలు కోసం ప్రోగ్రామ్ వేచి ఉండదు.
అవుట్‌పుట్
టెర్మినల్‌లో ఈ ఆదేశాన్ని అమలు చేయడం ద్వారా పై కోడ్‌ను అమలు చేయండి:
నోడ్ అప్లికేషన్. jsఇప్పుడు టెర్మినల్‌లోని అవుట్‌పుట్ అసమకాలికంగా ఇలా చూపబడుతుంది:
ఇప్పుడు మనకు సింక్రోనస్ మరియు ఎసిన్క్రోనస్ ఎగ్జిక్యూషన్ గురించి పూర్తి అవగాహన ఉంది కాబట్టి Node.jsలో ఈవెంట్ లూప్ యొక్క మా భావనను పటిష్టం చేయడానికి ముందుకు వెళ్దాం.
Node.js: ఈవెంట్ లూప్ మెకానిజం
సిన్క్రోనస్ మరియు అసమకాలిక టాస్క్‌లు రెండింటి అమలు Node.jsలోని ఈవెంట్ లూప్ ద్వారా నిర్వహించబడుతుంది. Node.js ప్రాజెక్ట్ ప్రారంభించబడిన వెంటనే అమలు చేయబడుతుంది మరియు సంక్లిష్టమైన పనులను సిస్టమ్‌కు సజావుగా బదిలీ చేస్తుంది. ప్రధాన థ్రెడ్‌లో ఇతర పనులు సజావుగా సాగేలా ఇది నిర్ధారిస్తుంది.
Node.jsలో ఈవెంట్ లూప్ యొక్క దృశ్య వివరణ
Node.jsలో ఈవెంట్ లూప్ నిరంతరంగా మరియు సెమీ-అనంతంగా ఉంటుంది. Node.js కోడ్ స్క్రిప్ట్ ప్రారంభం ద్వారా ఈవెంట్ లూప్ ప్రారంభించబడుతుంది మరియు ఇది async API కాల్‌లు మరియు ప్రాసెస్‌లను కాల్ చేయడం మరియు కాల్ చేయడం కోసం బాధ్యత వహిస్తుంది.Tick(), మరియు టైమర్‌లను షెడ్యూల్ చేయడం తర్వాత ఈవెంట్ లూప్ యొక్క అమలును పునఃప్రారంభిస్తుంది.
Node.jsలో, ఐదు ప్రధాన రకాల క్యూలు కాల్‌బ్యాక్‌లను నిర్వహిస్తాయి:
- సాధారణంగా min-heap అని పిలువబడే “టైమర్ క్యూ” “setTimeout” మరియు “setInterval”తో అనుబంధించబడిన కాల్‌బ్యాక్‌లను నిర్వహించడానికి బాధ్యత వహిస్తుంది.
- “fs” మరియు “http” మాడ్యూల్స్‌లో వంటి అసమకాలిక ఆపరేషన్‌ల కోసం కాల్‌బ్యాక్‌లు “I/O క్యూ” ద్వారా నిర్వహించబడతాయి.
- 'చెక్ క్యూ' అనేది నోడ్‌కు ప్రత్యేకమైన 'సెట్ఇమీడియేట్' ఫంక్షన్ కోసం కాల్‌బ్యాక్‌లను కలిగి ఉంది.
- 'క్లోజ్ క్యూ' ఏదైనా అసమకాలిక టాస్క్ యొక్క ముగింపు ఈవెంట్‌తో అనుబంధించబడిన కాల్‌బ్యాక్‌లను నిర్వహిస్తుంది.
- చివరగా, “మైక్రో టాస్క్” క్యూలో రెండు వేర్వేరు క్యూలు ఉన్నాయి:
- “nextTick” క్యూలో “process.nextTick” ఫంక్షన్‌తో అనుబంధించబడిన కాల్‌బ్యాక్‌లు ఉన్నాయి.
- స్థానిక ప్రామిస్‌కి సంబంధించిన కాల్‌బ్యాక్‌లను “ప్రామిస్” క్యూ నియంత్రిస్తుంది.
Node.jsలో ఈవెంట్ లూప్ కార్యాచరణ
ఈవెంట్ లూప్ కాల్బ్యాక్ ఎగ్జిక్యూషన్ ఆర్డర్‌ను నియంత్రించే నిర్దిష్ట అవసరాల కింద పనిచేస్తుంది. ప్రాసెస్ ప్రారంభంలో యూజర్ యొక్క సింక్రోనస్ జావాస్క్రిప్ట్ కోడ్‌కు ప్రాధాన్యత ఇవ్వబడుతుంది, కాబట్టి కాల్ స్టాక్ క్లియర్ అయినప్పుడు మాత్రమే ఈవెంట్ లూప్ ప్రారంభమవుతుంది. కింది అమలు క్రమం నిర్మాణాత్మక నమూనాను అనుసరిస్తుంది:
మైక్రోటాస్క్ క్యూలో కాల్‌బ్యాక్‌లకు అత్యధిక ప్రాధాన్యత ఇవ్వబడుతుంది, ఆపై ప్రామిస్ క్యూలో టాస్క్‌ల తర్వాత తదుపరి టిక్ క్యూలో టాస్క్‌లను అమలు చేయడానికి తరలించబడుతుంది. టైమర్ క్యూ కాల్‌బ్యాక్‌లలోని ప్రక్రియలు నిర్వహించబడతాయి, ఆ తర్వాత ప్రతి టైమర్ కాల్బ్యాక్ తర్వాత మైక్రోటాస్క్ క్యూ మళ్లీ సందర్శించబడుతుంది. I/O, చెక్ మరియు క్లోజ్ క్యూలలోని కాల్‌బ్యాక్‌లు ప్రతి దశ తర్వాత సందర్శించిన మైక్రోటాస్క్ క్యూతో ఒకే నమూనాలో అమలు చేయబడతాయి.
ప్రాసెస్ చేయడానికి మరిన్ని కాల్‌బ్యాక్‌లు ఉంటే లూప్ అమలు చేయడం కొనసాగుతుంది. కోడ్ స్క్రిప్ట్ ముగిసినప్పుడు లేదా ప్రాసెస్ చేయడానికి కాల్‌బ్యాక్‌లు ఏవీ మిగిలి లేనప్పుడు, ఈవెంట్ లూప్ సమర్థవంతంగా ముగుస్తుంది.
ఇప్పుడు మేము ఈవెంట్ లూప్‌ను లోతుగా అర్థం చేసుకున్నాము, దాని లక్షణాలను చూద్దాం.
Node.jsలో ఈవెంట్ లూప్ యొక్క లక్షణాలు
ప్రధాన లక్షణాలు:
- ఈవెంట్ లూప్ అనేది అనంతమైన లూప్ మరియు టాస్క్‌లను స్వీకరించిన వెంటనే వాటిని అమలు చేయడం కొనసాగిస్తుంది మరియు టాస్క్‌లు లేనప్పుడు స్లీప్ మోడ్‌లోకి వెళుతుంది కానీ టాస్క్ స్వీకరించిన వెంటనే పని చేయడం ప్రారంభిస్తుంది.
- ఈవెంట్ క్యూలోని టాస్క్‌లు స్టాక్ ఖాళీగా ఉన్నప్పుడు మాత్రమే అమలు చేయబడతాయి అంటే యాక్టివ్ ఆపరేషన్ లేదు.
- ఈవెంట్ లూప్‌లో కాల్‌బ్యాక్‌లు మరియు వాగ్దానాలు ఉపయోగించబడతాయి.
- ఈవెంట్ లూప్ అబ్‌స్ట్రాక్ట్ డేటా టైప్ క్యూ సూత్రాన్ని అనుసరిస్తున్నందున అది మొదటి పనిని పూర్తి చేసి తర్వాత తదుపరిదానికి వెళుతుంది.
ఈవెంట్ లూప్ మరియు అసమకాలిక మరియు సింక్రోనస్ ఎగ్జిక్యూషన్‌ల యొక్క లాజిక్ గురించి పూర్తిగా అర్థం చేసుకున్న తర్వాత, వివిధ దశల గురించి అవగాహన పొందడం ఈవెంట్ లూప్ యొక్క భావనలను పటిష్టం చేస్తుంది.
Node.js ఈవెంట్ లూప్ దశలు
పైన చెప్పినట్లుగా, ఈవెంట్ లూప్ సెమీ-అనంతం. ఇది అనేక దశలను కలిగి ఉంది కానీ కొన్ని దశలు అంతర్గత నిర్వహణ కోసం ఉపయోగించబడతాయి. ఈ దశలు కోడ్ స్క్రిప్ట్‌పై ఎలాంటి ప్రభావం చూపవు.
ఈవెంట్ లూప్ క్యూ యొక్క కార్యాచరణను అనుసరిస్తుంది మరియు ఫస్ట్-ఇన్ మరియు ఫస్ట్-అవుట్ సూత్రంపై టాస్క్‌ను అమలు చేస్తుంది. షెడ్యూల్ చేయబడిన టైమర్లు గడువు ముగిసే వరకు ఆపరేటింగ్ సిస్టమ్ ద్వారా నిర్వహించబడతాయి. గడువు ముగిసిన టైమర్లు టైమర్ల కోసం కాల్బ్యాక్ క్యూలో జోడించబడతాయి.
ఈవెంట్ లూప్ టైమర్ క్యూలో టాస్క్‌లను ఒక్కొక్కటిగా అమలు చేస్తుంది, ఎక్కువ టాస్క్‌లు మిగిలి ఉండవు లేదా గరిష్టంగా అనుమతించబడిన టాస్క్‌ల సంఖ్యను చేరుకుంటుంది. కింది విభాగాలలో ఈవెంట్ లూప్‌ల యొక్క ప్రధాన దశలు వివరించబడ్డాయి.
టైమర్ల దశ
Node.jsలో భవిష్యత్తులో అమలు చేయాల్సిన ఫంక్షన్‌లను షెడ్యూల్ చేయగల టైమర్ API ఉంది. కేటాయించిన సమయం ముగిసిన తర్వాత, టైమర్ కాల్బ్యాక్ షెడ్యూల్ చేయబడిన వెంటనే అమలు చేయబడుతుంది; అయినప్పటికీ, ఆపరేటింగ్ సిస్టమ్ ముగింపు నుండి లేదా ఇతర కాల్‌బ్యాక్‌ల అమలు కారణంగా ఆలస్యం జరగవచ్చు.
టైమర్లు API మూడు ప్రధాన విధులను కలిగి ఉంది:
- సమయం ముగిసింది
- వెంటనే సెట్
- సెట్ ఇంటర్వెల్
పైన పేర్కొన్న విధులు సమకాలికమైనవి. ఈవెంట్ లూప్‌లోని టైమర్ దశ దాని పరిధిని setTimeout మరియు setInterval ఫంక్షన్‌లకు పరిమితం చేసింది. చెక్ ఫంక్షన్ సెట్ఇమీడియట్ ఫంక్షన్‌ను నిర్వహిస్తుండగా.
సైద్ధాంతిక భాగాన్ని పటిష్టం చేయడానికి ఒక సాధారణ ఉదాహరణను పరిశీలిద్దాం:
// application.jsఫంక్షన్ ఆలస్యం ఫంక్షన్ ( ) {
కన్సోల్. లాగ్ ( 'ఆలస్యమైన ఫంక్షన్ గడువు ముగిసిన తర్వాత అమలు చేయబడుతుంది' ) ;
}
కన్సోల్. లాగ్ ( 'కార్యక్రమం ప్రారంభం' ) ;
సమయం ముగిసింది ( ఆలస్యమైన ఫంక్షన్, 2000 ) ;
కన్సోల్. లాగ్ ( 'కార్యక్రమం ముగింపు' ) ;
ఈ కోడ్‌లో:
- 'ప్రోగ్రామ్ ప్రారంభం' స్టేట్‌మెంట్‌ను టెర్మినల్‌కు లాగిన్ చేయడం ద్వారా ప్రోగ్రామ్ ప్రారంభమవుతుంది.
- ఆ తర్వాత ఆలస్యమైన ఫంక్షన్‌ను 2ms టైమర్‌తో పిలుస్తారు, కోడ్ స్క్రిప్ట్ ఆగిపోదు మరియు నేపథ్యంలో ఆలస్యాన్ని నిర్వహిస్తూ ముందుకు సాగుతుంది.
- ప్రకటన “ప్రోగ్రామ్ ముగింపు మొదటి ప్రకటన తర్వాత లాగ్ చేయబడింది.
- 2ms ఆలస్యం తర్వాత, ఆలస్యమైన ఫంక్షన్‌లోని స్టేట్‌మెంట్ టెర్మినల్‌కు లాగ్ చేయబడింది.
అవుట్‌పుట్
అవుట్‌పుట్ ఇలా కనిపిస్తుంది:
ఆలస్యమైన ఫంక్షన్‌ని ప్రాసెస్ చేయడానికి కోడ్ నిలిపివేయబడలేదని చూడవచ్చు; ఇది ముందుకు కదులుతుంది మరియు ఆలస్యం తర్వాత, ఫంక్షన్ కాల్బ్యాక్ ప్రాసెస్ చేయబడుతుంది.
పెండింగ్‌లో ఉన్న కాల్‌బ్యాక్‌లు
ఈవెంట్ లూప్ పోలింగ్ దశలో ఫైల్‌లను చదవడం, నెట్‌వర్క్ కార్యకలాపాలు లేదా ఇన్‌పుట్/అవుట్‌పుట్ టాస్క్‌లు వంటి ఈవెంట్‌లను తనిఖీ చేస్తుంది. Node.jsలో, ఈ పోలింగ్ దశలో కొన్ని ఈవెంట్‌లు మాత్రమే నిర్వహించబడుతున్నాయని తెలుసుకోవడం ముఖ్యం. అయితే, ఈవెంట్ లూప్ యొక్క తదుపరి పునరావృతంలో, కొన్ని ఈవెంట్‌లు పెండింగ్‌లో ఉన్న దశకు వాయిదా వేయబడవచ్చు. సంక్లిష్టమైన ఈవెంట్-ఆధారిత కార్యకలాపాలతో కూడిన Node.js కోడ్‌ని ఆప్టిమైజ్ చేసేటప్పుడు మరియు ట్రబుల్షూటింగ్ చేసేటప్పుడు ఇది గుర్తుంచుకోవలసిన కీలకమైన అంశం.
వేచి ఉన్న కాల్‌బ్యాక్‌ల దశలో, ఈవెంట్ లూప్ వాయిదా వేసిన ఈవెంట్‌లను పెండింగ్‌లో ఉన్న కాల్‌బ్యాక్‌ల క్యూలో జోడిస్తుంది మరియు వాటిని నిర్వహిస్తుందని అర్థం చేసుకోవడం ముఖ్యం. ఈ దశ నిర్దిష్ట ఆపరేటింగ్ సిస్టమ్‌లలో ECONNREFUSED ఎర్రర్ ఈవెంట్‌ల వంటి సిస్టమ్ సృష్టించిన కొన్ని TCP సాకెట్ ఎర్రర్‌లను కూడా నిర్వహిస్తుంది.
భావనను పటిష్టం చేయడానికి క్రింద ఒక ఉదాహరణ పేర్కొనబడింది:
// application.jsస్థిరంగా fs = అవసరం ( 'fs' ) ;
ఫంక్షన్ readFileAsync ( ఫైల్‌పాత్, కాల్బ్యాక్ ) {
fs. రీడ్ ఫైల్ ( './PromiseText.txt' , 'utf8' , ఫంక్షన్ ( తప్పు, డేటా ) {
ఉంటే ( తప్పు ) {
కన్సోల్. లోపం ( ` లోపం ఫైల్ చదవడం : $ { తప్పు. సందేశం } ` ) ;
} లేకపోతే {
కన్సోల్. లాగ్ ( ` ఫైల్ విషయము : $ { సమాచారం } ` ) ;
}
తిరిగి కాల్ చేయండి ( ) ;
} ) ;
}
కన్సోల్. లాగ్ ( 'కార్యక్రమం ప్రారంభం' ) ;
readFileAsync ( './PromiseText.txt' , ఫంక్షన్ ( ) {
కన్సోల్. లాగ్ ( 'ఫైల్ రీడ్ కాల్ బ్యాక్ ఎగ్జిక్యూట్ చేయబడింది' ) ;
} ) ;
కన్సోల్. లాగ్ ( 'కార్యక్రమం ముగింపు' ) ;
ఈ కోడ్‌లో:
- టెర్మినల్‌లో “కార్యక్రమం ప్రారంభం” అనే ప్రకటనను లాగిన్ చేయడం ద్వారా ప్రోగ్రామ్ ప్రారంభించబడుతుంది.
- “PromiseText.txt” ఫైల్ కంటెంట్‌ని చదవడానికి readFileAsync అసమకాలికంగా నిర్వచించబడింది. ఇది ఫైల్ రీడ్ అయిన తర్వాత కాల్బ్యాక్ ఫంక్షన్‌ని అమలు చేసే పారామెట్రైజ్డ్ ఫంక్షన్.
- ఫైల్ రీడింగ్ ప్రక్రియను ప్రారంభించడానికి readFileAsync ఫంక్షన్ అంటారు.
- ఫైల్ రీడింగ్ ప్రక్రియలో, ప్రోగ్రామ్ ఆగిపోదు; బదులుగా, ఇది తదుపరి స్టేట్‌మెంట్‌కు వెళ్లి దానిని 'ప్రోగ్రామ్ ముగింపు' టెర్మినల్‌లోకి లాగ్ చేస్తుంది.
- ఫైల్ రీడింగ్ యొక్క అసమకాలిక ఈవెంట్ ఈవెంట్ లూప్ ద్వారా నేపథ్యంలో ప్రాసెస్ చేయబడుతుంది.
- ఫైల్ అసమకాలికంగా చదవబడిన తర్వాత మరియు కంటెంట్ టెర్మినల్‌కు లాగ్ చేయబడిన తర్వాత ప్రోగ్రామ్ ఫైల్ కంటెంట్‌ను టెర్మినల్‌కు లాగ్ చేస్తుంది. ఆ తర్వాత, ఇది క్రింది సందేశాన్ని లాగ్ చేస్తుంది “ఫైల్ రీడ్ కాల్బ్యాక్ అమలు చేయబడింది”.
- ఈవెంట్ లూప్ తదుపరి దశలో పెండింగ్‌లో ఉన్న కాల్బ్యాక్ కార్యకలాపాలను నిర్వహిస్తుంది.
అవుట్‌పుట్
పై అమలు యొక్క ఫలితం:
నిష్క్రియ, Node.jsలో దశను సిద్ధం చేయండి
Node.jsలో అంతర్గత విధులను ఎదుర్కోవడానికి నిష్క్రియ దశ ఉపయోగించబడుతుంది కాబట్టి ఇది ప్రామాణిక దశ కాదు. ఇది కోడ్ స్క్రిప్ట్‌ను ప్రభావితం చేయదు. నిష్క్రియ దశ ఈవెంట్ లూప్‌కు విరామం కాలం లాంటిది, ఈ సమయంలో నేపథ్యంలో తక్కువ ప్రాధాన్యత గల టాస్క్‌లను నిర్వహిస్తుంది. ఈ దశను అర్థం చేసుకోవడానికి ఒక సాధారణ ఉదాహరణ:
స్థిరంగా { పనిలేకుండా } = అవసరం ( 'idle-gc' ) ;పనిలేకుండా. పట్టించుకోకుండా ( ) ;
ఈ కోడ్‌లో, నిష్క్రియ దశను విస్మరించడానికి అనుమతించే “idle-gc” మాడ్యూల్ ఉపయోగించబడుతుంది. ఈవెంట్ లూప్ బిజీగా ఉన్నప్పుడు మరియు బ్యాక్‌గ్రౌండ్ టాస్క్‌లు నిర్వహించనప్పుడు పరిస్థితులను నిర్వహించడానికి ఇది ఉపయోగపడుతుంది. idle.ignore యొక్క ఉపయోగం సరైనదిగా పరిగణించబడదు ఎందుకంటే ఇది పనితీరు సమస్యలను కలిగిస్తుంది.
Node.jsలో పోలింగ్ దశ
Node.jsలో పోల్ దశ ఇలా పనిచేస్తుంది:
- ఇది పోల్ క్యూలో ఈవెంట్‌లను నిర్వహిస్తుంది మరియు వాటికి సంబంధించిన పనులను నిర్వహిస్తుంది.
- ఇది ప్రక్రియలో I/O ఆపరేషన్‌ల కోసం ఎంత సమయం వేచి ఉండాలో మరియు తనిఖీ చేయాలనేది నిర్ణయిస్తుంది.
టైమర్ లేనందున ఈవెంట్ లూప్ పోల్ దశలోకి ప్రవేశించినందున, దిగువ టాస్క్‌లలో ఒకటి నిర్వహించబడుతుంది:
- Node.jsలో ఈవెంట్ లూప్ యొక్క పోల్ దశలో, పెండింగ్‌లో ఉన్న I/O ఈవెంట్‌లు క్యూలో ఉంచబడతాయి మరియు క్యూ ఖాళీ అయ్యే వరకు ఫస్ట్ ఇన్ మరియు ఫస్ట్ అవుట్ సూత్రాన్ని అనుసరించి సీక్వెన్షియల్ విధానంలో అమలు చేయబడతాయి. కాల్‌బ్యాక్‌ల అమలు సమయంలో తదుపరి టిక్ మరియు మైక్రోటాస్క్‌ల క్యూలు కూడా చర్యలో ఉంటాయి. ఇది సున్నితత్వాన్ని నిర్ధారిస్తుంది మరియు I/O కార్యకలాపాలను మరింత సమర్థవంతంగా మరియు విశ్వసనీయంగా నిర్వహించడానికి అనుమతిస్తుంది.
- క్యూ ఖాళీగా ఉంటే మరియు setImmediate() ఫంక్షన్ ద్వారా స్క్రిప్ట్ షెడ్యూల్ చేయబడకపోతే, ఈవెంట్ లూప్ ముగుస్తుంది మరియు అది తదుపరి దశకు (చెక్) కొనసాగుతుంది. మరోవైపు, setImmediate() ఫంక్షన్ ద్వారా స్క్రిప్ట్ షెడ్యూలింగ్ జరిగితే, ఈవెంట్ లూప్ కాల్‌బ్యాక్‌లను దాని ద్వారా అమలు చేయబడే క్యూకి జోడించడానికి అనుమతిస్తుంది.
ఇది ఒక సాధారణ కోడ్ ఉదాహరణతో ఉత్తమంగా వివరించబడింది:
సమయం ముగిసింది ( ( ) => {కన్సోల్. లాగ్ ( 'Async ఆపరేషన్ పూర్తయింది' ) ;
} , 2000 ) ;
కన్సోల్. లాగ్ ( 'ప్రారంభం' ) ;
వెంటనే సెట్ ( ( ) => {
కన్సోల్. లాగ్ ( 'సెట్ తక్షణ కాల్బ్యాక్ అమలు చేయబడింది' ) ;
} ) ;
కన్సోల్. లాగ్ ( 'ముగింపు' ) ;
ఈ కోడ్‌లో:
- 'ప్రారంభం' మరియు 'ముగింపు' అనే రెండు సందేశాలు ప్రోగ్రామ్ యొక్క ప్రారంభ మరియు ముగింపును సూచిస్తాయి.
- setTimeout() ఫంక్షన్ 2 ms ఆలస్యంతో కాల్బ్యాక్ ఫంక్షన్‌ను సెట్ చేస్తుంది మరియు టెర్మినల్‌కు “Async ఆపరేషన్ పూర్తయింది” అని లాగ్ చేస్తుంది.
- సెట్ఇమ్మీడియేట్() ఫంక్షన్ ప్రారంభ సందేశం టెర్మినల్‌కు లాగిన్ అయిన తర్వాత టెర్మినల్‌కు “సెట్ఇమ్మిడియేట్ కాల్బ్యాక్ ఎగ్జిక్యూట్ చేయబడింది” సందేశాన్ని లాగ్ చేస్తుంది.
అవుట్‌పుట్
'Async ఆపరేషన్ పూర్తయింది' సమయం తీసుకుంటుందని మరియు 'ముగింపు' సందేశం తర్వాత ముద్రించబడిందని అవుట్‌పుట్ కేవలం ఒక నిమిషం పరిశీలనతో సందేశాలను చూపుతుంది:
Node.js తనిఖీ దశ
పోల్ దశ అమలు చేయబడిన తర్వాత చెక్ దశలోని కాల్‌బ్యాక్‌లు అమలు చేయబడతాయి. సెట్ఇమ్మీడియేట్() ఫంక్షన్‌ని ఉపయోగించి కోడ్ స్క్రిప్ట్ షెడ్యూల్ చేయబడి ఉంటే మరియు పోల్ ఫంక్షన్ ఉచితం అయితే, ఈవెంట్ లూప్ నిష్క్రియంగా ఉండకుండా నేరుగా చెక్ ఫేజ్‌కి తరలించడం ద్వారా పని చేస్తుంది. setImmediate() ఫంక్షన్ అనేది ఈవెంట్ లూప్ యొక్క వివిధ దశలలో పనిచేసే ఒక ప్రత్యేకమైన టైమర్.
పోల్ ఫేజ్ ఎగ్జిక్యూషన్ పూర్తయిన తర్వాత కాల్ బ్యాక్ ఎగ్జిక్యూషన్‌లను ప్లాన్ చేయడానికి libuv API ఉపయోగించబడుతుంది. కోడ్ అమలు సమయంలో, ఈవెంట్ లూప్ పోల్ దశలోకి ప్రవేశిస్తుంది, దీనిలో ఇన్‌కమింగ్ కనెక్షన్ అభ్యర్థనల కోసం వేచి ఉంటుంది. మరొక సందర్భంలో setImmediate() ఫంక్షన్‌ని ఉపయోగించి కాల్బ్యాక్ షెడ్యూల్ చేయబడి ఉంటే మరియు పోల్ దశ ఎటువంటి కార్యాచరణ లేకుండా ముగించబడితే అది వేచి ఉండటానికి బదులుగా చెక్ దశకు తరలించబడుతుంది. అర్థం చేసుకోవడానికి క్రింది ఉదాహరణను పరిగణించండి:
// application.jsకన్సోల్. లాగ్ ( 'ప్రారంభం' ) ;
వెంటనే సెట్ ( ( ) => {
కన్సోల్. లాగ్ ( 'తక్షణ కాల్బ్యాక్' ) ;
} ) ;
కన్సోల్. లాగ్ ( 'ముగింపు' ) ;
ఈ కోడ్‌లో మూడు సందేశాలు టెర్మినల్‌కు లాగిన్ అయ్యాయి. setImmediate() ఫంక్షన్ చివరకు '' సందేశాన్ని లాగ్ చేయడానికి కాల్‌బ్యాక్‌ను పంపుతుంది. తక్షణ కాల్బ్యాక్ ” టెర్మినల్‌కి.
అవుట్‌పుట్
పై కోడ్ యొక్క అవుట్‌పుట్ క్రింది క్రమంలో చూపబడుతుంది:
Node.js కాల్‌బ్యాక్‌లను మూసివేయండి
ఈవెంట్‌లను మూసివేయడానికి మరియు ఈవెంట్ లూప్ పునరావృతాన్ని ముగించడానికి కాల్‌బ్యాక్‌లను అమలు చేయడానికి Node.js ఈ క్లోజ్ ఫేజ్‌ని ఉపయోగిస్తుంది. కనెక్షన్ మూసివేయబడిన తర్వాత, ఈవెంట్ లూప్ ఈ దశలో ముగింపు ఈవెంట్‌లను నిర్వహిస్తుంది. ఈవెంట్ లూప్ యొక్క ఈ దశలో, “nextTick()” మరియు మైక్రోటాస్క్‌లు ఇతర దశల మాదిరిగానే రూపొందించబడతాయి మరియు ప్రాసెస్ చేయబడతాయి.
ఈవెంట్ లూప్‌ను ఏ క్షణంలోనైనా ముగించడానికి process.exit ఫంక్షన్ ఉపయోగించబడుతుంది. ఈవెంట్ లూప్ ఏవైనా పెండింగ్‌లో ఉన్న అసమకాలిక కార్యకలాపాలను విస్మరిస్తుంది మరియు Node.js ప్రక్రియ ముగుస్తుంది.
పరిగణించవలసిన ఒక సాధారణ ఉదాహరణ:
// application.jsస్థిరంగా నికర = అవసరం ( 'నెట్' ) ;
స్థిరంగా సర్వర్ = నికర. సృష్టించు సర్వర్ ( ( సాకెట్ ) => {
సాకెట్. పై ( 'దగ్గరగా' , ( ) => {
కన్సోల్. లాగ్ ( 'సాకెట్ మూసివేయబడింది' ) ;
} ) ;
సాకెట్. పై ( 'సమాచారం' , ( సమాచారం ) => {
కన్సోల్. లాగ్ ( 'అందుకున్న డేటా:' , సమాచారం. స్ట్రింగ్ ( ) ) ;
} ) ;
} ) ;
సర్వర్. పై ( 'దగ్గరగా' , ( ) => {
కన్సోల్. లాగ్ ( 'సర్వర్ మూసివేయబడింది' ) ;
} ) ;
స్థిరంగా ఓడరేవు = 3000 ;
సర్వర్. వినండి ( ఓడరేవు, ( ) => {
కన్సోల్. లాగ్ ( `పోర్ట్ $లో సర్వర్ వినడం { ఓడరేవు } ` ) ;
} ) ;
సమయం ముగిసింది ( ( ) => {
కన్సోల్. లాగ్ ( '10 సెకన్ల తర్వాత సర్వర్ మూసివేయబడుతుంది' ) ;
సర్వర్. దగ్గరగా ( ) ;
ప్రక్రియ. బయటకి దారి ( ) ;
} , 10000 ) ;
ఈ కోడ్‌లో:
- ' స్థిర నికర = అవసరం (‘నెట్’) ” TCP సర్వర్‌ని నిర్వహించడానికి అవసరమైన నెట్ మాడ్యూల్‌ను దిగుమతి చేస్తుంది మరియు “ const server = net.createServer((సాకెట్) => { ” కొత్త TCP సర్వర్ ఉదాహరణను సృష్టిస్తుంది.
- ' socket.on(‘మూసివేయి’, () => {…} ”అన్ని సాకెట్లలోని “క్లోజ్” వింటుంది. సాకెట్ కనెక్షన్ మూసివేయబడినప్పుడు 'సాకెట్ మూసివేయబడింది' అనే సందేశం టెర్మినల్‌కు లాగ్ చేయబడింది.
- ' socket.on(‘డేటా’, (డేటా) => {} ”అన్ని వ్యక్తిగత సాకెట్ల నుండి ఇన్‌కమింగ్ డేటా కోసం తనిఖీ చేస్తుంది మరియు “.toString()” ఫంక్షన్‌ని ఉపయోగించి ప్రింట్ చేస్తుంది.
- ' server.on(‘మూసివేయి’, () => {…} ” సర్వర్‌లోనే “క్లోజ్” ఈవెంట్ కోసం తనిఖీ చేస్తుంది మరియు సర్వర్ కనెక్షన్ మూసివేయబడినప్పుడు అది టెర్మినల్‌కు “సర్వర్ మూసివేయబడింది” సందేశాన్ని లాగ్ చేస్తుంది.
- ' server.listen(పోర్ట్, () => {…} పోర్ట్‌లో ఇన్‌కమింగ్ కనెక్షన్‌లను వింటుంది.
- ' setTimeout(() => {…} ” సర్వర్‌ను మూసివేయడానికి 10 ms టైమర్‌ని సెట్ చేస్తుంది.
Node.jsలో ఈవెంట్ లూప్ యొక్క వివిధ దశలపై చర్చ ముగిసింది. ఒక ముగింపుకు వెళ్లే ముందు Node.jsలో ఈవెంట్ లూప్ నుండి ఎలా నిష్క్రమించాలనేది చివరిగా చర్చిద్దాం.
Node.jsలో ఈవెంట్ లూప్ నుండి నిష్క్రమిస్తోంది
ఈవెంట్ లూప్ దశల యొక్క అన్ని క్యూలలో కొన్ని టాస్క్‌లు ఉన్నంత వరకు ఈవెంట్ లూప్ అమలు దశలో ఉంటుంది. నిష్క్రమణ దశ ఉద్గారించిన తర్వాత ఈవెంట్ లూప్ ముగుస్తుంది మరియు మరిన్ని టాస్క్‌లు క్యూలలో లేకుంటే ఎగ్జిట్ లిజనర్ కాల్బ్యాక్ తిరిగి వస్తుంది.
ఈవెంట్ లూప్‌ను ముగించడానికి స్పష్టమైన మార్గం “.exit” పద్ధతిని ఉపయోగించడం. Process.exit ఫంక్షన్‌ని పిలిచిన వెంటనే Node.js యొక్క క్రియాశీల ప్రక్రియలు తక్షణమే ముగుస్తాయి. షెడ్యూల్ చేయబడిన మరియు పెండింగ్‌లో ఉన్న అన్ని ఈవెంట్‌లు తొలగించబడతాయి:
ప్రక్రియ. పై ( 'బయటకి దారి' , ( కోడ్ ) => {కన్సోల్. లాగ్ ( `నిష్క్రమణ కోడ్‌తో నిష్క్రమించడం : $ { కోడ్ } ` ) ;
} ) ;
ప్రక్రియ. బయటకి దారి ( 1 ) ;
వినియోగదారులు .exit ఫంక్షన్‌ను వినగలరు. ఈ ఈవెంట్‌ను విన్న వెంటనే Node.js ప్రోగ్రామ్ నిష్క్రమిస్తుంది కాబట్టి “.exit” ఫంక్షన్ తప్పనిసరిగా సమకాలీకరించబడుతుందని గమనించాలి.
ఇది ఈవెంట్ లూప్‌పై చర్చను ముగించింది. ఈవెంట్ లూప్‌కు సంబంధించిన అన్ని భావనలు, దశలు మరియు ఉదాహరణలను కవర్ చేసిన లోతైన కథనం.
ముగింపు
ఈవెంట్ లూప్‌ను అర్థం చేసుకునే ముందు, సింక్రోనస్ మరియు ఎసిన్క్రోనస్ కాన్సెప్ట్‌ల యొక్క అవలోకనం ఈవెంట్ లూప్‌లోని కోడ్ ఫ్లోను అర్థం చేసుకోవడానికి సహాయపడుతుంది. సింక్రోనస్ ఎగ్జిక్యూషన్ అంటే స్టెప్-బై-స్టెప్ ఎగ్జిక్యూషన్ అయితే ఎసిన్క్రోనస్ ఎగ్జిక్యూషన్ అంటే కొన్ని దశలు పూర్తయ్యే వరకు వేచి ఉండకుండా ఆపడం. ఈవెంట్ లూప్ యొక్క పని అన్ని దశలతో పాటు తగిన ఉదాహరణలతో పాటు వ్యాసంలో చర్చించబడింది.