ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕನ್ಕರೆನ್ಸಿ ಪ್ಯಾಟರ್ನ್ಸ್: ಪ್ರಾಮಿಸ್ ಪೂಲ್ಸ್ ಮತ್ತು ರೇಟ್ ಲಿಮಿಟಿಂಗ್

ಆಧುನಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಡೆವಲಪ್‌ಮೆಂಟ್‌ನಲ್ಲಿ, ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿಭಾಯಿಸುವುದು ಒಂದು ಮೂಲಭೂತ ಅವಶ್ಯಕತೆಯಾಗಿದೆ. ನೀವು 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 ಗಳ ಅರೇ ಇದೆ ಮತ್ತು ನೀವು fetch API ಬಳಸಿ ಪ್ರತಿ URL ನಿಂದ ಡೇಟಾವನ್ನು ತರಲು ಬಯಸುತ್ತೀರಿ, ಆದರೆ ಸರ್ವರ್ ಅನ್ನು ಓವರ್‌ಲೋಡ್ ಮಾಡುವುದನ್ನು ತಪ್ಪಿಸಲು ಏಕಕಾಲೀನ ವಿನಂತಿಗಳ ಸಂಖ್ಯೆಯನ್ನು ಸೀಮಿತಗೊಳಿಸಲು ಬಯಸುತ್ತೀರಿ ಎಂದು ಭಾವಿಸೋಣ.

            
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ಗಳು ವಿಧಿಸುವ ರೇಟ್ ಲಿಮಿಟ್‌ಗಳ ಬಗ್ಗೆ ತಿಳಿದಿರಲಿ. ಈ ಮಿತಿಗಳಲ್ಲಿ ಉಳಿಯಲು ಮತ್ತು ಬ್ಲಾಕ್ ಆಗುವುದನ್ನು ತಪ್ಪಿಸಲು ನಿಮ್ಮ ಸ್ವಂತ ರೇಟ್ ಲಿಮಿಟಿಂಗ್ ತರ್ಕವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿ. ರೇಟ್ ಲಿಮಿಟಿಂಗ್ ದೋಷಗಳನ್ನು ಸುಲಭವಾಗಿ ನಿಭಾಯಿಸಲು ಜಿಟರ್‌ನೊಂದಿಗೆ ಎಕ್ಸ್‌ಪೋನೆನ್ಶಿಯಲ್ ಬ್ಯಾಕ್‌ಆಫ್ ಬಳಸುವುದನ್ನು ಪರಿಗಣಿಸಿ.
• ಬಳಕೆದಾರರ ಅನುಭವ: ಬಳಕೆದಾರರು ರೇಟ್ ಲಿಮಿಟ್ ಆದಾಗ, ಅವರಿಗೆ ತಿಳಿವಳಿಕೆ ನೀಡುವ ದೋಷ ಸಂದೇಶಗಳನ್ನು ಒದಗಿಸಿ, ಮಿತಿಗೆ ಕಾರಣ ಮತ್ತು ಭವಿಷ್ಯದಲ್ಲಿ ಅದನ್ನು ಹೇಗೆ ತಪ್ಪಿಸುವುದು ಎಂಬುದನ್ನು ವಿವರಿಸಿ. ವಿಭಿನ್ನ ಬಳಕೆದಾರರ ಅಗತ್ಯಗಳಿಗೆ ಸರಿಹೊಂದುವಂತೆ ವಿಭಿನ್ನ ದರ ಮಿತಿಗಳೊಂದಿಗೆ ವಿವಿಧ ಸೇವಾ ಶ್ರೇಣಿಗಳನ್ನು ನೀಡುವುದನ್ನು ಪರಿಗಣಿಸಿ.
• ಮಾನಿಟರಿಂಗ್ ಮತ್ತು ಲಾಗಿಂಗ್: ಸಂಭಾವ್ಯ ಅಡಚಣೆಗಳನ್ನು ಗುರುತಿಸಲು ಮತ್ತು ನಿಮ್ಮ ರೇಟ್ ಲಿಮಿಟಿಂಗ್ ತರ್ಕವು ಪರಿಣಾಮಕಾರಿಯಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ಕನ್ಕರೆನ್ಸಿ ಮತ್ತು ವಿನಂತಿ ದರಗಳನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಿ. ಬಳಕೆಯ ಮಾದರಿಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಮತ್ತು ಸಂಭಾವ್ಯ ದುರುಪಯೋಗವನ್ನು ಗುರುತಿಸಲು ಸಂಬಂಧಿತ ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು ಲಾಗ್ ಮಾಡಿ.

ತೀರ್ಮಾನ

ಪ್ರಾಮಿಸ್ ಪೂಲ್ಸ್ ಮತ್ತು ರೇಟ್ ಲಿಮಿಟಿಂಗ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಕನ್ಕರೆನ್ಸಿಯನ್ನು ನಿರ್ವಹಿಸಲು ಮತ್ತು ಓವರ್‌ಲೋಡ್ ಅನ್ನು ತಡೆಯಲು ಶಕ್ತಿಯುತ ಸಾಧನಗಳಾಗಿವೆ. ಈ ಪ್ಯಾಟರ್ನ್‌ಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಂಡು ಮತ್ತು ಅವುಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಮೂಲಕ, ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ಕಾರ್ಯಕ್ಷಮತೆ, ಸ್ಥಿರತೆ, ಮತ್ತು ಸ್ಕೇಲೆಬಿಲಿಟಿಯನ್ನು ನೀವು ಸುಧಾರಿಸಬಹುದು. ನೀವು ಸರಳ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ ಅಥವಾ ಸಂಕೀರ್ಣ ಡಿಸ್ಟ್ರಿಬ್ಯೂಟೆಡ್ ಸಿಸ್ಟಮ್ ಅನ್ನು ನಿರ್ಮಿಸುತ್ತಿರಲಿ, ದೃಢವಾದ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹ ಸಾಫ್ಟ್‌ವೇರ್ ಅನ್ನು ನಿರ್ಮಿಸಲು ಈ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವುದು ಅತ್ಯಗತ್ಯ.

ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ನಿರ್ದಿಷ್ಟ ಅವಶ್ಯಕತೆಗಳನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ಪರಿಗಣಿಸಲು ಮತ್ತು ಸೂಕ್ತವಾದ ಕನ್ಕರೆನ್ಸಿ ನಿರ್ವಹಣಾ ತಂತ್ರವನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ಮರೆಯದಿರಿ. ಕಾರ್ಯಕ್ಷಮತೆ ಮತ್ತು ಸಂಪನ್ಮೂಲ ಬಳಕೆಯ ನಡುವಿನ ಅತ್ಯುತ್ತಮ ಸಮತೋಲನವನ್ನು ಕಂಡುಹಿಡಿಯಲು ವಿವಿಧ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳೊಂದಿಗೆ ಪ್ರಯೋಗ ಮಾಡಿ. ಪ್ರಾಮಿಸ್ ಪೂಲ್ಸ್ ಮತ್ತು ರೇಟ್ ಲಿಮಿಟಿಂಗ್‌ನ ದೃಢವಾದ ತಿಳುವಳಿಕೆಯೊಂದಿಗೆ, ಆಧುನಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಡೆವಲಪ್‌ಮೆಂಟ್‌ನ ಸವಾಲುಗಳನ್ನು ಎದುರಿಸಲು ನೀವು ಸಜ್ಜಾಗುತ್ತೀರಿ.