TypeScript में कार्य कतारें: निर्माण और प्रसंस्करण अनुकूलन

TypeScript में कार्य कतारों के साथ काम करना: पूरी मार्गदर्शिका

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

कार्य कतार क्या है और इसकी आवश्यकता क्यों है?

कार्य कतार एक डेटा संरचना है जो FIFO (First In, First Out) सिद्धांत पर काम करती है। कार्य कतार के अंत में जोड़े जाते हैं और शुरुआत से निकाले जाते हैं। TypeScript और Node.js के संदर्भ में, कतारों का उपयोग इसके लिए किया जाता है:

• समांतरता को सीमित करना — एक साथ निष्पादित संचालनों की संख्या को नियंत्रित करना (उदाहरण के लिए, सीमाओं वाले API अनुरोध)।
• अतुल्यकालिक प्रसंस्करण — मुख्य थ्रेड को अवरुद्ध किए बिना पृष्ठभूमि में भारी कार्यों को निष्पादित करना।
• पुनः प्रयास — विलंब के साथ विफल कार्यों का स्वचालित पुनरारंभ।
• क्रम प्रबंधन — आश्रित संचालनों के अनुक्रमिक निष्पादन की गारंटी।

TypeScript सख्त टाइपिंग जोड़ता है, जो कतार कोड को अधिक विश्वसनीय और पूर्वानुमानित बनाता है।

TypeScript पर कार्य कतार का मूल कार्यान्वयन

आइए एक सरल लेकिन पूरी तरह से टाइप की गई कतार बनाकर शुरू करें। यह कार्यों (फ़ंक्शन जो Promise लौटाते हैं) को स्वीकार करेगी और उन्हें क्रमिक रूप से निष्पादित करेगी।

// कार्य प्रकार परिभाषित करेंtype Task<T> = () => Promise<T>;

// कतार वर्गclass TaskQueue<T> {    private queue: Task<T>[] = [];    private isProcessing: boolean = false;

    // कतार में कार्य जोड़ना    enqueue(task: Task<T>): void {        this.queue.push(task);        this.process();    }

    // प्रसंस्करण शुरू करना    private async process(): Promise<void> {        if (this.isProcessing) return;        this.isProcessing = true;

        while (this.queue.length > 0) {            const task = this.queue.shift()!;            try {                const result = await task();                console.log('कार्य पूर्ण हुआ:', result);            } catch (error) {                console.error('कार्य निष्पादन में त्रुटि:', error);            }        }

        this.isProcessing = false;    }}

// उपयोग का उदाहरणconst queue = new TaskQueue<string>();queue.enqueue(async () => {    await new Promise(resolve => setTimeout(resolve, 1000));    return 'पहला कार्य';});queue.enqueue(async () => 'दूसरा कार्य (तेज़)');

यह कार्यान्वयन अनुक्रमिक निष्पादन और नया कार्य जोड़ने पर प्रसंस्करण की स्वचालित शुरुआत सुनिश्चित करता है। हालाँकि, यह समांतरता और प्राथमिकताओं का समर्थन नहीं करता है।

समांतरता सीमा वाली कतार

अक्सर एक साथ कई कार्यों को निष्पादित करने की आवश्यकता होती है, लेकिन एक निश्चित सीमा (जैसे, 5 समानांतर अनुरोध) से अधिक नहीं। आइए concurrency पैरामीटर जोड़ें।

class ParallelTaskQueue<T> {    private queue: Task<T>[] = [];    private activeCount: number = 0;    private readonly concurrency: number;

    constructor(concurrency: number = 3) {        this.concurrency = concurrency;    }

    enqueue(task: Task<T>): void {        this.queue.push(task);        this.processNext();    }

    private processNext(): void {        while (this.activeCount < this.concurrency && this.queue.length > 0) {            const task = this.queue.shift()!;            this.activeCount++;            task()                .then(result => console.log('सफलता:', result))                .catch(error => console.error('त्रुटि:', error))                .finally((