జావాస్క్రిప్ట్ కంకరెన్సీ ప్యాటర్న్స్: ప్రామిస్ పూల్స్ మరియు రేట్ లిమిటింగ్

ఆధునిక జావాస్క్రిప్ట్ డెవలప్‌మెంట్‌లో, అసింక్రోనస్ ఆపరేషన్‌లతో వ్యవహరించడం ఒక ప్రాథమిక అవసరం. మీరు APIల నుండి డేటాను పొందుతున్నా, పెద్ద డేటాసెట్‌లను ప్రాసెస్ చేస్తున్నా లేదా వినియోగదారు ఇంటరాక్షన్‌లను నిర్వహిస్తున్నా, పనితీరు మరియు స్థిరత్వం కోసం కంకరెన్సీని సమర్థవంతంగా నిర్వహించడం చాలా ముఖ్యం. ఈ సవాలును పరిష్కరించే రెండు శక్తివంతమైన ప్యాటర్న్‌లు ప్రామిస్ పూల్స్ మరియు రేట్ లిమిటింగ్. ఈ కథనం ఈ భావనలలోకి లోతుగా ప్రవేశిస్తుంది, ఆచరణాత్మక ఉదాహరణలను అందిస్తుంది మరియు మీ ప్రాజెక్ట్‌లలో వాటిని ఎలా అమలు చేయాలో చూపిస్తుంది.

అసింక్రోనస్ ఆపరేషన్‌లు మరియు కంకరెన్సీని అర్థం చేసుకోవడం

జావాస్క్రిప్ట్, దాని స్వభావం ప్రకారం, సింగిల్-థ్రెడ్. దీని అర్థం ఒకేసారి ఒక ఆపరేషన్ మాత్రమే అమలు చేయబడుతుంది. అయితే, అసింక్రోనస్ ఆపరేషన్‌ల పరిచయం (కాల్‌బ్యాక్‌లు, ప్రామిస్‌లు మరియు async/await వంటి టెక్నిక్‌లను ఉపయోగించి) జావాస్క్రిప్ట్‌కు మెయిన్ థ్రెడ్‌ను బ్లాక్ చేయకుండా బహుళ పనులను ఏకకాలంలో నిర్వహించడానికి అనుమతిస్తుంది. ఈ సందర్భంలో కంకరెన్సీ అంటే ఒకేసారి పురోగతిలో ఉన్న బహుళ పనులను నిర్వహించడం.

ఈ సందర్భాలను పరిగణించండి:

• ఒక డాష్‌బోర్డ్‌ను నింపడానికి ఒకేసారి బహుళ APIల నుండి డేటాను పొందడం.
• ఒక బ్యాచ్‌లో పెద్ద సంఖ్యలో చిత్రాలను ప్రాసెస్ చేయడం.
• డేటాబేస్ ఇంటరాక్షన్‌లు అవసరమయ్యే బహుళ వినియోగదారు అభ్యర్థనలను నిర్వహించడం.

సరైన కంకరెన్సీ నిర్వహణ లేకుండా, మీరు పనితీరులో ఆటంకాలు, పెరిగిన లాటెన్సీ మరియు అప్లికేషన్ అస్థిరతను కూడా ఎదుర్కోవచ్చు. ఉదాహరణకు, ఒక APIకి చాలా అభ్యర్థనలతో దాడి చేయడం రేట్ లిమిటింగ్ లోపాలకు లేదా సేవా అంతరాయాలకు దారితీయవచ్చు. అదేవిధంగా, ఏకకాలంలో చాలా CPU-ఇంటెన్సివ్ టాస్క్‌లను అమలు చేయడం క్లయింట్ లేదా సర్వర్ వనరులను అధికంగా వినియోగిస్తుంది.

ప్రామిస్ పూల్స్: ఏకకాల పనులను నిర్వహించడం

ఒక ప్రామిస్ పూల్ అనేది ఏకకాల అసింక్రోనస్ ఆపరేషన్‌ల సంఖ్యను పరిమితం చేయడానికి ఒక యంత్రాంగం. ఇది ఏ సమయంలోనైనా నిర్దిష్ట సంఖ్యలో టాస్క్‌లు మాత్రమే నడుస్తున్నాయని నిర్ధారిస్తుంది, వనరుల అలసటను నివారిస్తుంది మరియు ప్రతిస్పందనను నిర్వహిస్తుంది. ఈ ప్యాటర్న్ సమాంతరంగా అమలు చేయగల కానీ థ్రాటిల్ చేయాల్సిన పెద్ద సంఖ్యలో స్వతంత్ర పనులతో వ్యవహరించేటప్పుడు ప్రత్యేకంగా ఉపయోగపడుతుంది.

ఒక ప్రామిస్ పూల్‌ను అమలు చేయడం

జావాస్క్రిప్ట్‌లో ఒక ప్రామిస్ పూల్ యొక్క ప్రాథమిక అమలు ఇక్కడ ఉంది:

            
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 పద్ధతి మళ్లీ పిలువబడుతుందని నిర్ధారిస్తుంది.

ఉదాహరణ వినియోగం

మీ దగ్గర URLల శ్రేణి ఉందని మరియు మీరు ప్రతి URL నుండి డేటాను fetch APIని ఉపయోగించి పొందాలనుకుంటున్నారు, కానీ మీరు సర్వర్‌ను ఓవర్‌లోడ్ చేయకుండా ఉండటానికి ఏకకాల అభ్యర్థనల సంఖ్యను పరిమితం చేయాలనుకుంటున్నారు అనుకుందాం.

            
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 ఫంక్షన్ ప్రామిస్‌ల శ్రేణిని సృష్టిస్తుంది, ప్రతి ఒక్కటి ఒక నిర్దిష్ట URL నుండి డేటాను పొందే పనిని సూచిస్తుంది. pool.add పద్ధతి ప్రతి పనిని ప్రామిస్ పూల్‌కు జోడిస్తుంది, ఇది ఈ పనుల అమలును ఏకకాలంలో నిర్వహిస్తుంది, ఏ సమయంలోనైనా 3 కంటే ఎక్కువ అభ్యర్థనలు ఫ్లైట్‌లో లేవని నిర్ధారిస్తుంది. Promise.all ఫంక్షన్ అన్ని పనులు పూర్తయ్యే వరకు వేచి ఉండి, ఫలితాల శ్రేణిని తిరిగి ఇస్తుంది.

రేట్ లిమిటింగ్: API దుర్వినియోగం మరియు సర్వీస్ ఓవర్‌లోడ్‌ను నివారించడం

రేట్ లిమిటింగ్ అనేది క్లయింట్లు (లేదా వినియోగదారులు) ఒక సేవ లేదా APIకి అభ్యర్థనలు చేసే రేటును నియంత్రించడానికి ఒక సాంకేతికత. ఇది దుర్వినియోగాన్ని నివారించడానికి, డినయల్-ఆఫ్-సర్వీస్ (DoS) దాడుల నుండి రక్షించడానికి మరియు వనరుల న్యాయమైన వినియోగాన్ని నిర్ధారించడానికి చాలా అవసరం. రేట్ లిమిటింగ్‌ను క్లయింట్-సైడ్, సర్వర్-సైడ్ లేదా రెండింటిలోనూ అమలు చేయవచ్చు.

రేట్ లిమిటింగ్ ఎందుకు ఉపయోగించాలి?

• దుర్వినియోగాన్ని నివారించండి: ఒకే వినియోగదారు లేదా క్లయింట్ ఒక నిర్దిష్ట సమయ వ్యవధిలో చేయగల అభ్యర్థనల సంఖ్యను పరిమితం చేస్తుంది, వారిని అధిక అభ్యర్థనలతో సర్వర్‌ను ఓవర్‌లోడ్ చేయకుండా నివారిస్తుంది.
• DoS దాడుల నుండి రక్షించండి: దాడి చేసేవారు అభ్యర్థనలు పంపే రేటును పరిమితం చేయడం ద్వారా డిస్ట్రిబ్యూటెడ్ డినయల్-ఆఫ్-సర్వీస్ (DDoS) దాడుల ప్రభావాన్ని తగ్గించడంలో సహాయపడుతుంది.
• న్యాయమైన వినియోగాన్ని నిర్ధారించండి: అభ్యర్థనలను సమానంగా పంపిణీ చేయడం ద్వారా వివిధ వినియోగదారులు లేదా క్లయింట్లు వనరులను న్యాయంగా యాక్సెస్ చేయడానికి అనుమతిస్తుంది.
• పనితీరును మెరుగుపరచండి: సర్వర్ ఓవర్‌లోడ్ కాకుండా నివారిస్తుంది, ఇది అభ్యర్థనలకు సకాలంలో ప్రతిస్పందించగలదని నిర్ధారిస్తుంది.
• ఖర్చు ఆప్టిమైజేషన్: API వినియోగ కోటాలను మించిపోయే ప్రమాదాన్ని తగ్గిస్తుంది మరియు మూడవ-పక్ష సేవల నుండి అదనపు ఖర్చులను నివారిస్తుంది.

జావాస్క్రిప్ట్‌లో రేట్ లిమిటింగ్‌ను అమలు చేయడం

జావాస్క్రిప్ట్‌లో రేట్ లిమిటింగ్‌ను అమలు చేయడానికి వివిధ పద్ధతులు ఉన్నాయి, ప్రతిదానికీ దాని స్వంత లాభనష్టాలు ఉన్నాయి. ఇక్కడ, మనం ఒక సాధారణ టోకెన్ బకెట్ అల్గారిథమ్‌ను ఉపయోగించి క్లయింట్-సైడ్ అమలును అన్వేషిస్తాము.

            
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 పద్ధతి గరిష్ట సామర్థ్యం వరకు, intervalకు refillRate చొప్పున బకెట్‌కు టోకెన్లను జోడిస్తుంది.
• 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 API అభ్యర్థనలను చేస్తుంది, ప్రతి ఒక్కటి rateLimiter.consume() కు కాల్ చేసిన తర్వాత జరుగుతుంది. రేట్ పరిమితిని మించిపోతే, consume పద్ధతి ఒక లోపంతో తిరస్కరిస్తుంది, ఇది try...catch బ్లాక్ ద్వారా పట్టుకోబడుతుంది.

ప్రామిస్ పూల్స్ మరియు రేట్ లిమిటింగ్‌ను కలపడం

కొన్ని సందర్భాల్లో, మీరు కంకరెన్సీ మరియు అభ్యర్థన రేట్లపై మరింత సూక్ష్మమైన నియంత్రణను సాధించడానికి ప్రామిస్ పూల్స్ మరియు రేట్ లిమిటింగ్‌ను కలపాలనుకోవచ్చు. ఉదాహరణకు, మీరు ఒక నిర్దిష్ట API ఎండ్‌పాయింట్‌కు ఏకకాల అభ్యర్థనల సంఖ్యను పరిమితం చేయాలనుకోవచ్చు, అదే సమయంలో మొత్తం అభ్యర్థన రేటు ఒక నిర్దిష్ట పరిమితిని మించకుండా చూసుకోవాలి.

ఈ రెండు ప్యాటర్న్‌లను మీరు ఎలా కలపవచ్చో ఇక్కడ ఉంది:

            
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 ఫంక్షన్ URL నుండి డేటాను పొందే ముందు మొదట RateLimiter నుండి ఒక టోకెన్‌ను వినియోగిస్తుంది. ఇది PromisePool ద్వారా నిర్వహించబడే కంకరెన్సీ స్థాయితో సంబంధం లేకుండా అభ్యర్థన రేటు పరిమితంగా ఉండేలా నిర్ధారిస్తుంది.

ప్రపంచవ్యాప్త అప్లికేషన్‌ల కోసం పరిగణనలు

ప్రపంచవ్యాప్త అప్లికేషన్‌లలో ప్రామిస్ పూల్స్ మరియు రేట్ లిమిటింగ్‌ను అమలు చేసేటప్పుడు, ఈ క్రింది అంశాలను పరిగణించడం ముఖ్యం:

• సమయ మండలాలు: రేట్ లిమిటింగ్‌ను అమలు చేసేటప్పుడు సమయ మండలాల గురించి జాగ్రత్తగా ఉండండి. మీ రేట్ లిమిటింగ్ లాజిక్ ఒక స్థిరమైన సమయ మండలంపై ఆధారపడి ఉందని లేదా సమయ మండలం-అజ్ఞాత విధానాన్ని (ఉదా., UTC) ఉపయోగిస్తుందని నిర్ధారించుకోండి.
• భౌగోళిక పంపిణీ: మీ అప్లికేషన్ బహుళ భౌగోళిక ప్రాంతాలలో విస్తరించబడితే, నెట్‌వర్క్ లాటెన్సీ మరియు వినియోగదారు ప్రవర్తనలో తేడాలను పరిగణనలోకి తీసుకోవడానికి ప్రతి-ప్రాంతం ప్రాతిపదికన రేట్ లిమిటింగ్‌ను అమలు చేయడాన్ని పరిగణించండి. కంటెంట్ డెలివరీ నెట్‌వర్క్‌లు (CDNలు) తరచుగా అంచున కాన్ఫిగర్ చేయగల రేట్ లిమిటింగ్ ఫీచర్‌లను అందిస్తాయి.
• API ప్రొవైడర్ రేట్ పరిమితులు: మీ అప్లికేషన్ ఉపయోగించే మూడవ-పక్ష APIల ద్వారా విధించబడిన రేట్ పరిమితుల గురించి తెలుసుకోండి. ఈ పరిమితులలో ఉండటానికి మరియు బ్లాక్ చేయబడకుండా ఉండటానికి మీ స్వంత రేట్ లిమిటింగ్ లాజిక్‌ను అమలు చేయండి. రేట్ లిమిటింగ్ లోపాలను సునాయాసంగా నిర్వహించడానికి జిట్టర్‌తో ఎక్స్‌పోనెన్షియల్ బ్యాక్‌ఆఫ్‌ను ఉపయోగించడాన్ని పరిగణించండి.
• వినియోగదారు అనుభవం: వినియోగదారులు రేట్ పరిమితం చేయబడినప్పుడు వారికి సమాచార లోప సందేశాలను అందించండి, పరిమితికి కారణాన్ని మరియు భవిష్యత్తులో దానిని ఎలా నివారించాలో వివరించండి. వివిధ వినియోగదారు అవసరాలకు అనుగుణంగా విభిన్న రేట్ పరిమితులతో వివిధ సేవా శ్రేణులను అందించడాన్ని పరిగణించండి.
• పర్యవేక్షణ మరియు లాగింగ్: సంభావ్య ఆటంకాలను గుర్తించడానికి మరియు మీ రేట్ లిమిటింగ్ లాజిక్ సమర్థవంతంగా ఉందని నిర్ధారించుకోవడానికి మీ అప్లికేషన్ యొక్క కంకరెన్సీ మరియు అభ్యర్థన రేట్లను పర్యవేక్షించండి. వినియోగ ప్యాటర్న్‌లను ట్రాక్ చేయడానికి మరియు సంభావ్య దుర్వినియోగాన్ని గుర్తించడానికి సంబంధిత మెట్రిక్‌లను లాగ్ చేయండి.

ముగింపు

ప్రామిస్ పూల్స్ మరియు రేట్ లిమిటింగ్ జావాస్క్రిప్ట్ అప్లికేషన్‌లలో కంకరెన్సీని నిర్వహించడానికి మరియు ఓవర్‌లోడ్‌ను నివారించడానికి శక్తివంతమైన సాధనాలు. ఈ ప్యాటర్న్‌లను అర్థం చేసుకుని, వాటిని సమర్థవంతంగా అమలు చేయడం ద్వారా, మీరు మీ అప్లికేషన్‌ల పనితీరు, స్థిరత్వం మరియు స్కేలబిలిటీని మెరుగుపరచవచ్చు. మీరు ఒక సాధారణ వెబ్ అప్లికేషన్‌ను నిర్మిస్తున్నా లేదా సంక్లిష్టమైన డిస్ట్రిబ్యూటెడ్ సిస్టమ్‌ను నిర్మిస్తున్నా, దృఢమైన మరియు విశ్వసనీయమైన సాఫ్ట్‌వేర్‌ను నిర్మించడానికి ఈ భావనలను మాస్టర్ చేయడం చాలా అవసరం.

మీ అప్లికేషన్ యొక్క నిర్దిష్ట అవసరాలను జాగ్రత్తగా పరిగణించి, తగిన కంకరెన్సీ నిర్వహణ వ్యూహాన్ని ఎంచుకోవాలని గుర్తుంచుకోండి. పనితీరు మరియు వనరుల వినియోగం మధ్య సరైన సమతుల్యతను కనుగొనడానికి వివిధ కాన్ఫిగరేషన్‌లతో ప్రయోగాలు చేయండి. ప్రామిస్ పూల్స్ మరియు రేట్ లిమిటింగ్ గురించి దృఢమైన అవగాహనతో, మీరు ఆధునిక జావాస్క్రిప్ట్ డెవలప్‌మెంట్ సవాళ్లను ఎదుర్కోవడానికి బాగా సన్నద్ధంగా ఉంటారు.