जावास्क्रिप्ट कंकरेंसी पैटर्न: प्रॉमिस पूल्स और रेट लिमिटिंग

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

एसिंक्रोनस ऑपरेशंस और कंकरेंसी को समझना

जावास्क्रिप्ट, स्वभाव से, सिंगल-थ्रेडेड है। इसका मतलब है कि एक समय में केवल एक ही ऑपरेशन निष्पादित हो सकता है। हालाँकि, एसिंक्रोनस ऑपरेशंस (कॉलबैक, प्रॉमिस, और async/await जैसी तकनीकों का उपयोग करके) की शुरुआत जावास्क्रिप्ट को मुख्य थ्रेड को ब्लॉक किए बिना एक साथ कई कार्यों को संभालने की अनुमति देती है। इस संदर्भ में कंकरेंसी का अर्थ है एक साथ प्रगति पर कई कार्यों का प्रबंधन करना।

इन परिदृश्यों पर विचार करें:

• एक डैशबोर्ड को पॉप्युलेट करने के लिए एक साथ कई एपीआई से डेटा प्राप्त करना।
• एक बैच में बड़ी संख्या में छवियों को प्रोसेस करना।
• कई यूजर अनुरोधों को संभालना जिनके लिए डेटाबेस इंटरैक्शन की आवश्यकता होती है।

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

प्रॉमिस पूल्स: समवर्ती कार्यों का प्रबंधन

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

एक प्रॉमिस पूल लागू करना

यहां जावास्क्रिप्ट में एक प्रॉमिस पूल का एक बुनियादी कार्यान्वयन है:

            
class PromisePool {
  constructor(concurrency) {
    this.concurrency = concurrency;
    this.running = 0;
    this.queue = [];
  }

  async add(task) {
    return new Promise((resolve, reject) => {
      this.queue.push({ task, resolve, reject });
      this.processQueue();
    });
  }

  async processQueue() {
    if (this.running < this.concurrency && this.queue.length) {
      const { task, resolve, reject } = this.queue.shift();
      this.running++;

      try {
        const result = await task();
        resolve(result);
      } catch (error) {
        reject(error);
      } finally {
        this.running--;
        this.processQueue(); // Process the next task in the queue
      }
    }
  }
}

            

              
                Copy
              
            
          

स्पष्टीकरण:

• PromisePool क्लास एक concurrency पैरामीटर लेती है, जो एक साथ चल सकने वाले कार्यों की अधिकतम संख्या को परिभाषित करता है।
• add विधि कतार में एक कार्य (एक फ़ंक्शन जो एक प्रॉमिस लौटाता है) जोड़ती है। यह एक प्रॉमिस लौटाता है जो कार्य पूरा होने पर रिजॉल्व या रिजेक्ट हो जाएगा।
• processQueue विधि यह जांचती है कि क्या उपलब्ध स्लॉट (this.running < this.concurrency) और कतार में कार्य हैं। यदि ऐसा है, तो यह एक कार्य को डीक्यू करता है, उसे निष्पादित करता है, और running काउंटर को अपडेट करता है।
• finally ब्लॉक यह सुनिश्चित करता है कि running काउंटर घटाया जाए और कतार में अगले कार्य को प्रोसेस करने के लिए processQueue विधि को फिर से कॉल किया जाए, भले ही कार्य विफल हो जाए।

उदाहरण उपयोग

मान लीजिए कि आपके पास यूआरएल की एक ऐरे है और आप fetch एपीआई का उपयोग करके प्रत्येक यूआरएल से डेटा प्राप्त करना चाहते हैं, लेकिन आप सर्वर को ओवरलोड करने से बचने के लिए समवर्ती अनुरोधों की संख्या को सीमित करना चाहते हैं।

            
async function fetchData(url) {
  console.log(`Fetching data from ${url}`);
  // Simulate network latency
  await new Promise(resolve => setTimeout(resolve, Math.random() * 1000));
  const response = await fetch(url);
  if (!response.ok) {
    throw new Error(`HTTP error! status: ${response.status}`);
  }
  return await response.json();
}

async function main() {
  const urls = [
    'https://jsonplaceholder.typicode.com/todos/1',
    'https://jsonplaceholder.typicode.com/todos/2',
    'https://jsonplaceholder.typicode.com/todos/3',
    'https://jsonplaceholder.typicode.com/todos/4',
    'https://jsonplaceholder.typicode.com/todos/5',
    'https://jsonplaceholder.typicode.com/todos/6',
    'https://jsonplaceholder.typicode.com/todos/7',
    'https://jsonplaceholder.typicode.com/todos/8',
    'https://jsonplaceholder.typicode.com/todos/9',
    'https://jsonplaceholder.typicode.com/todos/10',
  ];

  const pool = new PromisePool(3); // Limit concurrency to 3
  const promises = urls.map(url => pool.add(() => fetchData(url)));

  try {
    const results = await Promise.all(promises);
    console.log('Results:', results);
  } catch (error) {
    console.error('Error fetching data:', error);
  }
}

main();

            

              
                Copy
              
            
          

इस उदाहरण में, PromisePool को 3 की कंकरेंसी के साथ कॉन्फ़िगर किया गया है। urls.map फ़ंक्शन प्रॉमिस की एक ऐरे बनाता है, जिनमें से प्रत्येक एक विशिष्ट यूआरएल से डेटा प्राप्त करने के कार्य का प्रतिनिधित्व करता है। pool.add विधि प्रत्येक कार्य को प्रॉमिस पूल में जोड़ती है, जो इन कार्यों के निष्पादन को समवर्ती रूप से प्रबंधित करता है, यह सुनिश्चित करता है कि किसी भी समय 3 से अधिक अनुरोध उड़ान में न हों। Promise.all फ़ंक्शन सभी कार्यों के पूरा होने की प्रतीक्षा करता है और परिणामों की एक ऐरे लौटाता है।

रेट लिमिटिंग: एपीआई दुरुपयोग और सेवा ओवरलोड को रोकना

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

रेट लिमिटिंग का उपयोग क्यों करें?

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

जावास्क्रिप्ट में रेट लिमिटिंग लागू करना

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

            
class RateLimiter {
  constructor(capacity, refillRate, interval) {
    this.capacity = capacity; // Maximum number of tokens
    this.tokens = capacity;
    this.refillRate = refillRate; // Tokens added per interval
    this.interval = interval; // Interval in milliseconds

    setInterval(() => {
      this.refill();
    }, this.interval);
  }

  refill() {
    this.tokens = Math.min(this.capacity, this.tokens + this.refillRate);
  }

  async consume(cost = 1) {
    if (this.tokens >= cost) {
      this.tokens -= cost;
      return Promise.resolve();
    } else {
      return new Promise((resolve, reject) => {
        const waitTime = Math.ceil((cost - this.tokens) / this.refillRate) * this.interval;
        setTimeout(() => {
          if (this.tokens >= cost) {
            this.tokens -= cost;
            resolve();
          } else {
            reject(new Error('Rate limit exceeded.'));
          }
        }, waitTime);
      });
    }
  }
}

            

              
                Copy
              
            
          

स्पष्टीकरण:

• RateLimiter क्लास तीन पैरामीटर लेती है: capacity (टोकन की अधिकतम संख्या), refillRate (प्रति अंतराल जोड़े गए टोकन की संख्या), और interval (मिलीसेकंड में समय अंतराल)।
• refill विधि बकेट में refillRate प्रति interval की दर से टोकन जोड़ती है, जो अधिकतम क्षमता तक हो सकती है।
• consume विधि एक निर्दिष्ट संख्या में टोकन (डिफ़ॉल्ट रूप से 1) का उपभोग करने का प्रयास करती है। यदि पर्याप्त टोकन उपलब्ध हैं, तो यह उनका उपभोग करता है और तुरंत रिजॉल्व हो जाता है। अन्यथा, यह गणना करता है कि पर्याप्त टोकन उपलब्ध होने तक कितना समय इंतजार करना है, उस समय तक प्रतीक्षा करता है, और फिर टोकन का उपभोग करने का फिर से प्रयास करता है। यदि अभी भी पर्याप्त टोकन नहीं हैं, तो यह एक त्रुटि के साथ रिजेक्ट हो जाता है।

उदाहरण उपयोग

            
async function makeApiRequest() {
  // Simulate API request
  await new Promise(resolve => setTimeout(resolve, Math.random() * 500));
  console.log('API request successful');
}

async function main() {
  const rateLimiter = new RateLimiter(5, 1, 1000); // 5 requests per second

  for (let i = 0; i < 10; i++) {
    try {
      await rateLimiter.consume();
      await makeApiRequest();
    } catch (error) {
      console.error('Rate limit exceeded:', error.message);
    }
  }
}

main();

            

              
                Copy
              
            
          

इस उदाहरण में, RateLimiter को प्रति सेकंड 5 अनुरोधों की अनुमति देने के लिए कॉन्फ़िगर किया गया है। main फ़ंक्शन 10 एपीआई अनुरोध करता है, जिनमें से प्रत्येक से पहले rateLimiter.consume() को कॉल किया जाता है। यदि दर सीमा पार हो जाती है, तो consume विधि एक त्रुटि के साथ रिजेक्ट हो जाएगी, जिसे try...catch ब्लॉक द्वारा पकड़ा जाता है।

प्रॉमिस पूल्स और रेट लिमिटिंग का संयोजन

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

यहां बताया गया है कि आप इन दो पैटर्नों को कैसे जोड़ सकते हैं:

            
async function fetchDataWithRateLimit(url, rateLimiter) {
  try {
    await rateLimiter.consume();
    return await fetchData(url);
  } catch (error) {
    throw error;
  }
}

async function main() {
  const urls = [
    'https://jsonplaceholder.typicode.com/todos/1',
    'https://jsonplaceholder.typicode.com/todos/2',
    'https://jsonplaceholder.typicode.com/todos/3',
    'https://jsonplaceholder.typicode.com/todos/4',
    'https://jsonplaceholder.typicode.com/todos/5',
    'https://jsonplaceholder.typicode.com/todos/6',
    'https://jsonplaceholder.typicode.com/todos/7',
    'https://jsonplaceholder.typicode.com/todos/8',
    'https://jsonplaceholder.typicode.com/todos/9',
    'https://jsonplaceholder.typicode.com/todos/10',
  ];

  const pool = new PromisePool(3); // Limit concurrency to 3
  const rateLimiter = new RateLimiter(5, 1, 1000); // 5 requests per second

  const promises = urls.map(url => pool.add(() => fetchDataWithRateLimit(url, rateLimiter)));

  try {
    const results = await Promise.all(promises);
    console.log('Results:', results);
  } catch (error) {
    console.error('Error fetching data:', error);
  }
}

main();

            

              
                Copy
              
            
          

इस उदाहरण में, fetchDataWithRateLimit फ़ंक्शन यूआरएल से डेटा प्राप्त करने से पहले RateLimiter से एक टोकन का उपभोग करता है। यह सुनिश्चित करता है कि PromisePool द्वारा प्रबंधित कंकरेंसी स्तर की परवाह किए बिना अनुरोध दर सीमित है।

वैश्विक अनुप्रयोगों के लिए विचार

वैश्विक अनुप्रयोगों में प्रॉमिस पूल्स और रेट लिमिटिंग लागू करते समय, निम्नलिखित कारकों पर विचार करना महत्वपूर्ण है:

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

निष्कर्ष

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

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