अतुल्यकालिक प्रोग्रामिंग, कॉलबैक और प्रक्रिया का उपयोग कर ।nextTick ()

इस तथ्य के बावजूद कि Node.js का अध्ययन करने वाले अधिकांश लोग कुछ हद तक जावास्क्रिप्ट जानते हैं और ब्राउज़रों के संदर्भ में इसका उपयोग करने का अनुभव करते हैं, जबकि व्यावहारिक मुद्दों पर चर्चा करते हुए, मानक पुस्तकालय के संचालन को समझने में कई कठिनाइयों का सामना करना पड़ता है और कोड के अतुल्यकालिक निष्पादन सुनिश्चित करने के लिए कई नेस्टेड होते हैं। कॉलबैक। गलतफहमी भी अक्सर पैदा होती है। मैं Node.js में इवेंट लूप की प्रक्रिया का संक्षेप में वर्णन करने की कोशिश करूंगा और आपको बताऊंगा कि उच्च गुणवत्ता वाले अतुल्यकालिक कोड लिखते समय आपको किन बिंदुओं पर ध्यान देना चाहिए। मुझे लगता है कि यह लेख उन लोगों के लिए उपयोगी होगा जो ब्राउज़रों के लिए उत्पादक रूपरेखा लिखने में शामिल हैं।

गीतात्मक विषयांतर: Node.js अंतर्निहित घटनाओं का चक्र

जैसा कि कई बार लिखा गया है, Node.js एक घटना लूप पर आधारित है जो कि परिवाद पुस्तकालय द्वारा कार्यान्वित किया गया है। लूप के प्रत्येक मोड़ पर, निम्न होता है: सबसे पहले, लूप के पिछले लूप पर स्थापित फ़ंक्शन प्रक्रिया का उपयोग करके निष्पादित किए जाते हैं ।nextTick ()। इसके बाद विशेष रूप से टाइमर घटनाओं में लिबेव इवेंट्स का प्रसंस्करण आता है। पिछले नहीं बल्कि कम से कम, libeio को I / O को पूरा करने और उनके लिए निर्धारित कॉलबैक को पूरा करने के लिए चुना गया है। यदि लूप के पारित होने के दौरान यह पता चला कि कोई फ़ंक्शन प्रक्रिया का उपयोग करके स्थापित नहीं किया गया था ।nextTick (), वहाँ एक भी टाइमर नहीं है और libev और libeio में अनुरोध कतार खाली है, फिर नोड बाहर निकलता है। यदि आप इवेंट लूप के बारे में अधिक जानना चाहते हैं, तो प्रस्तुति www.slideshare.net/jacekbecela/introduction-to-nodejs पर जाएं ।



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

परीक्षण सर्वर का तुल्यकालिक संस्करण

// readFileSync.js var http = require('http'), fs = require('fs'); function func1(str) { var res = ''; for (var i = 0, l = str.length; i < l; i++) { res += str.charCodeAt(i); } return res; } function func2(str) { var res = 0; for (var i = 0, l = str.length; i < l; i++) { res += Math.sin(str.charCodeAt(i)); } return '' + res; } http.createServer(function (req, res) { // Very simple and dangerous check var filename = req.url.replace(/\?.*/, '').replace(/(\.\.|\/)/, ''); // Read file from disk try { var filecontent = fs.readFileSync(filename, 'utf8'); } catch (e) { res.writeHead(404, {'Content-Type': 'text/plain'}); res.end('File ' + filename + ' doesn\'t exist'); return; } // Calculate checksum var hash = func2(func1(filecontent)); // Write response res.writeHead(200, {'Content-Type': 'text/plain'}); res.end(hash); }).listen(8124, "127.0.0.1");
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

एक उदाहरण सर्वर में डिस्क से एक फ़ाइल का सिंक्रोनस रीडिंग होता है, जो रीडिंग पूरी होने तक निष्पादन को ब्लॉक करता है, और बाद में दो कार्यों के मूल्य की गणना जो एक बड़े फ़ाइल आकार के साथ लंबे समय तक निष्पादित की जा सकती है। इसके अलावा, यदि रीडिंग T _रीड सेकंड लेता है और T _calc सेकंड की राशि की गणना करता है, तो ऐसा अवरुद्ध सर्वर प्रति सेकंड 1 / (T _read + T _calc ) अनुरोधों से कम सेवा कर पाएगा। हम अधिक कनेक्शन को संभालने की अनुमति देकर अपने सर्वर को कैसे सुधार सकते हैं? सबसे पहले, नॉन-ब्लॉकिंग फाइल रीडिंग का उपयोग करें।

एसिंक्रोनस रूप से एक फ़ाइल को पढ़ना और कॉलबैक का उपयोग करने की कोशिश करना

  // readFile.js var http = require('http'), fs = require('fs'); function func1(str) { var res = ''; for (var i = 0, l = str.length; i < l; i++) { res += str.charCodeAt(i); } return res; } function func2(str) { var res = 0; for (var i = 0, l = str.length; i < l; i++) { res += Math.sin(str.charCodeAt(i)); } return '' + res; } http.createServer(function (req, res) { // Very simple and dangerous check var filename = req.url.replace(/\?.*/, '').replace(/(\.\.|\/)/, ''); // Read file from disk fs.readFile(filename, 'utf8', function (err, filecontent) { if (err) { res.writeHead(404, {'Content-Type': 'text/plain'}); res.end('File ' + filename + ' doesn\'t exist'); return; } // Calculate checksum var hash = func2(func1(filecontent)); // Write response res.writeHead(200, {'Content-Type': 'text/plain'}); res.end(hash); }); }).listen(8124, "127.0.0.1");
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

> अतुल्यकालिक पढ़ने के उपयोग के कारण, हम इस तथ्य के कारण प्रत्येक अनुरोध के प्रसंस्करण में तेजी ला सकते हैं कि पृष्ठभूमि में गणना के दौरान, फ़ाइल दूसरे अनुरोध के लिए पढ़ी जाएगी। <हड़ताल इस प्रकार, प्रसंस्करण समय न्यूनतम होगा (टी _रीड , टी _{कैल्क} ), और नहीं (टी _रीड + टी _{कैल्क} ), जैसा कि एक तुल्यकालिक सर्वर के मामले में। इस प्रकार, जब दो अनुरोध सिंक्रोनस केस में आते हैं, तो उनकी सेवा का समय T _read1 + T _calc1 + T _read2 + T _{calc2 होगा} , और जब एसिंक्रोनस रूप से पढ़ा जाएगा तो यह T _read1 + T _read2 + min (T _calc1 , T _calc2 ) तक पहुंच सकता है।



यह पहले से ही अच्छा है। लेकिन क्या होगा अगर फ़ाइल का प्रसंस्करण समय फ़ाइल के पढ़ने के समय से बहुत अधिक है और इसमें बहुत अधिक उतार-चढ़ाव होता है? इस मामले में, एक फ़ाइल के लिए राशि की गणना के दौरान, कई अन्य छोटी फ़ाइलों को समय पर पढ़ा जा सकता है, जिसे बाद में जल्दी से संसाधित किया जाएगा। इसके अलावा, उपरोक्त उदाहरण में, क्लाइंट को लगभग उसी क्रम में परिणाम प्राप्त होगा जिसमें सर्वर को अनुरोध भेजा गया था। हालांकि, उन ग्राहकों को पहले परिणाम वापस करना चाहते हैं जो छोटी फ़ाइलों या फ़ाइलों का अनुरोध करते हैं, जिन्हें कम प्रसंस्करण समय की आवश्यकता होती है। ऐसा करने के लिए, नेस्टेड प्रोसेसिंग फ़ंक्शन की लंबी श्रृंखला का उपयोग करते समय, किसी तरह से func1 () की गणना करने के बाद, आपको मुख्य धागे पर नियंत्रण वापस करने की आवश्यकता है, और चक्र के अगले मोड़ पर, func2 () की गणना करें और ग्राहक को परिणाम लौटाएं। इसके कारण, एक अनुरोध के लिए func1 () और func2 () की गणना के बीच के अंतराल में, एक नए कनेक्शन को स्वीकार किया जा सकता है और एक अन्य फ़ाइल को पढ़ने का कार्य बनाया जा सकता है, या पहले से पढ़ी गई एक छोटी फ़ाइल संसाधित हो जाएगी।



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

  // readFile-and-sync-chain.js var http = require('http'), fs = require('fs'); function func1(str) { var res = ''; for (var i = 0, l = str.length; i < l; i++) { res += str.charCodeAt(i); } return res; } function func2(str) { var res = 0; for (var i = 0, l = str.length; i < l; i++) { res += Math.sin(str.charCodeAt(i)); } return '' + res; } function func1_cb(str, cb) { var res = func1(str); cb(res); } function func2_cb(str, cb) { var res = func2(str); cb(res); } http.createServer(function (req, res) { // Very simple and dangerous check var filename = req.url.replace(/\?.*/, '').replace(/(\.\.|\/)/, ''); // Read file from disk fs.readFile(filename, 'utf8', function (err, filecontent) { if (err) { res.writeHead(404, {'Content-Type': 'text/plain'}); res.end('File ' + filename + ' doesn\'t exist'); return; } // Calculate checksum func1_cb(filecontent, function (str) { func2_cb(str, function (hash) { // Write response res.writeHead(200, {'Content-Type': 'text/plain'}); res.end(hash); }); }); }); }).listen(8124, "127.0.0.1");
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

वास्तव में क्या होगा? कोई जादू नहीं, बिल्कुल, नहीं। एकमात्र अंतर यह है कि हमने शुद्ध रूप से अनिवार्य राशि गणना कोड को दो नेस्टेड कॉलबैक फ़ंक्शन के साथ एक कोड के साथ बदल दिया है, जो एक-दूसरे को क्रमिक रूप से कॉल करेंगे और अनावश्यक फ़ंक्शन कॉल के कारण राशि गणना समय को थोड़ा बढ़ा देंगे, जो अंततः केवल हमारे सर्वर के प्रदर्शन को खराब करेगा। ।

अतुल्यकालिक फ़ाइल पढ़ने और उचित अतुल्यकालिक प्रसंस्करण

निष्पादन के मुख्य सूत्र पर नियंत्रण स्थानांतरित करने के लिए और साथ ही साथ func1 () की गणना के बाद राशि को संसाधित करने के भविष्य के कार्य पर डाल दिया गया है, आप जावास्क्रिप्ट में उपलब्ध पुराने सिद्ध उपकरण का उपयोग कर सकते हैं: setTimeout (fn, 0)। यदि हम ब्राउज़रों के लिए प्रोग्राम करते हैं तो इस फ़ंक्शन का उपयोग किया जाना चाहिए। लेकिन, जैसा कि मैंने ऊपर लिखा था, Node.js के पास एक फ़ंक्शन प्रक्रिया है ।nextTick (fn), जो अधिक कुशल है और इसके पास दिए गए फ़ंक्शन को टाइमर का उपयोग करके सेट किए गए फ़ंक्शन की तुलना में पहले निष्पादित किया जाएगा या जो सॉकेट या फ़ाइल सिस्टम पर इवेंट हैंडलर हैं। इस प्रकार, readFile-and-sync-chain.js सर्वर कोड निम्नानुसार फिर से लिखा जा सकता है:

  // readFile-and-nextTick.js var http = require('http'), fs = require('fs'); function func1(str) { var res = ''; for (var i = 0, l = str.length; i < l; i++) { res += str.charCodeAt(i); } return res; } function func2(str) { var res = 0; for (var i = 0, l = str.length; i < l; i++) { res += Math.sin(str.charCodeAt(i)); } return '' + res; } function func1_cb(str, cb) { var res = func1(str); process.nextTick(function () { cb(res); }); } function func2_cb(str, cb) { var res = func2(str); process.nextTick(function () { cb(res); }); } http.createServer(function (req, res) { // Very simple and dangerous check var filename = req.url.replace(/\?.*/, '').replace(/(\.\.|\/)/, ''); // Read file from disk fs.readFile(filename, 'utf8', function (err, filecontent) { if (err) { res.writeHead(404, {'Content-Type': 'text/plain'}); res.end('File ' + filename + ' doesn\'t exist'); return; } // Calculate checksum func1_cb(filecontent, function (str) { func2_cb(str, function (hash) { // Write response res.writeHead(200, {'Content-Type': 'text/plain'}); res.end(hash); }); }); }); }).listen(8124, "127.0.0.1");
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यह परिणाम सर्वर का अंतिम संस्करण है, जो सभी ऑपरेशनों को समान रूप से निष्पादित करता है और इसमें न्यूनतम संख्या कोड अनुभाग होते हैं जो घटनाओं के चक्र को अवरुद्ध करते हैं।

माना विकल्पों के प्रदर्शन की तुलना

उपरोक्त सभी, अधिकांश भाग के लिए, सही वास्तुकला के बारे में चर्चा करते हैं। वास्तव में, एक विशेष विकल्प का प्रदर्शन फ़ाइल फ़ाइल के किस आकार और उसके प्रसंस्करण समय पर निर्भर कर सकता है, फ़ाइल आकार पर प्रसंस्करण समय की गैर-रैखिक निर्भरता पर और कितने अलग-अलग सर्वर प्रक्रियाओं का अनुरोध करता है। फिर भी, परीक्षणों से पता चला कि किसी भी मामले में, समाधानों का उपयोग करना जो वास्तुकला के संदर्भ में अधिक उपयुक्त हैं, यहां तक ​​कि सबसे खराब स्थिति में भी, सर्वर को 10% से अधिक धीमा नहीं करता है।



तुलना के लिए, 128 बाइट्स से लेकर 1 एमबी आकार की फाइलें इस्तेमाल की गईं और अपाचे बेंच का उपयोग कर सर्वर को लोड किया गया:

 ab2 -n 1000 -c 100 http://127.0.0.1:8124/filename
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

परिणाम रेखांकन में दिखाए गए हैं:





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



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



PS ने इस मुद्दे को उठाने के लिए newcomers to forum.nodejs.ru को धन्यवाद दिया।