Node.js में सिंगल थ्रेडेड नॉन ब्लॉकिंग IO मॉडल कैसे काम करता है


325

मैं एक नोड प्रोग्रामर नहीं हूं, लेकिन मैं इस बात में दिलचस्पी रखता हूं कि सिंगल थ्रेडेड नॉन ब्लॉकिंग आईओ मॉडल कैसे काम करता है। जब मैंने लेख को समझने के लिए नोड-जेएस-ईवेंट-लूप पढ़ा , तो मैं वास्तव में इसके बारे में उलझन में हूं। इसने मॉडल के लिए एक उदाहरण दिया:

c.query(
   'SELECT SLEEP(20);',
   function (err, results, fields) {
     if (err) {
       throw err;
     }
     res.writeHead(200, {'Content-Type': 'text/html'});
     res.end('<html><head><title>Hello</title></head><body><h1>Return from async DB query</h1></body></html>');
     c.end();
    }
);

Que: जब दो अनुरोध ए (पहले आते हैं) और बी होते हैं क्योंकि केवल एक ही धागा होता है, तो सर्वर-साइड प्रोग्राम अनुरोध को संभाल लेगा। सबसे पहले: SQL क्वेरी करना सोते समय I / O प्रतीक्षा के लिए स्टेटमेंट है। और प्रोग्राम I/Oप्रतीक्षा में अटका हुआ है , और उस कोड को निष्पादित नहीं कर सकता है जो वेब पेज को पीछे छोड़ता है। क्या प्रतीक्षा के दौरान प्रोग्राम बी से अनुरोध करने के लिए स्विच करेगा? मेरी राय में, सिंगल थ्रेड मॉडल के कारण, एक अनुरोध को दूसरे से स्विच करने का कोई तरीका नहीं है। लेकिन उदाहरण कोड का शीर्षक कहता है कि आपके कोड को छोड़कर सब कुछ समानांतर में चलता है

(PS मुझे यकीन नहीं है कि मैं कोड को गलत समझ रहा हूं या नहीं, क्योंकि मैंने कभी नोड का उपयोग नहीं किया है।) प्रतीक्षा के दौरान नोड कैसे ए से बी पर स्विच करता है? और क्या आप सरल तरीके से नोड के एकल थ्रेडेड गैर अवरुद्ध IO मॉडल की व्याख्या कर सकते हैं ? अगर आप मेरी मदद कर सकते हैं तो मैं इसकी सराहना करूंगा। :)

जवाबों:


374

Node.js लिब्यू पर बनाया गया है , एक क्रॉस-प्लेटफ़ॉर्म लाइब्रेरी है जो समर्थित ओएस (यूनिक्स, ओएस एक्स और विंडोज कम से कम) द्वारा प्रदान किए गए एसिंक्रोनस (गैर-अवरोधक) इनपुट / आउटपुट के लिए एपिस / सिस्कल्स को सार करता है।

एसिंक्रोनस IO

इस प्रोग्रामिंग मॉडल में डिवाइस और संसाधनों (सॉकेट्स, फाइलसिस्टम, आदि) पर खुला / पढ़ा हुआ ऑपरेशन लिखना है। फाइल-सिस्टम द्वारा प्रबंधित कॉलिंग थ्रेड को ब्लॉक नहीं करता है (जैसा कि विशिष्ट सिंक्रोनस सी-जैसे मॉडल में) और बस चिह्नित करें। जब नया डेटा या ईवेंट उपलब्ध हों, तो प्रक्रिया (कर्नेल / OS स्तर डेटा संरचना में) अधिसूचित की जाए। वेब-सर्वर-जैसे ऐप के मामले में, प्रक्रिया तब यह पता लगाने के लिए ज़िम्मेदार होती है कि अधिसूचित घटना किस अनुरोध / संदर्भ से संबंधित है और वहाँ से अनुरोध को संसाधित करना है। ध्यान दें कि यह जरूरी होगा कि आप ओएस से एक अलग स्टैक फ्रेम पर होंगे, जो ओएस के अनुरोध को उत्पन्न करता है क्योंकि बाद में नई घटनाओं को संभालने के लिए एक थ्रेडेड प्रक्रिया के लिए एक प्रक्रिया 'डिस्पैचर के लिए उपज थी।

मेरे द्वारा बताए गए मॉडल के साथ समस्या यह है कि यह प्रोग्रामर के लिए कारण से परिचित और कठिन नहीं है क्योंकि यह प्रकृति में गैर-अनुक्रमिक है। "आपको फ़ंक्शन ए में अनुरोध करने और परिणाम को एक अलग फ़ंक्शन में संभालने की आवश्यकता है जहां ए से आपके स्थानीय लोग आमतौर पर उपलब्ध नहीं हैं।"

नोड का मॉडल (कंटीन्यूएशन पासिंग स्टाइल एंड इवेंट लूप)

नोड एक निश्चित प्रोग्रामिंग शैली को नियोजित करने के लिए प्रोग्रामर को प्रेरित करके इस मॉडल को थोड़ा और तुल्यकालिक-दिखने के लिए जावास्क्रिप्ट की भाषा सुविधाओं का लाभ उठाने की समस्या से निपटता है। प्रत्येक फ़ंक्शन जो IO का अनुरोध करता है, उसके पास एक हस्ताक्षर है function (... parameters ..., callback)और उसे कॉलबैक दिया जाना चाहिए जो अनुरोध किए गए ऑपरेशन पूरा होने पर आह्वान किया जाएगा (ध्यान रखें कि पूरा होने के लिए ओएस के इंतजार में ज्यादातर समय बिताया जाता है - जो समय हो सकता है अन्य काम करते हुए बिताया)। क्लोज़र के लिए जावास्क्रिप्ट का समर्थन आपको कॉलबैक के शरीर के अंदर बाहरी (कॉलिंग) फ़ंक्शन में परिभाषित चर का उपयोग करने की अनुमति देता है - यह अलग-अलग कार्यों के बीच राज्य को रखने की अनुमति देता है जो नोड रनटाइम द्वारा स्वतंत्र रूप से लागू किया जाएगा। कंटिन्यू पासिंग स्टाइल भी देखें ।

इसके अलावा, एक IO ऑपरेशन स्पॉनिंग फ़ंक्शन के आह्वान के बाद कॉलिंग फ़ंक्शन आमतौर returnपर नोड के इवेंट लूप को नियंत्रित करेगा । यह लूप अगले कॉलबैक या फ़ंक्शन को लागू करेगा जो निष्पादन के लिए निर्धारित किया गया था (सबसे अधिक संभावना है क्योंकि इसी घटना को ओएस द्वारा अधिसूचित किया गया था) - यह कई अनुरोधों के समवर्ती प्रसंस्करण की अनुमति देता है।

आप नोड के इवेंट लूप को कर्नेल के डिस्पैचर के समान समझ सकते हैं : कर्नेल एक ब्लॉक किए गए धागे को निष्पादित करने के लिए शेड्यूल करेगा, जब उसका लंबित आईओ पूरा हो जाता है, जबकि नोड तब कॉलबैक शेड्यूल करेगा जब संबंधित घटना घट गई हो।

अत्यधिक समवर्ती, कोई समानता नहीं

एक अंतिम टिप्पणी के रूप में, वाक्यांश "अपने कोड को छोड़कर समानांतर में सब कुछ रन" उस नोड से संभाल अनुरोध करने के लिए अपने कोड की अनुमति देता है बिंदु पर कब्जा करने के एक सभ्य काम करता है किसी एकल थ्रेड के साथ हजारों खुला सॉकेट के सैकड़ों समवर्ती बहुसंकेतन और अपने सभी js उन्हें क्रमबद्ध द्वारा निष्पादन की एक ही धारा में तर्क (भले ही "समानांतर में सब कुछ चलता है" कह रहा है, शायद यहाँ सही नहीं है - देखें समरकता बनाम समानतावाद - अंतर क्या है? )। यह वेबप सर्वरों के लिए बहुत अच्छा काम करता है क्योंकि ज्यादातर समय वास्तव में नेटवर्क या डिस्क (डेटाबेस / सॉकेट्स) के इंतजार में बीतता है और तर्क वास्तव में सीपीयू गहन नहीं है - यह कहना है: यह आईओ-बाउंड वर्कलोड के लिए अच्छी तरह से काम करता है


45
अनुवर्ती प्रश्न: I / O वास्तव में तब कैसे होता है? नोड प्रणाली के लिए एक अनुरोध कर रहा है और इसे समाप्त होने पर अधिसूचित करने के लिए कह रहा है। तो क्या सिस्टम एक थ्रेड चला रहा है जो I / O कर रहा है, या सिस्टम I / O को असिंक्रोनस रूप से हार्डवेयर लेवल पर इंटरप्ट का उपयोग कर रहा है? कहीं न कहीं I / O के खत्म होने का इंतजार करना पड़ता है, और जब तक यह पूरा नहीं हो जाता है, तब तक ब्लॉक करना होगा और कुछ संसाधनों का उपभोग करना होगा।
फिलिप

6
बस ध्यान दिया कि इस फॉलोअप टिप्पणी का जवाब @ user568109 द्वारा दिया गया है, काश इन दो उत्तरों को मर्ज करने का एक तरीका होता।
लेफ्लिन

4
मेरी इच्छा है कि आप एक प्रतिक्रिया दो बार लंबे समय तक लिख सकते हैं, इसलिए मैं दो बार बेहतर समझूंगा।
राफेल Eyng

रिकॉर्ड के लिए, नोड को बहुत सी जगहों पर समर्थित किया गया है। जब मैं MIPS32 राउटर के लिए फर्मवेयर डिजाइन कर रहा था, तो Node.JS उन पर OpenWRT के माध्यम से चलाया जा सकता था।
Qix - मोनासा

यह अपाचे पर कैसे स्कोर करता है? अपाचे एक अलग धागे के साथ समवर्ती कनेक्शन को संभालने में भी सक्षम है।
सुहैल गुप्ता

210

खैर, कुछ परिप्रेक्ष्य देने के लिए, मैं अपाचे के साथ नोड.जेएस की तुलना करता हूं।

Apache एक बहु-थ्रेडेड HTTP सर्वर है, जो सर्वर को प्राप्त होने वाले प्रत्येक अनुरोध के लिए एक अलग थ्रेड बनाता है जो उस अनुरोध को संभालता है।

दूसरी ओर Node.js ईवेंट संचालित है, सिंगल थ्रेड से एसिंक्रोनस रूप से सभी अनुरोधों को संभालना।

जब ए और बी एपाचे पर प्राप्त होते हैं, तो दो धागे बनाए जाते हैं जो अनुरोधों को संभालते हैं। प्रत्येक क्वेरी को अलग से हैंडल कर रहा है, प्रत्येक पृष्ठ की सेवा करने से पहले क्वेरी परिणाम की प्रतीक्षा कर रहा है। पृष्ठ केवल तब तक परोसा जाता है जब तक कि क्वेरी समाप्त न हो जाए। क्‍वेरी लाने पर रोक लग रही है, क्‍योंकि सर्वर परिणाम आने तक शेष थ्रेड को निष्पादित नहीं कर सकता है।

नोड में, c.query को असिंक्रोनस रूप से संभाला जाता है, जिसका अर्थ है कि c.query ए के लिए परिणाम प्राप्त करता है, यह B के लिए c.query को संभालने के लिए कूदता है, और जब परिणाम A के लिए आता है, तो यह कॉल करने के लिए परिणाम वापस भेजता है जो कॉल भेजता है प्रतिक्रिया। Node.js को कॉल फिनिश के बारे में तब पता चलता है जब भ्रूण खत्म हो जाता है।

मेरी राय में, क्योंकि यह एक एकल धागा मॉडल है, एक अनुरोध से दूसरे में स्विच करने का कोई तरीका नहीं है।

वास्तव में नोड सर्वर बिल्कुल आपके लिए करता है। स्विच करने के लिए, (अतुल्यकालिक व्यवहार) आपके द्वारा उपयोग किए जाने वाले अधिकांश फ़ंक्शन कॉलबैक होंगे।

संपादित करें

SQL क्वेरी mysql लाइब्रेरी से ली गई है । यह कॉलबैक शैली को लागू करता है और साथ ही SQL अनुरोधों को कतार में लाने के लिए घटना उत्सर्जक है। यह उन्हें अतुल्यकालिक रूप से निष्पादित नहीं करता है, जो कि आंतरिक लिबाव थ्रेड्स द्वारा किया जाता है जो गैर-अवरुद्ध I / O के अमूर्तता प्रदान करते हैं। क्वेरी बनाने के लिए निम्न चरण होते हैं:

  1. Db का कनेक्शन खोलें, कनेक्शन को एसिंक्रोनस रूप से बनाया जा सकता है।
  2. Db कनेक्ट होने के बाद, क्वेरी सर्वर पर दी जाती है। क्वेरीज़ को पंक्तिबद्ध किया जा सकता है।
  3. मुख्य ईवेंट लूप को कॉलबैक या ईवेंट के साथ पूरा होने की सूचना मिलती है।
  4. मुख्य लूप आपके कॉलबैक / इवेंटहैंडलर को निष्पादित करता है।

Http सर्वर के आने वाले अनुरोधों को इसी तरह से नियंत्रित किया जाता है। आंतरिक धागा वास्तुकला कुछ इस तरह है:

नोड .js इवेंट लूप

C ++ थ्रेड्स लिबव्यू हैं जो एसिंक्रोनस I / O (डिस्क या नेटवर्क) करते हैं। थ्रेड पूल के लिए अनुरोध भेजने के बाद मुख्य ईवेंट लूप निष्पादित करना जारी रखता है। यह अधिक अनुरोधों को स्वीकार कर सकता है क्योंकि यह प्रतीक्षा या नींद नहीं करता है। SQL क्वेरी / HTTP अनुरोध / फ़ाइल सिस्टम सभी इस तरह से पढ़ते हैं।


16
आरेख बहुत उपयोगी है।
अनमोल सराफ

14
रुको, तो अपने आरेख में आपके पास "आंतरिक सी ++ थ्रेडपूल" है, जिसका अर्थ है कि सभी आईओ अवरुद्ध संचालन एक धागा स्पॉन करेंगे, है ना? इसलिए यदि मेरा नोड ऐप प्रत्येक अनुरोध के लिए कुछ आईओ काम करता है , तो क्या वास्तव में नोड मॉडल और अपाचे मॉडल के बीच कोई अंतर नहीं है? मुझे यह हिस्सा माफ नहीं हो रहा है।
gav.newalkar

21
@ gav.newalkar वे एक धागा नहीं रखते, अनुरोध पंक्तिबद्ध हैं। थ्रेडपूल में धागे उन्हें संसाधित करते हैं। थ्रेड्स अपाचे की तरह गतिशील और प्रति अनुरोध नहीं हैं। वे आमतौर पर तय होते हैं और सिस्टम से सिस्टम में भिन्न होते हैं।
user568109 6

10
@ user568109 लेकिन अपाचे एक थ्रेडपूल ( httpd.apache.org/docs/2.4/mod/worker.html ) का भी उपयोग कर रहा है । तो अंत में नोड के साथ एक सेटअप के बीच का अंतर। जो अपाचे के सामने एक से अलग होता है केवल थ्रेडपूल स्थित है, है ना?
क्रिश

13
वह आरेख आधिकारिक डॉक्स के पहले पृष्ठ पर होना चाहिए।
गुलविर

52

Node.js पर्दे के पीछे कामेच्छा का उपयोग करता है । libuv में एक थ्रेड पूल है (आकार 4 डिफ़ॉल्ट रूप से)। इसलिए Node.js समरूपता प्राप्त करने के लिए थ्रेड्स का उपयोग करता है।

हालाँकि , आपका कोड एक ही धागे पर चलता है (यानी, Node.js फ़ंक्शन के सभी कॉलबैक उसी धागे, तथाकथित लूप-थ्रेड या ईवेंट-लूप) पर कॉल किए जाएंगे। जब लोग कहते हैं "Node.js एक ही धागे पर चलता है" तो वे वास्तव में कह रहे हैं "Node.js के कॉलबैक एक ही धागे पर चलते हैं"।


1
लघु लेकिन स्पष्ट उत्तर (y)
सुधांशु गौर

1
अच्छा जवाब मैं यह जोड़ूंगा कि I / O इस मुख्य घटना-पाश, लूप-थ्रेड, अनुरोध-सूत्र के बाहर होता है
Ionut Popa

इसका जवाब है कि मैं 2 घंटे से क्या खोज रहा था, कैसे एक एकल आवेदन में संगामिति का प्रबंधन किया गया
मुहम्मद रमजान

हाँ, 'अगले स्तर' उत्तर पाने के लिए मुश्किल है। यह बताता है कि आईओ वास्तव में कहां होता है (थ्रेड पूल में कहीं और)
ओलिवर शॉ

9

Node.js ईवेंट लूप प्रोग्रामिंग मॉडल पर आधारित है। ईवेंट लूप एकल थ्रेड में चलता है और बार-बार ईवेंट की प्रतीक्षा करता है और फिर उन ईवेंट के लिए किसी भी ईवेंट हैंडलर को सब्सक्राइब करता है। उदाहरण के लिए घटनाएँ हो सकती हैं

  • टाइमर इंतजार पूरा हो गया है
  • डेटा का अगला हिस्सा इस फ़ाइल में लिखे जाने के लिए तैयार है
  • एक नया नया HTTP अनुरोध हमारे रास्ते में आ रहा है

यह सभी एकल थ्रेड में चलता है और कोई भी जावास्क्रिप्ट कोड कभी भी समानांतर में निष्पादित नहीं होता है। जब तक ये ईवेंट हैंडलर छोटे होते हैं और अभी तक अधिक ईवेंट की प्रतीक्षा करते हैं, तब तक सब कुछ अच्छी तरह से काम करता है। यह कई अनुरोधों को एकल Node.js प्रक्रिया द्वारा समवर्ती रूप से नियंत्रित करने की अनुमति देता है।

(हुड के नीचे एक छोटा सा जादू है जहां घटनाओं की उत्पत्ति होती है। इसमें से कुछ में निम्न स्तर के कार्यकर्ता धागे शामिल हैं जो समानांतर में चल रहे हैं।)

इस SQL ​​मामले में, डेटाबेस क्वेरी बनाने और कॉलबैक में इसके परिणाम प्राप्त करने के बीच बहुत सी चीजें (घटनाएं) हो रही हैं । उस समय के दौरान ईवेंट लूप अनुप्रयोग में जीवन को बनाए रखता है और अन्य अनुरोधों को एक समय में एक छोटी सी घटना को आगे बढ़ाता है। इसलिए कई अनुरोधों को समवर्ती रूप से परोसा जा रहा है।

इवेंट लूप उच्च स्तरीय दृश्य

के अनुसार: "10,000ft से इवेंट लूप - Node.js के पीछे कोर अवधारणा"


5

फ़ंक्शन c.query () में दो तर्क हैं

c.query("Fetch Data", "Post-Processing of Data")

इस मामले में ऑपरेशन "लिंच डेटा" एक DB-Query है, अब इसे Node.js द्वारा एक श्रमिक थ्रेड को बंद करके और DB-Query के प्रदर्शन का यह कार्य देकर इसे संभाला जा सकता है। (याद रखें Node.js आंतरिक रूप से थ्रेड बना सकते हैं)। यह फ़ंक्शन को बिना किसी देरी के तुरंत लौटने में सक्षम बनाता है

दूसरा तर्क "पोस्ट-प्रोसेसिंग ऑफ़ डेटा" एक कॉलबैक फ़ंक्शन है, नोड फ्रेमवर्क इस कॉलबैक को पंजीकृत करता है और इसे इवेंट लूप द्वारा बुलाया जाता है।

इस प्रकार यह कथन c.query (paramenter1, parameter2)तुरंत वापस आएगा, नोड को किसी अन्य अनुरोध को पूरा करने के लिए सक्षम करेगा।

पुनश्च: मैं अभी नोड को समझना शुरू कर चुका हूं, वास्तव में मैं इसे @Philip पर टिप्पणी के रूप में लिखना चाहता था, लेकिन चूंकि इसमें पर्याप्त प्रतिष्ठा अंक नहीं थे, इसलिए इसे उत्तर के रूप में लिखा।


3

यदि आप थोड़ा आगे पढ़ते हैं - "बेशक, बैकएंड पर डीबी पहुंच और प्रक्रिया निष्पादन के लिए थ्रेड और प्रक्रियाएं हैं। हालांकि, ये स्पष्ट रूप से आपके कोड के संपर्क में नहीं हैं, इसलिए आप जानकर इनके अलावा अन्य के बारे में चिंता नहीं कर सकते। डेटाबेस के साथ या अन्य प्रक्रियाओं के साथ I / O अंतःक्रियाएं प्रत्येक अनुरोध के परिप्रेक्ष्य से अतुल्यकालिक होंगी क्योंकि उन थ्रेड्स से परिणाम आपके कोड में इवेंट लूप के माध्यम से वापस आ जाते हैं। "

के बारे में - "आपके कोड को छोड़कर सब कुछ समानांतर चलता है" - आपके कोड को सिंक्रोनाइज़ किया जाता है, जब भी आप एक अतुल्यकालिक ऑपरेशन जैसे कि IO का इंतजार करते हैं, तो ईवेंट लूप सब कुछ संभाल लेता है और कॉलबैक को इनवॉइस करता है। यह कुछ ऐसा नहीं है जिसके बारे में आपको सोचना है।

आपके उदाहरण में: दो अनुरोध ए हैं (पहला आता है) और बी। आप अनुरोध ए को निष्पादित करते हैं, आपका कोड सिंक्रोनाइज़ रन करना जारी रखता है और अनुरोध बी निष्पादित करता है। ईवेंट लूप अनुरोध ए को संभालता है, जब यह समाप्त होता है तो यह अनुरोध ए के कॉलबैक को आमंत्रित करता है। परिणाम, वही बी अनुरोध करने के लिए जाता है।


3
"बेशक, बैकएंड पर, डीबी पहुंच और प्रक्रिया निष्पादन के लिए थ्रेड्स और प्रक्रियाएं हैं। हालांकि, ये आपके कोड से स्पष्ट रूप से उजागर नहीं होते हैं" - अगर मैं इस वाक्यांश से लेता हूं, तो मुझे नोड के बीच कोई अंतर नहीं दिखता है। do या किसी भी बहुस्तरीय ढांचे - मान लें कि जावा का स्प्रिंग फ्रेमवर्क है - करता है। धागे हैं, लेकिन आप उनके निर्माण को नियंत्रित नहीं करते हैं।
राफेल Eyng

@ RafaelEyng मुझे लगता है कि कई अनुरोधों की श्रृंखला को संभालने के लिए, नोड के लिए हमेशा एक ही धागा होगा। मुझे यकीन नहीं है कि अगर प्रत्येक कॉलबैक को db एक्सेस जैसी अन्य प्रक्रियाओं से अलग थ्रेड्स के नए उदाहरण पर डाल दिया जाता है, लेकिन कम से कम हम निश्चित रूप से जानते हैं कि नोड हर बार थ्रेड को त्वरित नहीं करता है, यह एक अनुरोध प्राप्त करता है जिसे प्रसंस्करण से पहले इंतजार करना होगा (निष्पादन से पहले) कॉलबैक)।
कोल्ड सेर्बस

1

ठीक है, अब तक अधिकांश चीजें स्पष्ट होनी चाहिए ... मुश्किल हिस्सा एसक्यूएल है : यदि यह वास्तविकता में नहीं है तो किसी अन्य थ्रेड में चल रहा है या यह पूरी तरह से प्रक्रिया में है, एसक्यूएल-निष्पादन को अलग-अलग चरणों में टूटना होगा (एक द्वारा एसिंक्रोनस निष्पादन के लिए बनाया गया एसक्यूएल प्रोसेसर!), जहां गैर-अवरुद्ध वाले को निष्पादित किया जाता है, और अवरुद्ध वाले (जैसे नींद) वास्तव में कर्नेल को स्थानांतरित किया जा सकता है (एक अलार्म बाधा / घटना के रूप में) और घटना की सूची के लिए घटना सूची में डाल दिया। मुख्य घेरा।

इसका अर्थ है, जैसे कि एसक्यूएल की व्याख्या, आदि तुरंत किया जाता है, लेकिन प्रतीक्षा के दौरान (भविष्य में आने वाली घटना के रूप में कुछ केक्यू, एपोल, ... संरचना में कर्नेल द्वारा संग्रहीत किया जाता है; साथ में अन्य IO संचालन; ) मुख्य लूप अन्य चीजें कर सकता है और अंततः जांच कर सकता है कि क्या कुछ उन IOs और प्रतीक्षा के दौरान हुआ था।

इसलिए, इसे फिर से लागू करने के लिए: कार्यक्रम को कभी भी (प्राप्त करने की अनुमति नहीं) अटक गया है, नींद की कॉल को कभी भी निष्पादित नहीं किया जाता है। उनका कर्तव्य कर्नेल द्वारा किया जाता है (कुछ लिखें, नेटवर्क पर आने के लिए कुछ इंतजार करें, समय बीतने का इंतजार करें) या किसी अन्य थ्रेड या प्रक्रिया। - नोड प्रक्रिया यह जांचती है कि क्या प्रत्येक ईवेंट-लूप-साइकल में एक बार ओएस को केवल ब्लॉकिंग कॉल में कर्नेल द्वारा कम से कम एक कर्तव्य समाप्त हो गया है। वह बिंदु तक पहुंच जाता है, जब सब कुछ गैर-अवरुद्ध हो जाता है।

स्पष्ट? :-)

मुझे नहीं पता। लेकिन c.query कहाँ से आता है?


kqueue epoll linux kernel में स्केलेबल एसिंक्रोनस I / O नोटिफिकेशन के लिए है। नोड के पास इसके लिए libuv है। नोड पूरी तरह से यूजरलैंड पर है। यह निर्भर नहीं करता है कि कर्नेल क्या लागू करता है।
user568109

1
@ user568109, कामदेव नोड के मध्य पुरुष हैं। कोई भी एसिंक्रोनस फ्रेमवर्क कर्नेल में कुछ एसिंक्रोनस I / O समर्थन पर (सीधे या नहीं) निर्भर करता है। इसलिए?
रॉबर्ट सीमर

गलतफहमी के लिए खेद है। सॉकेट संचालन को कर्नेल से गैर-अवरोधक I / O की आवश्यकता होती है। यह अतुल्यकालिक हैंडलिंग का ख्याल रखता है। लेकिन एसिंक्रोनस फ़ाइल I / O को libuv द्वारा ही नियंत्रित किया जाता है। आपका उत्तर यह नहीं बताता है। यह दोनों को समान मानता है, जो कर्नेल द्वारा नियंत्रित किया जाता है।
user568109
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.