TypeScript में समवर्तीता और मल्टीथ्रेडिंग: उन्नत स्तर

TypeScript में समवर्तीता और मल्टीथ्रेडिंग: उन्नत स्तर

आधुनिक वेब डेवलपमेंट और TypeScript पर सर्वर अनुप्रयोगों में, समवर्तीता और मल्टीथ्रेडिंग के साथ कुशलतापूर्वक काम करना महत्वपूर्ण हो जाता है। हालाँकि JavaScript एक सिंगल-थ्रेडेड भाषा है, रनटाइम वातावरण (ब्राउज़र या Node.js) कार्यों के समानांतर निष्पादन के लिए शक्तिशाली उपकरण प्रदान करता है। इस लेख में, हम TypeScript में समवर्तीता के साथ काम करने की उन्नत तकनीकों पर चर्चा करेंगे, जिसमें Worker Threads, SharedArrayBuffer, Atomics और सिंक्रोनाइज़ेशन पैटर्न शामिल हैं।

1. मूलभूत आधार: Event Loop और async/await

मल्टीथ्रेडिंग में गहराई से जाने से पहले, यह समझना महत्वपूर्ण है कि TypeScript में Event Loop कैसे काम करता है। सिंगल-थ्रेडेड वातावरण में समवर्तीता नॉन-ब्लॉकिंग इनपुट-आउटपुट और एसिंक्रोनस संचालन के माध्यम से प्राप्त की जाती है।

त्रुटि प्रबंधन के साथ कई एसिंक्रोनस कार्यों के समवर्ती निष्पादन के लिए Promise.allSettled() का उपयोग करने का एक उदाहरण देखें:

interface TaskResult<T> {  status: 'fulfilled' | 'rejected';  value?: T;  reason?: Error;}

async function runConcurrentTasks<T>(  tasks: Promise<T>[]): Promise<TaskResult<T>[]> {  const results = await Promise.allSettled(tasks);    return results.map(result => {    if (result.status === 'fulfilled') {      return { status: 'fulfilled', value: result.value };    } else {      return { status: 'rejected', reason: result.reason };    }  });}

// उपयोगconst task1 = fetchData('/api/users');const task2 = fetchData('/api/posts');const task3 = fetchData('/api/comments');

const results = await runConcurrentTasks([task1, task2, task3]);

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

CPU-गहन कार्यों (जैसे, इमेज प्रोसेसिंग, क्रिप्टोग्राफी, जटिल गणना) के लिए वास्तविक थ्रेड्स की आवश्यकता होती है। Node.js में इसके लिए Worker Threads का उपयोग किया जाता है।

TypeScript के साथ एक टाइप किया गया Worker बनाएँ:

// worker.tsimport { parentPort, workerData } from 'worker_threads';

interface WorkerInput {  data: number[];  operation: 'sum' | 'multiply';}

interface WorkerOutput {  result: number;  duration: number;}

if (parentPort) {  const input: WorkerInput = workerData;  const start = performance.now();    let result: number;    if (input.operation === 'sum') {    result = input.data.reduce((acc, val) => acc + val, 0);  } else {    result = input.data.reduce((acc, val) => acc * val, 1);  }    const output: WorkerOutput = {    result,    duration: performance.now() - start  };    parentPort.postMessage(output);}

अब कई Worker को प्रबंधित करने के लिए एक मैनेजर बनाएँ:

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

class ThreadPool<TInput, TOutput> {  private workers: Worker[] = [];  private taskQueue: Array<{    input: TInput;    resolve: (value: TOutput) => void;    reject: (reason?: any) => void;  }> = [];

  constructor(    private workerScript: string,    private poolSize: number = 4  ) {    this.initialize();  }

  private initialize(): void {    for (let i = 0; i < this.poolSize; i++) {      const worker = new Worker(this.workerScript);            worker.on('message', (result: TOutput) => {        const task = this.taskQueue.shift();        if (task) {          task.resolve(result);        }        worker.postMessage(this.taskQueue[0]?.input);      });

      worker.on('error', (error) => {        const task = this.taskQueue.shift();        if (task) {          task.reject(error);        }      });

      this.workers.push(worker);    }  }

  async execute(input: TInput): Promise<TOutput> {    return new Promise((resolve, reject) => {      this.ta