कैसे मल्टी-प्रोसेसिंग ने मुझे अपने जावास्क्रिप्ट एप्लिकेशन को 4x तक गति देने में मदद की

जावास्क्रिप्ट को स्वाभाविक रूप से एकल-थ्रेडेड जानवर के रूप में डिज़ाइन किया गया है। फिर भी, कंप्यूटिंग के जंगली इलाकों में, 'मल्टीप्रोसेसिंग' और 'मल्टी-कोर प्रोसेसर' के रूप में जाने जाने वाले शिकारी, आपके कोड निष्पादन को अनसुनी गति तक बढ़ाने के लिए तैयार होने की प्रतीक्षा कर रहे हैं। 💪🚀

मैंने इस जंगल में कदम रखने का साहस किया, अपना कोड अंतिम उत्तरजीविता परीक्षण में डाला, और आश्चर्यजनक परिणाम सामने आए। 🏆अब, इस रोमांचक खोज में मेरे साथ शामिल होने की आपकी बारी है। हम Node.js में मल्टीप्रोसेसिंग की पहेली में गहराई से उतरेंगे, रिवेटिंग कोड उदाहरणों से लैस होंगे और मेरे प्रयोगों के शानदार फलों पर मशाल चमकाएंगे। 🍎🍏

मल्टीप्रोसेसिंग के जादू के माध्यम से सुपरचार्जिंग जावास्क्रिप्ट प्रदर्शन के इस एड्रेनालाईन-ईंधन वाले साहसिक कार्य पर जाने के लिए तैयार हो जाइए! कमर कस लें और अपने आप को तैयार कर लें क्योंकि हम हाई-ऑक्टेन कोडिंग के मंत्रमुग्ध कर देने वाले क्षेत्र में प्रवेश करने वाले हैं।

इससे पहले कि हम बहुत गहराई में जाएं, आइए खुद को कुछ भरोसेमंद उपकरणों से लैस करें। हम अक्सर कठिन कम्प्यूटेशनल कार्य का अनुकरण करने के लिए कुछ सहायक फ़ंक्शन तैयार करेंगे। आइए एक नई कलाकृति बनाएं, utils.js नाम की एक फ़ाइल बनाएं और वहां इन आवश्यक मंत्रों को लिखें।

 // utils.js function generateRandomData(size) { const data = []; for (let i = 0; i < size; i++) { data.push(Math.random()); } return data; } function processData(data) { // performs some calculations on the array // to simulate high resource intensity let sum = 0; for (let num of data) { for (let j = 0; j < 1000000; j++) { sum += Math.sqrt(num); } } return sum; } module.exports = { generateRandomData, processData, };

एकल-थ्रेडेड संस्करण

एक ही सूत्र में निष्पादन समस्या-समाधान के लिए एक मेहनती और विश्वसनीय दृष्टिकोण का प्रतिनिधित्व करता है। स्क्रिप्ट के एकल-थ्रेडेड संस्करण को दृश्य रूप से इस प्रकार वर्णित किया जा सकता है। सिंगल-थ्रेडेड संस्करण का कोड काफी सीधा है। हम डेटा बनाते हैं और उसे प्रोसेसिंग के लिए भेजते हैं।

 // sync.js const { generateRandomData, processData } = require("./utils"); const data = generateRandomData(30000); console.time("single-thread. Time:"); processData(data); console.timeEnd("single-thread. Time:");

हम कमांड के साथ स्क्रिप्ट लॉन्च करते हैं: node sync.js

हम प्रतीक्षा करते हैं... और प्रतीक्षा करते हैं... और प्रतीक्षा करते हैं...

और इतनी प्रतीक्षा के बाद, हमें स्क्रिप्ट के निष्पादन समय को इंगित करने वाला एक संदेश प्राप्त होता है।

 single-thread. Time:: 25.888s

यह दृष्टिकोण अधिकतर मामलों में फिट बैठता है। लेकिन एक दिक्कत है. कौन, सही दिमाग से, प्रतीक्षा करने की कला को पसंद करता है? इस कष्टदायक देरी को दूर करने के लिए, हमें अपने कंप्यूटर की पूरी मारक क्षमता का उपयोग करना चाहिए! आख़िरकार, अधिकांश आधुनिक कंप्यूटर एक से अधिक सीपीयू कोर के साथ आते हैं!

तो, हमें उन अतिरिक्त कोर को निष्क्रिय क्यों रहने देना चाहिए, जब वे संख्याओं को कम कर सकते हैं और हमारे कोड निष्पादन को सुपरचार्ज कर सकते हैं ? अब उन सोए हुए दिग्गजों को रोशन करने और मल्टीप्रोसेसिंग की कच्ची शक्ति को अनलॉक करने का समय आ गया है! आइए गोता लगाएँ!

स्क्रिप्ट का बहु-संसाधित संस्करण

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

संक्षेप में, हम बस एक बड़े डेटासेट को खंडों में विभाजित कर रहे हैं और प्रत्येक खंड को एक अलग सीपीयू कोर को प्रसंस्करण के लिए निर्दिष्ट कर रहे हैं।

multi-process.js नामक एक फ़ाइल बनाएं और इसे निम्नलिखित सामग्री से भरें।

 // multi-process.js const childProcess = require("child_process"); const utils = require("./utils"); const data = utils.generateRandomData(30000); const chunkSize = Math.ceil(data.length / 4); const chunks = []; for (let i = 0; i < 4; i++) { const start = i * chunkSize; const end = start + chunkSize; chunks.push(data.slice(start, end)); } console.time("multiProcessed"); const workers = []; let results = []; // result collection array for (let i = 0; i < chunks.length; i++) { const worker = childProcess.fork("./worker.js"); // pass its number and data to the workflow worker.send({ workerNumber: i, data: chunks[i] }); workers.push( new Promise((resolve, reject) => { worker.on("message", (result) => { results.push(result); // add the result to the result array resolve(); }); worker.on("error", reject); worker.on("exit", (code) => { if (code !== 0) { reject(new Error(`Worker stopped with exit code ${code}`)); } }); }) ); } Promise.all(workers) .then(() => { console.timeEnd("multiProcessed"); console.log("Processing results:", results); }) .catch((err) => console.error(err));

यह कोड Node.js में बहु-संसाधित डेटा हैंडलिंग की सिम्फनी में एक अकेले कार्यकर्ता प्रक्रिया के ऑर्केस्ट्रेशन को प्रकट करता है।

संक्षेप में, यहाँ क्या हो रहा है:

• कार्यकर्ता मुख्य प्रक्रिया से process.on('message') के माध्यम से डेटा और उसका नंबर प्राप्त करता है।

• processData फ़ंक्शन इस कार्यकर्ता को सौंपे गए डेटा के हिस्से पर गणना करता है।

• परिणाम `process.send()`` के माध्यम से मुख्य प्रक्रिया में वापस भेजा जाता है।

• कार्यकर्ता process.exit() के माध्यम से कोड 0 के साथ समाप्त होता है।

  
  

कमांड के साथ स्क्रिप्ट को सक्रिय करें: node multi-process.js

टर्बो बूस्ट को कस कर पकड़ें...

और हम यह निष्कर्ष निकालते हैं कि कोड ने 5 सेकंड में काम किया!

 Worker 0 started Worker 1 started Worker 2 started Worker 3 started ==================== Worker 1 finished ==================== Worker 2 finished ==================== Worker 3 finished ==================== Worker 0 finished multiProcessed: 5.266s Processing results: [ 4971422688.053512, 4989646323.157899, 4999088030.661542, 5008034869.924775 ]

हमारी स्क्रिप्ट ने चार गुना तेजी से काम किया है! क्या यह शानदार नहीं है?

महान अनावरण: परीक्षण परिणाम

गहरी जिज्ञासा के साथ, मैंने दोनों स्क्रिप्ट को 4-कोर प्रोसेसर वाले कंप्यूटर पर चलाया, और जादू को देखने का इंतजार किया:

• एकल कलाकार, हमारी एकल-थ्रेडेड स्क्रिप्ट ने 25.8 सेकंड में डेटा को परिश्रमपूर्वक संसाधित किया।

• पावर-पैक टीम, हमारी मल्टी-थ्रेडेड स्क्रिप्ट ने इसे केवल 5.2 सेकंड में पार्क से बाहर कर दिया!

  
  

मल्टीप्रोसेसिंग की शक्ति को देखिए - गणना की गति को चौगुनी से भी अधिक!

ये स्पष्ट विरोधाभास इस बात पर प्रकाश डालते हैं कि कैसे मल्टीप्रोसेसिंग आपकी मशीन की कम्प्यूटेशनल क्षमताओं को काफी हद तक बढ़ा सकती है और निष्पादन समय को कम कर सकती है।

अंतिम विचार

हमारा रोमांचक अन्वेषण इस बात की एक ज्वलंत तस्वीर पेश करता है कि कैसे मल्टीप्रोसेसिंग Node.js में कम्प्यूटेशनल कार्यों को टर्बोचार्ज कर सकती है। प्रत्येक प्रोसेसर कोर पर अपना कोड जारी करने से प्रदर्शन में एक ठोस छलांग लगती है, जो चलने से टेलीपोर्टेशन में स्थानांतरित होने के समान है!

यह निश्चित रूप से इस तीर को आपके कोडिंग तरकश में जोड़ने और अपनी परियोजनाओं में इस दृष्टिकोण के साथ प्रयोग करने लायक है। और Node.js में वर्कर थ्रेड्स के आगमन के साथ, मल्टीप्रोसेसिंग को लागू करना आसान हो गया है।

इसे पढ़कर एड्रेनालाईन रश आ गया? नीचे टिप्पणी में Node.js में मल्टीप्रोसेसिंग के साथ अपने स्वयं के रोमांच को बेझिझक साझा करें! आइए मिलकर हाई-स्पीड कोडिंग के रहस्यों को सुलझाना जारी रखें।