रिकर्सिव प्रक्रिया का उपयोग करता है .nexttick अन्य प्रक्रियाओं या धागे काम करते हैं?

Question

तकनीकी रूप से जब हम निम्नलिखित कोड (रिकर्सिव प्रक्रिया.नेक्स्टिक) निष्पादित करते हैं, तो CPU उपयोग 100% या निकट हो जाएगा। प्रश्न यह कल्पना कर रहा है कि मैं एक सीपीयू के साथ एक मशीन पर चल रहा हूं और नोड HTTP सर्वर की एक और प्रक्रिया काम कर रही है, यह इसे कैसे प्रभावित करती है?

क्या थ्रेड रिकर्सिव प्रक्रिया कर रहा है .nexttick HTTP सर्वर को बिल्कुल काम करने दें?

यदि हमारे पास रिकर्सिव प्रक्रिया के दो धागे हैं .nexttick, क्या उन्हें दोनों को 50% हिस्सा मिलता है?

चूंकि मुझे नहीं पता कि एक कोर के साथ कोई भी मशीन इसे आजमा नहीं सकती है। और चूंकि सीपीयू के बीच सीपीयू के समय साझा करने की मेरी समझ इस मामले में सीमित है, इसलिए मुझे उन मशीनों के साथ प्रयास करने की ज़रूरत नहीं है जिनमें 4 कोर CPU है।

function interval(){ 
    process.nextTick(function(){ 
    someSmallSyncCode(); 
    interval(); 
    }) 
} 

धन्यवाद

Answer 1

यह समझने के लिए कि यहां क्या हो रहा है, आपको नोड के ईवेंट लूप के साथ-साथ ओएस और सीपीयू के बारे में कुछ चीजें समझनी होंगी।

सबसे पहले, इस कोड को बेहतर समझने दें। आप इसे रिकर्सिव कहते हैं, लेकिन क्या यह है?

रिकर्सन में हम आम तौर पर नेस्टेड कॉल स्टैक के बारे में सोचते हैं और फिर जब गणना की जाती है (बेस केस तक पहुंच जाती है), तो स्टैक "रिक्त" होता है जहां हमारे रिकर्सिव फ़ंक्शन को बुलाया जाता है।

हालांकि यह एक तरीका है जो खुद को कॉल करता है (अप्रत्यक्ष रूप से कॉलबैक के माध्यम से), ईवेंट लूप स्कूज़ करता है कि वास्तव में क्या चल रहा है।

process.nextTick कॉलबैक के रूप में एक फ़ंक्शन लेता है और इसे ईवेंट लूप के अगले गो-ऑन पर किए जाने वाले सामानों की सूची में पहले रखता है। यह कॉलबैक तब निष्पादित किया जाता है और जब यह किया जाता है, तो आप एक बार फिर एक ही कॉलबैक पंजीकृत करते हैं। अनिवार्य रूप से, इस और सही पुनरावृत्ति के बीच महत्वपूर्ण अंतर यह है कि हमारे कॉल स्टैक को कभी भी एक से अधिक कॉल गहरे नहीं मिलते हैं। हम कभी भी ढेर "अनदेखा" नहीं करते हैं, हमारे पास उत्तराधिकार में बहुत कम छोटे ढेर हैं।

ठीक है, तो यह क्यों मायने रखता है?

जब हम ईवेंट लूप को बेहतर समझते हैं और वास्तव में क्या चल रहा है, तो हम बेहतर ढंग से समझ सकते हैं कि सिस्टम संसाधनों का उपयोग कैसे किया जाता है। Process.next का उपयोग करके इस फैशन में टिकटें, आप आश्वस्त कर रहे हैं कि इवेंट लूप पर हमेशा कुछ करना है, यही कारण है कि आपको उच्च सीपीयू उपयोग मिलता है (लेकिन आप पहले से ही जानते थे)। अब, मान लीजिए अगर हम थे अपने HTTP सर्वर स्क्रिप्ट के रूप में एक ही प्रक्रिया में चलाने के लिए थे, इस तरह के

function interval(){ 
    process.nextTick(doIntervalStuff) 
} 

function doIntervalStuff() { 
    someSmallSyncCode(); 
    interval(); 
} 

http.createServer(function (req, res) { 
doHTTPStuff() 
}).listen(1337, "127.0.0.1"); 

तो नीचे के रूप में कैसे करता है CPU उपयोग कार्यक्रम के दो विभिन्न भागों के बीच विभाजित हो कि? अच्छा कहना मुश्किल है, लेकिन अगर हम घटना लूप को समझते हैं, तो हम कम से कम अनुमान लगा सकते हैं।

चूंकि हम process.nextTick का उपयोग करते हैं, तो doIntervalStuff फ़ंक्शन इवेंट लूप की "प्रारंभ" पर हर बार चलाया जाएगा, हालांकि, यदि HTTP सर्वर (जैसे कनेक्शन को संभालना) के लिए कुछ किया जाना है तो हम पता है कि अगली बार इवेंट लूप शुरू होने से पहले किया जाएगा, और याद रखें, नोड की प्रकृति की प्रकृति के कारण, यह इवेंट लूप के एक पुनरावृत्ति पर किसी भी कनेक्शन को संभालने में सक्षम हो सकता है।इसका अर्थ यह है कि, कम से कम सिद्धांत में, प्रक्रिया में प्रत्येक कार्य को सीपीयू उपयोग तक "जरूरत" होती है, और फिर प्रक्रिया .nextTick फ़ंक्शंस बाकी का उपयोग करता है। हालांकि यह बिल्कुल सही नहीं है (उदाहरण के लिए, ब्लॉकिंग कोड का आपका बिट इसे गड़बड़ कर देगा), यह सोचने के लिए एक अच्छा पर्याप्त मॉडल है।

ठीक है (अंत में) आपके वास्तविक प्रश्न पर, अलग प्रक्रियाओं के बारे में क्या?

दिलचस्प बात यह है कि ओएस और सीपीयू अक्सर प्रकृति में "घटना" भी होते हैं। जब भी कोई प्रक्रिया कुछ करना चाहती है (जैसे नोड के मामले में, इवेंट लूप का पुनरावृत्ति शुरू करें), यह ओएस को संभालने का अनुरोध करता है, ओएस फिर इस नौकरी को एक तैयार कतार में दिखाता है (जिसे प्राथमिकता दी जाती है) और यह निष्पादित करता है जब CPU शेड्यूलर इसके आसपास घूमने का निर्णय लेता है। यह एक बार फिर एक oversimplified मॉडल है, लेकिन लेने के लिए मूल अवधारणा यह है कि नोड के घटना लूप की तरह, प्रत्येक प्रक्रिया को "जरूरत" हो जाता है और फिर आपके नोड ऐप की तरह एक प्रक्रिया जब भी संभव हो निष्पादित करने की कोशिश करता है अंतराल।

तो जब आपकी नोड प्रक्रियाएं कहती हैं कि यह 100% सीपीयू ले रही है, यह सटीक नहीं है, अन्यथा, कुछ भी नहीं किया जाएगा और सिस्टम क्रैश हो जाएगा। अनिवार्य रूप से, यह सभी सीपीयू को ले जा सकता है लेकिन ओएस अभी भी अन्य चीजों को फिसलने के लिए निर्धारित करता है।

यदि आप एक दूसरी प्रक्रिया नोड प्रक्रिया को जोड़ना चाहते थे जो एक ही प्रक्रिया करता था .nextTick, ओएस दोनों प्रक्रियाओं को समायोजित करने का प्रयास करेगा और, प्रत्येक नोड प्रक्रिया के ईवेंट लूप पर किए जाने वाले काम की मात्रा के आधार पर, ओएस तदनुसार काम को विभाजित करेगा (कम से कम सिद्धांत में, लेकिन वास्तविकता में शायद सब कुछ धीमा हो जाएगा और सिस्टम अस्थिरता)।

एक बार फिर, यह बहुत अधिक है, लेकिन उम्मीद है कि यह आपको क्या हो रहा है इसका एक विचार देता है। ऐसा कहा जा रहा है, मैं process.nextTick का उपयोग करने की अनुशंसा नहीं करता जबतक कि आपको पता न हो कि आपको इसकी आवश्यकता है, अगर प्रत्येक 5 एमएस कुछ कर रहा है, तो प्रक्रिया के बजाय सेटटाइमआउट का उपयोग करके स्वीकार्य है .nextTick cpu उपयोग पर oodles को सहेज लेगा।

आशा है कि आपके प्रश्न का उत्तर दें: डी

Answer 2

नहीं, आप की जरूरत नहीं है कृत्रिम रूप से, अपनी प्रक्रियाओं को रोकने के लिए दूसरों को उनके कार्य करते हैं करने के लिए अपने ऑपरेटिंग सिस्टम है कि के लिए तंत्र है। वास्तव में, इस तरह से process.nextTick का उपयोग करके आपके कंप्यूटर को धीमा कर दिया जाएगा क्योंकि इसमें बहुत अधिक ओवरहेड है।