नोड.जेएस में टाइमर आर्किटेक्चर

मैं टाइमर के रूप में नोड में इस तरह के एक अद्भुत और व्यापक रूप से उपयोग किए जाने वाले उपकरण के बारे में बात करना चाहता हूं, और सेटटाइम, सेट इन्टरवल फ़ंक्शन और नेट मॉड्यूल में उनके उपयोग के बारे में। नोड.जेएस में, टाइमर के लिए कर्नल मॉड्यूल जिम्मेदार है। इस मॉड्यूल से सेटटाइमआउट एक विश्व स्तर पर सुलभ फ़ंक्शन है।

स्रोत कोड में आप आसानी से एक टिप्पणी पा सकते हैं:

इस तथ्य के कारण कि कई सॉकेट में समान समय-सीमा होगी, हम उनमें से प्रत्येक के लिए अपने स्वयं के टाइमर का अर्थ नहीं करेंगे (जिसका अर्थ है लीब्यूव से निम्न-स्तरीय टाइमर )। यह बहुत अधिक उपरि देता है। इसके बजाय, हम समान टाइमआउट क्षणों के साथ सॉकेट के पैकेट के लिए एक ऐसे टाइमर का उपयोग करेंगे। हम दोगुनी कनेक्टेड सूचियों में सॉकेट्स को एकजुट करेंगे। यह तकनीक कामेच्छा प्रलेखन में वर्णित है: http://pod.tst.eu/http://cvs.schmorp.de/libev/ev.pod#Be_smart_about_timeouts

मैं ध्यान देता हूं कि इस प्रलेखन में ४ विभिन्न तकनीकों का वर्णन किया गया है। समस्या जो हल की गई थी: हर बार जब सॉकेट सक्रिय होता है, उदाहरण के लिए, जब नया डेटा आता है, तो आपको टाइमर को विस्तारित करने की आवश्यकता होती है।
तकनीक बढ़ती जटिलता और प्रभावशीलता में सूचीबद्ध हैं:
1. बंद करो, फिर से संगठित करना और गतिविधि द्वारा टाइमर शुरू करना। लगभग हमेशा खराब। कोई प्लस नहीं हैं।
2. ev_timer_again के साथ टाइमर बढ़ाएँ। एक बहुत ही सरल उपाय जो आमतौर पर ठीक काम करेगा।
3. जब यह मूल रूप से नियोजित किया गया था, तो टाइमर को काम करने दें, जिसके बाद यह जांचें कि क्या इसे दूसरे द्वारा और कितने द्वारा विस्तारित करना आवश्यक है। अधिक कठिन, लेकिन कुछ मामलों में यह अधिक कुशलता से काम करता है।
4. टाइमआउट के लिए दोगुनी लिंक की गई सूचियों का उपयोग करें। यदि आपको टाइमर को विस्तारित करने की आवश्यकता है, तो यह बस दोगुनी लिंक की गई सूची के अंत में स्थानांतरित हो जाता है। कठिन भी, लेकिन बेहद प्रभावी।
4th विकल्प नोड में लागू किया गया है ।js.

सेटटाइमआउट (कॉलबैक, मिसे, [arg], [...])

यदि आप निम्नलिखित कोड निष्पादित करते हैं तो क्या होता है?

var start = Date.now(); //    ,     . var Timeout100 = setTimeout(function() {}, 100); //     10 var Timeout110 = setTimeout(function() {}, 100); var Timeout210 = setTimeout(function() {}, 200); 

और निम्नलिखित होगा। टाइमर.जेएस मॉड्यूल में सूचियों नामक एक मॉड्यूल चर है, जो सभी सक्रिय टाइमर को संग्रहीत करने (लगभग) के लिए जिम्मेदार है।
संक्षेप में, सेटटाइमआउट के आंतरिक तर्क को निम्नानुसार दर्शाया जा सकता है:

 function setTimeout(callback, msecs) { var list = lists[msecs]; //      ,   ,     //     msecs. if (!list) { //    process.binding('timer_wrap').Timer ,  libuv' . list = lists[msecs] = new Timer(); //    ,   . list.ontimeout = ...; //  . list.start(msecs, 0); //  ,       . L.init(list); } //   ,       callback  msecs . var item = Timeout; item._idleStart = Date.now(); //    item._idleTimeout = msecs; //   item._onTimeout = callback; //    //      . // ,         //   item',  ..     ,    //      . L.append(list, item); return item; } 

इस प्रकार, टाइमर चर में 2 कुंजी शामिल होंगी:


शुरू के समय + 100ms libuv Timer100 पर दस्तक देगा, वे कहते हैं, अभिनय। इस पर प्रतिक्रिया उस हैंडलर का निष्पादन होगा, जिसे मैंने बाद में बात करने का वादा किया था।

यह हैंडलर क्या करेगा? इसका तर्क भी बहुत जटिल नहीं है:

 //      ,     ,    function callback(Timer list, msecs) { var now = Date.now(); var first; //       ,    ,    , //    ,   .   . while(first = L.peek()) { // ,     var wait = item._idleStart + item._idleTimeout - now; //     if (wait <= 0) { //     L.remove(first); //  callback first.onTimeout(); } else { //    wait  list.start(wait, 0); // , ..      -   //       return; } } //     , ,   . //  . list.stop(); //   delete lists[msecs]; } 

हमारे मामले में यह कॉलबैक 3 बार कहा जाएगा:

1. शुरू + 100 पल:
   
   1. टाइमआउट १ निष्पादित करें
   2. हम देखते हैं कि Timeout2 से पहले 10ms बचे हैं, इस समय के लिए टाइमर सेट करें
   3. बाहर आओ।
2. प्रारंभ + 110 पल:
   
   1. टाइमआउट 2 निष्पादित;
   2. हम देखते हैं कि शीट खाली है, टिमर 100 और प्रमुख सूचियों को हटाएं [100]।
   3. बाहर आओ।
3. प्रारंभ + 210 पल:
   
   1. टाइमआउट 3 चलाएं;
   2. हम देखते हैं कि शीट खाली है, टिमर 200 और प्रमुख सूचियों को हटा दें [200]।
   3. बाहर आओ।

क्लियर टाइमआउट (टाइमआउट)

अब देखते हैं कि क्लियरटाइम कैसे काम करता है। यह फ़ंक्शन टाइमआउट वर्ग के उसी ऑब्जेक्ट को तर्क के रूप में लेता है जिसे सेटटाइमआउट से लौटाया गया था।

 function clearTimeout(item) { //    . L.remove(item); var msecs = item._idleTimeout; //   var list = lists[msecs]; //   ,  if (list && L.isEmpty(list)) { list.close(); delete lists[msecs]; } } 

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

में

setInterval (कॉलबैक, msecs, [arg], [...]) और clearInterval (अंतराल)

setInterval और clearInterval, setTimeout के विपरीत, किसी भी चाल का उपयोग न करें। प्रत्येक अंतराल के लिए, एक नया libuv का टाइमर बनाया जाता है और इसे रिपीट मोड में प्रत्येक msecs मिलीसेकंड में चार्ज किया जाता है। स्पष्टता के साथ, यह बंद हो जाता है और हटा दिया जाता है। वह सब है।

सॉकेट्स (नेट मॉड्यूल)

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

प्रोटोटाइप में सॉकेट्स में पहले से ही _onTimeout पद्धति है, इसलिए उन्हें बंद करने की आवश्यकता नहीं है।
वे केवल गुण _idleStart, _idleTimeout (समय ट्रैकिंग के लिए गुण), _idleNext और _idlePrev (दोगुनी लिंक की गई सूची के लिए गुण) द्वारा विस्तारित हैं।
जब डेटा प्राप्त होता है और भेजा जाता है, तो सॉकेट को बस संबंधित दोगुनी लिंक की गई सूची से हटा दिया जाता है ...

... और तुरंत इसके अंत में जोड़ा गया:

इस लेख को लिखने के दुष्प्रभाव:

1. एक पुल अनुरोध नोड.जेएस को भेजा गया था , सेटटाइमआउट () को 5% तक, दुर्लभ मामलों में 50% तक।
2. नोड्स के लिए एक पुल अनुरोध भेजा है। टाइमर की झूठी शुरुआत को सही करते हुए।
3. मुझे पता चला कि उबंटू 12.04 (दूसरे - 11.04) पर चलने वाली मेरी मशीनों पर नोड बिट्स में 32 बिट + PAE Date.now () फ़ंक्शन होता है और ब्राउज़रों को 15 गुना धीमी गति से काम करना चाहिए। मुझे लगता है कि बिंदु gettimeofday (2) अंतर्निहित कॉल है। 64-बिट Ubuntu 12.10 पर अपग्रेड करना इस समस्या को हल करता है।

निष्कर्ष:

1. आपके द्वारा उपयोग किए जाने वाले टूल के स्रोत कोड पढ़ें - आप बहुत कुछ सीखेंगे।
2. Node.js डेवलपर्स, टाइमर के साथ काम करने के लिए सर्वोत्तम प्रथाओं का पालन करते हैं, हालांकि, कार्यान्वयन में कुछ चूक हैं।
3. टाइमआउट की कतार का रेकिंग एक चक्र में और समकालिक रूप से होता है।
4. आंतरिक टाइमर्स का उत्पादन न करने के लिए समान टाइमआउट मान का उपयोग करना उपयोगी है।