Node.js में थ्रेडिंग: मॉड्यूल कार्यकर्ता_थ्रेड्स

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

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

एकल-सूत्र में बँधी दुनिया

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

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

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

क्या Node.js प्लेटफ़ॉर्म सिंगल-थ्रेडेड है?

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

दूसरे शब्दों में, हमारे जेएस कोड को छोड़कर सब कुछ समानांतर में काम करता है। जावास्क्रिप्ट कोड के तुल्यकालिक ब्लॉक में, कमांड को हमेशा एक समय में निष्पादित किया जाता है, जिस क्रम में उन्हें स्रोत कोड में प्रस्तुत किया जाता है:

let flag = false function doSomething() {  flag = true  //    -  (     flag)...  //      ,     flag   true.  // -       ,  //      . } 

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

 db.findOne('SELECT ... LIMIT 1', function(err, result) { if (err) return console.error(err) console.log(result) }) console.log('Running query') setTimeout(function() { console.log('Hey there') }, 1000) 

यह संभव है कि यहां दिखाए गए डेटाबेस को क्वेरी लगभग एक मिनट लेगी, लेकिन इस क्वेरी के आरंभ होने के तुरंत बाद Running query संदेश कंसोल को भेजा जाएगा। इस मामले में, अनुरोध के निष्पादित होने के एक दिन बाद, Hey there संदेश प्रदर्शित होगा, भले ही इसका निष्पादन पूरा हो गया हो या नहीं। हमारा Node.js एप्लिकेशन केवल उस फ़ंक्शन को कॉल करता है जो अनुरोध शुरू करता है, जबकि इसके अन्य कोड का निष्पादन अवरुद्ध नहीं है। अनुरोध पूरा होने के बाद, एप्लिकेशन को कॉलबैक फ़ंक्शन का उपयोग करके इस बारे में सूचित किया जाएगा, और फिर उसे इस अनुरोध का जवाब मिलेगा।

सीपीयू गहन कार्य

यदि हम जावास्क्रिप्ट के माध्यम से, भारी कंप्यूटिंग करने की आवश्यकता है तो क्या होगा? उदाहरण के लिए - स्मृति में संग्रहीत डेटा के एक बड़े सेट को संसाधित करने के लिए? यह इस तथ्य को जन्म दे सकता है कि कार्यक्रम में समकालिक कोड का एक टुकड़ा होगा, जिसके निष्पादन में बहुत समय लगता है और अन्य कोड के निष्पादन को अवरुद्ध करता है। कल्पना कीजिए कि इन गणनाओं में 10 सेकंड लगते हैं। यदि हम एक ऐसे वेब सर्वर के बारे में बात कर रहे हैं जो एक निश्चित अनुरोध को संसाधित करता है, तो इसका मतलब यह होगा कि यह कम से कम 10 सेकंड के लिए अन्य अनुरोधों को संसाधित करने में सक्षम नहीं होगा। यह एक बड़ी समस्या है। वास्तव में, 100 मिलीसेकंड से अधिक की गणना पहले से ही इस समस्या का कारण बन सकती है।

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

आइए हम अपने पिछले उदाहरण पर लौटते हैं। कल्पना कीजिए कि डेटाबेस के लिए एक प्रश्न के जवाब में, कई हजार एन्क्रिप्टेड रिकॉर्ड आए, जो तुल्यकालिक जेएस कोड में स्थानांतरित किए जाने चाहिए:

 db.findAll('SELECT ...', function(err, results) { if (err) return console.error(err) //      ,    . for (const encrypted of results) {   const plainText = decrypt(encrypted)   console.log(plainText) } }) 

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

जावास्क्रिप्ट में कभी थ्रेड्स क्यों नहीं होंगे?

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

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

समस्या का आदिम समाधान: इवेंट लूप का पुनरावृत्ति

पिछले ब्लॉक के पूरा होने तक Node.js इवेंट कतार में कोड के अगले ब्लॉक को निष्पादित नहीं करेगा। इसका मतलब है कि हमारी समस्या को हल करने के लिए, हम इसे समकालिक कोड अंशों द्वारा दर्शाए गए भागों में तोड़ सकते हैं, और फिर इन अंशों के निष्पादन की योजना बनाने के लिए फॉर्म setImmediate(callback) निर्माण का उपयोग कर सकते हैं। इस निर्माण में callback फ़ंक्शन द्वारा निर्दिष्ट कोड को इवेंट लूप के वर्तमान पुनरावृत्ति (टिक) के कार्यों के पूरा होने के बाद निष्पादित किया जाएगा। उसके बाद, गणना के अगले बैच को पंक्तिबद्ध करने के लिए उसी डिज़ाइन का उपयोग किया जाता है। यह घटनाओं के चक्र को अवरुद्ध नहीं करने देता है और, एक ही समय में, वॉल्यूमेट्रिक समस्याओं को हल करता है।

कल्पना करें कि हमारे पास एक बड़ा सरणी है जिसे संसाधित करने की आवश्यकता है, जबकि ऐसे सरणी के प्रत्येक तत्व को संसाधित करने के लिए जटिल गणना की आवश्यकता होती है:

 const arr = [/*large array*/] for (const item of arr) { //         } // ,   ,      . 

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

 const crypto = require('crypto') const arr = new Array(200).fill('something') function processChunk() { if (arr.length === 0) {   // ,      } else {   console.log('processing chunk');   //  10         const subarr = arr.splice(0, 10)   for (const item of subarr) {     //           doHeavyStuff(item)   }   //       setImmediate(processChunk) } } processChunk() function doHeavyStuff(item) { crypto.createHmac('sha256', 'secret').update(new Array(10000).fill(item).join('.')).digest('hex') } //       , ,   , //       . let interval = setInterval(() => { console.log('tick!') if (arr.length === 0) clearInterval(interval) }, 0) 

अब, एक बार में, हम सरणी के दस तत्वों को संसाधित करते हैं, उसके बाद, setImmediate() का उपयोग करके, हम गणना के अगले बैच की योजना बनाते हैं। और इसका मतलब यह है कि यदि आपको प्रोग्राम में कुछ और कोड निष्पादित करने की आवश्यकता है, तो इसे सरणी के प्रसंस्करण टुकड़ों पर संचालन के बीच निष्पादित किया जा सकता है। इसके लिए, यहाँ, उदाहरण के अंत में, वहाँ कोड है जो setInterval() का उपयोग करता है।

जैसा कि आप देख सकते हैं, ऐसा कोड अपने मूल संस्करण की तुलना में बहुत अधिक जटिल दिखता है। और अक्सर एल्गोरिथ्म हमारे मुकाबले बहुत अधिक जटिल हो सकता है, जिसका अर्थ है कि, जब कार्यान्वित किया जाता है, तो गणनाओं को टुकड़ों में तोड़ना आसान नहीं होगा और यह समझना होगा कि, सही संतुलन प्राप्त करने के लिए, आपको setImmediate() सेट setImmediate() , गणना के अगले टुकड़े की योजना बनाना। इसके अलावा, अब कोड अतुल्यकालिक हो गया है, और यदि हमारी परियोजना तीसरे पक्ष के पुस्तकालयों पर निर्भर करती है, तो हम भागों में एक कठिन कार्य को हल करने की प्रक्रिया को तोड़ने में सक्षम नहीं हो सकते हैं।

पृष्ठभूमि की प्रक्रिया

शायद setImmediate() साथ उपरोक्त दृष्टिकोण सरल मामलों के लिए ठीक काम करेगा, लेकिन यह आदर्श से बहुत दूर है। इसके अलावा, यहां थ्रेड्स का उपयोग नहीं किया जाता है (स्पष्ट कारणों के लिए) और हम इसके लिए भाषा को बदलने का इरादा नहीं रखते हैं। क्या थ्रेड्स का उपयोग किए बिना समानांतर डेटा प्रोसेसिंग करना संभव है? हां, यह संभव है, और इसके लिए हमें पृष्ठभूमि डेटा प्रसंस्करण के लिए किसी प्रकार के तंत्र की आवश्यकता है। यह एक निश्चित कार्य शुरू करने के बारे में है, इसके लिए डेटा पास करना है, और इसलिए कि यह कार्य, मुख्य कोड के साथ हस्तक्षेप किए बिना, वह सभी का उपयोग करता है जिसकी उसे जरूरत है, काम पर उतना समय खर्च करें जितनी जरूरत है, और फिर परिणाम वापस करें मुख्य कोड। हमें निम्नलिखित कोड स्निपेट के समान कुछ चाहिए:

 //  script.js   ,    . const service = createService('script.js') //          service.compute(data, function(err, result) { //      }) 

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

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

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

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

 //   const workerFarm = require('worker-farm') const service = workerFarm(require.resolve('./script')) service('hello', function (err, output) { console.log(output) }) // script.js //      - module.exports = (input, callback) => { callback(null, input + ' ' + world) } 

वर्कर_थ्रेड्स मॉड्यूल

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

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

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

कामगार कामगार बहता है

यदि आप संस्करण 11.7.0 से पहले Node.js प्लेटफ़ॉर्म का उपयोग करते हैं, तो worker_threads मॉड्यूल के साथ कार्य को सक्षम करने के लिए, आपको --experimental-worker शुरू करते समय --experimental-worker ध्वज का उपयोग करने की आवश्यकता --experimental-worker

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

कार्यकर्ता सूत्र के साथ काम करने के एक उदाहरण पर विचार करें। हमारे पास एक मुख्य फ़ाइल होगी, index.js , जिसमें हम एक श्रमिक धागा बनाएंगे और इसे प्रसंस्करण के लिए कुछ डेटा पास करेंगे। संबंधित API ईवेंट-आधारित है, लेकिन मैं यहां एक वादे का उपयोग करने जा रहा हूं जो कार्यकर्ता के पहले संदेश के आने पर हल होता है:

 // index.js //    Node.js   11.7.0,  //      node --experimental-worker index.js const { Worker } = require('worker_threads') function runService(workerData) { return new Promise((resolve, reject) => {   const worker = new Worker('./service.js', { workerData });   worker.on('message', resolve);   worker.on('error', reject);   worker.on('exit', (code) => {     if (code !== 0)       reject(new Error(`Worker stopped with exit code ${code}`));   }) }) } async function run() { const result = await runService('world') console.log(result); } run().catch(err => console.error(err)) 

जैसा कि आप देख सकते हैं, वर्कफ़्लो प्रवाह तंत्र का उपयोग करना काफी सरल है। अर्थात्, एक श्रमिक बनाते समय, आपको Worker डिजाइनर को कार्यकर्ता कोड और डेटा के साथ फाइल को पथ पास करना होगा। याद रखें कि यह डेटा क्लोन किया गया है, साझा मेमोरी में संग्रहीत नहीं है। कार्यकर्ता शुरू करने के बाद, हम उससे एक संदेश की उम्मीद करते हैं, message घटना सुनते हैं।

ऊपर, प्रकार के Worker की एक वस्तु बनाते समय, हमने निर्माणकर्ता को कार्यकर्ता कोड - service.js साथ फाइल का नाम दिया। इस फ़ाइल का कोड इस प्रकार है:

 const { workerData, parentPort } = require('worker_threads') // , ,    , //    . parentPort.postMessage({ hello: workerData }) 

दो चीजें हैं जो हमें कार्यकर्ता कोड में रुचि रखती हैं। सबसे पहले, हमें मुख्य एप्लिकेशन द्वारा प्रेषित डेटा की आवश्यकता है। हमारे मामले में, वे workerData चर द्वारा workerData हैं। दूसरे, हमें मुख्य एप्लिकेशन को जानकारी प्रसारित करने के लिए एक तंत्र की आवश्यकता है। यह तंत्र parentPort ऑब्जेक्ट द्वारा parentPort है, जिसमें parentPort postMessage() विधि है, जिसके उपयोग से हम डेटा प्रोसेसिंग के परिणामों को मुख्य एप्लिकेशन में पास करते हैं। कि यह सब कैसे काम करता है।

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

worker_threads मॉड्यूल के बारे में विवरण यहां पाया जा सकता है ।

वेब कार्यकर्ता

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

परिणाम

worker_threads — Node.js. , , . , , , « ». , ? , worker_threads , Node.js worker-farm , worker_threads , Node.js .

प्रिय पाठकों! Node.js-?