TypeScript में समवर्तीता और मल्टीथ्रेडिंग: एक संपूर्ण गाइड

शुरुआती लोगों के लिए ऑनलाइन Python प्रशिक्षक

Python आसानी से सीखें बिना सिद्धांत के बोझ के। स्वचालित जांच के साथ व्यावहारिक कार्य हल करें और ब्राउज़र में सीधे कोड लिखें।

पाठ्यक्रम शुरू करें

TypeScript में समवर्तीता और मल्टीथ्रेडिंग: सिद्धांत से व्यवहार तक

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

समवर्तीता और मल्टीथ्रेडिंग को समझना

कोड में गहराई से जाने से पहले, दो प्रमुख अवधारणाओं के बीच अंतर करना महत्वपूर्ण है:

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

TypeScript Node.js वातावरण में काम करता है, जहाँ मुख्य थ्रेड Event Loop के माध्यम से घटनाओं को संसाधित करता है। भारी गणनाओं के लिए, यह एक अड़चन बन सकता है।

अतुल्यकालिकता और Promise: समवर्तीता का आधार

TypeScript में समवर्तीता का मूल स्तर async/await और Promise पर बनाया गया है। ये तंत्र I/O संचालन की प्रतीक्षा करते समय मुख्य थ्रेड को ब्लॉक नहीं करने देते हैं।

// डेटा की अतुल्यकालिक लोडिंग का उदाहरणinterface User {  id: number;  name: string;}

async function fetchUser(id: number): Promise<User> {  const response = await fetch(`https://api.example.com/users/${id}`);  return response.json();}

// कई अनुरोधों का समानांतर प्रारंभasync function loadUsers(): Promise<User[]> {  const userIds = [1, 2, 3, 4, 5];  const promises = userIds.map(id => fetchUser(id));  return Promise.all(promises);}

loadUsers().then(users => {  console.log('उपयोगकर्ता लोड किए गए:', users.length);});

Promise.all सभी प्रॉमिस को एक साथ शुरू करता है, लेकिन वे एक ही थ्रेड में निष्पादित होते हैं। यह I/O कार्यों के लिए आदर्श है, लेकिन CPU-गहन संचालन के लिए उपयुक्त नहीं है।

Worker Threads: वास्तविक मल्टीथ्रेडिंग

मुख्य थ्रेड को ब्लॉक किए बिना भारी गणना करने के लिए, Worker Threads का उपयोग करें। यह Node.js का एक अंतर्निहित मॉड्यूल है जो अपनी स्वयं की मेमोरी के साथ अलग-अलग थ्रेड बनाता है।

आइए एक अलग थ्रेड में फाइबोनैचि संख्याओं की गणना का एक उदाहरण बनाएं:

// fibonacci.worker.tsimport { parentPort } from 'worker_threads';

function fibonacci(n: number): number {  if (n <= 1) return n;  return fibonacci(n - 1) + fibonacci(n - 2);}

parentPort?.on('message', (n: number) => {  const result = fibonacci(n);  parentPort?.postMessage(result);});

// main.tsimport { Worker } from 'worker_threads';import path from 'path';

function runFibonacciInWorker(n: number): Promise<number> {  return new Promise((resolve, reject) => {    const worker = new Worker(path.resolve(__dirname, 'fibonacci.worker.ts'));        worker.postMessage(n);    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 main() {  console.time('fibonacci');  const result = await runFibonacciInWorker(40);  console.timeEnd('fibonacci');  console.log(`Fibonacci(40) = ${result}`);}

main();

ध्यान दें: TypeScript वर्कर्स को चलाने के लिए JavaScript में संकलन की आवश्यकता होगी। आप ts-node या पूर्व-संकलन का उपयोग कर सकते हैं।