Pola Konkurensi JavaScript: Promise Pools dan Rate Limiting

Dalam pengembangan JavaScript modern, berurusan dengan operasi asinkron adalah persyaratan mendasar. Baik Anda mengambil data dari API, memproses kumpulan data yang besar, atau menangani interaksi pengguna, mengelola konkurensi secara efektif sangat penting untuk performa dan stabilitas. Dua pola ampuh yang mengatasi tantangan ini adalah Promise Pools dan Rate Limiting. Artikel ini menyelami konsep-konsep ini secara mendalam, memberikan contoh praktis dan menunjukkan cara mengimplementasikannya dalam proyek Anda.

Memahami Operasi Asinkron dan Konkurensi

JavaScript, pada dasarnya, bersifat single-threaded. Ini berarti hanya satu operasi yang dapat dieksekusi pada satu waktu. Namun, pengenalan operasi asinkron (menggunakan teknik seperti callback, Promise, dan async/await) memungkinkan JavaScript menangani beberapa tugas secara bersamaan tanpa memblokir thread utama. Konkurensi, dalam konteks ini, berarti mengelola beberapa tugas yang sedang berlangsung secara simultan.

Pertimbangkan skenario-skenario ini:

• Mengambil data dari beberapa API secara bersamaan untuk mengisi dasbor.
• Memproses sejumlah besar gambar dalam satu batch.
• Menangani beberapa permintaan pengguna yang memerlukan interaksi basis data.

Tanpa manajemen konkurensi yang tepat, Anda mungkin akan menghadapi hambatan performa, peningkatan latensi, dan bahkan ketidakstabilan aplikasi. Misalnya, membanjiri API dengan terlalu banyak permintaan dapat menyebabkan kesalahan pembatasan laju (rate limiting) atau bahkan pemadaman layanan. Demikian pula, menjalankan terlalu banyak tugas yang intensif CPU secara bersamaan dapat membebani sumber daya klien atau server.

Promise Pools: Mengelola Tugas-Tugas Konkuren

Promise Pool adalah mekanisme untuk membatasi jumlah operasi asinkron yang berjalan secara bersamaan. Ini memastikan bahwa hanya sejumlah tugas tertentu yang berjalan pada waktu tertentu, mencegah kehabisan sumber daya dan menjaga responsivitas. Pola ini sangat berguna ketika berhadapan dengan sejumlah besar tugas independen yang dapat dieksekusi secara paralel tetapi perlu diatur (throttled).

Mengimplementasikan Promise Pool

Berikut adalah implementasi dasar dari Promise Pool di JavaScript:

            
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(); // Proses tugas berikutnya dalam antrean
      }
    }
  }
}

            

              
                Copy
              
            
          

Penjelasan:

• Kelas PromisePool menerima parameter concurrency, yang mendefinisikan jumlah maksimum tugas yang dapat berjalan secara bersamaan.
• Metode add menambahkan tugas (sebuah fungsi yang mengembalikan Promise) ke dalam antrean. Ini mengembalikan sebuah Promise yang akan resolve atau reject ketika tugas selesai.
• Metode processQueue memeriksa apakah ada slot yang tersedia (this.running < this.concurrency) dan tugas di dalam antrean. Jika ya, ia mengambil tugas dari antrean, mengeksekusinya, dan memperbarui penghitung running.
• Blok finally memastikan bahwa penghitung running dikurangi dan metode processQueue dipanggil lagi untuk memproses tugas berikutnya dalam antrean, bahkan jika tugas gagal.

Contoh Penggunaan

Katakanlah Anda memiliki sebuah array URL dan Anda ingin mengambil data dari setiap URL menggunakan API fetch, tetapi Anda ingin membatasi jumlah permintaan konkuren untuk menghindari membebani server.

            
async function fetchData(url) {
  console.log(`Mengambil data dari ${url}`);
  // Mensimulasikan latensi jaringan
  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); // Batasi konkurensi menjadi 3
  const promises = urls.map(url => pool.add(() => fetchData(url)));

  try {
    const results = await Promise.all(promises);
    console.log('Hasil:', results);
  } catch (error) {
    console.error('Kesalahan mengambil data:', error);
  }
}

main();

            

              
                Copy
              
            
          

Dalam contoh ini, PromisePool dikonfigurasi dengan konkurensi 3. Fungsi urls.map membuat sebuah array Promise, masing-masing mewakili tugas untuk mengambil data dari URL tertentu. Metode pool.add menambahkan setiap tugas ke Promise Pool, yang mengelola eksekusi tugas-tugas ini secara bersamaan, memastikan bahwa tidak lebih dari 3 permintaan yang sedang berjalan pada waktu tertentu. Fungsi Promise.all menunggu semua tugas selesai dan mengembalikan sebuah array hasil.

Rate Limiting: Mencegah Penyalahgunaan API dan Beban Berlebih Layanan

Rate limiting (pembatasan laju) adalah teknik untuk mengontrol laju di mana klien (atau pengguna) dapat membuat permintaan ke layanan atau API. Ini penting untuk mencegah penyalahgunaan, melindungi dari serangan denial-of-service (DoS), dan memastikan penggunaan sumber daya yang adil. Rate limiting dapat diimplementasikan di sisi klien, sisi server, atau keduanya.

Mengapa Menggunakan Rate Limiting?

• Mencegah Penyalahgunaan: Membatasi jumlah permintaan yang dapat dibuat oleh satu pengguna atau klien dalam periode waktu tertentu, mencegah mereka membebani server dengan permintaan yang berlebihan.
• Melindungi dari Serangan DoS: Membantu mengurangi dampak serangan distributed denial-of-service (DDoS) dengan membatasi laju pengiriman permintaan oleh penyerang.
• Memastikan Penggunaan yang Adil: Memungkinkan pengguna atau klien yang berbeda untuk mengakses sumber daya secara adil dengan mendistribusikan permintaan secara merata.
• Meningkatkan Performa: Mencegah server dari kelebihan beban, memastikan bahwa server dapat merespons permintaan secara tepat waktu.
• Optimisasi Biaya: Mengurangi risiko melebihi kuota penggunaan API dan menimbulkan biaya tambahan dari layanan pihak ketiga.

Mengimplementasikan Rate Limiting di JavaScript

Ada berbagai pendekatan untuk mengimplementasikan rate limiting di JavaScript, masing-masing dengan kelebihan dan kekurangannya sendiri. Di sini, kita akan menjelajahi implementasi sisi klien menggunakan algoritma token bucket sederhana.

            
class RateLimiter {
  constructor(capacity, refillRate, interval) {
    this.capacity = capacity; // Jumlah token maksimum
    this.tokens = capacity;
    this.refillRate = refillRate; // Token ditambahkan per interval
    this.interval = interval; // Interval dalam milidetik

    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('Batas laju terlampaui.'));
          }
        }, waitTime);
      });
    }
  }
}

            

              
                Copy
              
            
          

Penjelasan:

• Kelas RateLimiter menerima tiga parameter: capacity (jumlah token maksimum), refillRate (jumlah token yang ditambahkan per interval), dan interval (interval waktu dalam milidetik).
• Metode refill menambahkan token ke dalam bucket dengan laju refillRate per interval, hingga kapasitas maksimum.
• Metode consume mencoba untuk mengonsumsi sejumlah token tertentu (defaultnya 1). Jika ada cukup token yang tersedia, ia mengonsumsinya dan segera resolve. Jika tidak, ia menghitung jumlah waktu yang diperlukan untuk menunggu hingga cukup token tersedia, menunggu selama waktu tersebut, dan kemudian mencoba mengonsumsi token lagi. Jika masih tidak ada cukup token, ia akan reject dengan sebuah error.

Contoh Penggunaan

            
async function makeApiRequest() {
  // Mensimulasikan permintaan API
  await new Promise(resolve => setTimeout(resolve, Math.random() * 500));
  console.log('Permintaan API berhasil');
}

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

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

main();

            

              
                Copy
              
            
          

Dalam contoh ini, RateLimiter dikonfigurasi untuk mengizinkan 5 permintaan per detik. Fungsi main membuat 10 permintaan API, yang masing-masing didahului oleh panggilan ke rateLimiter.consume(). Jika batas laju terlampaui, metode consume akan reject dengan sebuah error, yang ditangkap oleh blok try...catch.

Menggabungkan Promise Pools dan Rate Limiting

Dalam beberapa skenario, Anda mungkin ingin menggabungkan Promise Pools dan Rate Limiting untuk mencapai kontrol yang lebih terperinci atas konkurensi dan laju permintaan. Misalnya, Anda mungkin ingin membatasi jumlah permintaan konkuren ke titik akhir API tertentu sambil juga memastikan bahwa laju permintaan keseluruhan tidak melebihi ambang batas tertentu.

Berikut adalah cara Anda dapat menggabungkan kedua pola ini:

            
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); // Batasi konkurensi menjadi 3
  const rateLimiter = new RateLimiter(5, 1, 1000); // 5 permintaan per detik

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

  try {
    const results = await Promise.all(promises);
    console.log('Hasil:', results);
  } catch (error) {
    console.error('Kesalahan mengambil data:', error);
  }
}

main();

            

              
                Copy
              
            
          

Dalam contoh ini, fungsi fetchDataWithRateLimit pertama-tama mengonsumsi token dari RateLimiter sebelum mengambil data dari URL. Ini memastikan bahwa laju permintaan dibatasi, terlepas dari tingkat konkurensi yang dikelola oleh PromisePool.

Pertimbangan untuk Aplikasi Global

Saat mengimplementasikan Promise Pools dan Rate Limiting dalam aplikasi global, penting untuk mempertimbangkan faktor-faktor berikut:

• Zona Waktu: Perhatikan zona waktu saat mengimplementasikan rate limiting. Pastikan logika pembatasan laju Anda didasarkan pada zona waktu yang konsisten atau menggunakan pendekatan yang tidak bergantung pada zona waktu (misalnya, UTC).
• Distribusi Geografis: Jika aplikasi Anda disebarkan di beberapa wilayah geografis, pertimbangkan untuk menerapkan rate limiting per wilayah untuk memperhitungkan perbedaan latensi jaringan dan perilaku pengguna. Content Delivery Networks (CDN) sering menawarkan fitur rate limiting yang dapat dikonfigurasi di edge.
• Batas Laju Penyedia API: Waspadai batas laju yang diberlakukan oleh API pihak ketiga yang digunakan aplikasi Anda. Terapkan logika rate limiting Anda sendiri untuk tetap berada dalam batas ini dan menghindari pemblokiran. Pertimbangkan untuk menggunakan exponential backoff dengan jitter untuk menangani kesalahan rate limiting dengan baik.
• Pengalaman Pengguna: Berikan pesan kesalahan yang informatif kepada pengguna ketika mereka terkena rate limiting, menjelaskan alasan pembatasan dan cara menghindarinya di masa mendatang. Pertimbangkan untuk menawarkan tingkatan layanan yang berbeda dengan batas laju yang bervariasi untuk mengakomodasi kebutuhan pengguna yang berbeda.
• Pemantauan dan Pencatatan Log: Pantau konkurensi dan laju permintaan aplikasi Anda untuk mengidentifikasi potensi hambatan dan memastikan bahwa logika rate limiting Anda efektif. Catat metrik yang relevan untuk melacak pola penggunaan dan mengidentifikasi potensi penyalahgunaan.

Kesimpulan

Promise Pools dan Rate Limiting adalah alat yang ampuh untuk mengelola konkurensi dan mencegah beban berlebih dalam aplikasi JavaScript. Dengan memahami pola-pola ini dan mengimplementasikannya secara efektif, Anda dapat meningkatkan performa, stabilitas, dan skalabilitas aplikasi Anda. Baik Anda membangun aplikasi web sederhana atau sistem terdistribusi yang kompleks, menguasai konsep-konsep ini sangat penting untuk membangun perangkat lunak yang tangguh dan andal.

Ingatlah untuk mempertimbangkan dengan cermat persyaratan spesifik aplikasi Anda dan memilih strategi manajemen konkurensi yang sesuai. Bereksperimenlah dengan konfigurasi yang berbeda untuk menemukan keseimbangan optimal antara performa dan pemanfaatan sumber daya. Dengan pemahaman yang kuat tentang Promise Pools dan Rate Limiting, Anda akan siap untuk mengatasi tantangan pengembangan JavaScript modern.