أنماط التزامن في JavaScript: تجمعات الوعود (Promise Pools) وتحديد المعدل (Rate Limiting)

في تطوير JavaScript الحديث، يعد التعامل مع العمليات غير المتزامنة متطلبًا أساسيًا. سواء كنت تجلب البيانات من واجهات برمجة التطبيقات (APIs)، أو تعالج مجموعات كبيرة من البيانات، أو تتعامل مع تفاعلات المستخدم، فإن إدارة التزامن بفعالية أمر بالغ الأهمية للأداء والاستقرار. هناك نمطان قويان يعالجان هذا التحدي وهما تجمعات الوعود (Promise Pools) وتحديد المعدل (Rate Limiting). يتعمق هذا المقال في هذه المفاهيم، ويقدم أمثلة عملية ويوضح كيفية تطبيقها في مشاريعك.

فهم العمليات غير المتزامنة والتزامن

JavaScript، بطبيعتها، هي أحادية الخيط (single-threaded). هذا يعني أنه يمكن تنفيذ عملية واحدة فقط في كل مرة. ومع ذلك، فإن إدخال العمليات غير المتزامنة (باستخدام تقنيات مثل الاستدعاءات (callbacks)، والوعود (Promises)، و async/await) يسمح لـ JavaScript بالتعامل مع مهام متعددة بشكل متزامن دون حظر الخيط الرئيسي. التزامن، في هذا السياق، يعني إدارة مهام متعددة قيد التنفيذ في وقت واحد.

خذ بعين الاعتبار هذه السيناريوهات:

• جلب البيانات من واجهات برمجة تطبيقات متعددة في وقت واحد لملء لوحة تحكم.
• معالجة عدد كبير من الصور في دفعة واحدة.
• التعامل مع طلبات مستخدمين متعددة تتطلب تفاعلات مع قاعدة البيانات.

بدون إدارة تزامن مناسبة، قد تواجه اختناقات في الأداء، وزيادة في زمن الاستجابة، وحتى عدم استقرار في التطبيق. على سبيل المثال، إغراق واجهة برمجة تطبيقات بعدد كبير جدًا من الطلبات يمكن أن يؤدي إلى أخطاء تحديد المعدل أو حتى انقطاع الخدمة. وبالمثل، فإن تشغيل عدد كبير جدًا من المهام كثيفة الاستخدام لوحدة المعالجة المركزية (CPU) بشكل متزامن يمكن أن يطغى على موارد العميل أو الخادم.

تجمعات الوعود (Promise Pools): إدارة المهام المتزامنة

تجمع الوعود (Promise Pool) هو آلية لتحديد عدد العمليات غير المتزامنة المتزامنة. يضمن تشغيل عدد معين فقط من المهام في أي وقت معين، مما يمنع استنفاد الموارد ويحافظ على الاستجابة. هذا النمط مفيد بشكل خاص عند التعامل مع عدد كبير من المهام المستقلة التي يمكن تنفيذها بالتوازي ولكن تحتاج إلى تقييد.

تطبيق تجمع الوعود

إليك تطبيق أساسي لتجمع الوعود في 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(); // Process the next task in the queue
      }
    }
  }
}

            

              
                Copy
              
            
          

الشرح:

• يأخذ الكلاس PromisePool معامل concurrency، الذي يحدد الحد الأقصى لعدد المهام التي يمكن تشغيلها بشكل متزامن.
• تضيف الدالة add مهمة (دالة تعيد Promise) إلى قائمة الانتظار. وتعيد Promise سيتم حله أو رفضه عند اكتمال المهمة.
• تتحقق الدالة processQueue مما إذا كانت هناك خانات متاحة (this.running < this.concurrency) ومهام في قائمة الانتظار. إذا كان الأمر كذلك، فإنها تزيل مهمة من القائمة، وتنفذها، وتحدث عداد running.
• تضمن كتلة finally أن يتم إنقاص عداد running واستدعاء دالة processQueue مرة أخرى لمعالجة المهمة التالية في قائمة الانتظار، حتى لو فشلت المهمة.

مثال على الاستخدام

لنفترض أن لديك مصفوفة من عناوين URL وتريد جلب البيانات من كل عنوان URL باستخدام واجهة برمجة تطبيقات 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 بإنشاء مصفوفة من الوعود (Promises)، يمثل كل منها مهمة لجلب البيانات من عنوان URL محدد. تضيف الدالة pool.add كل مهمة إلى تجمع الوعود، الذي يدير تنفيذ هذه المهام بشكل متزامن، مما يضمن عدم وجود أكثر من 3 طلبات قيد التنفيذ في أي وقت معين. تنتظر الدالة Promise.all حتى تكتمل جميع المهام وتعيد مصفوفة من النتائج.

تحديد المعدل: منع إساءة استخدام واجهة برمجة التطبيقات والحمل الزائد على الخدمة

تحديد المعدل هو تقنية للتحكم في المعدل الذي يمكن للعملاء (أو المستخدمين) من خلاله تقديم طلبات إلى خدمة أو واجهة برمجة تطبيقات. إنه ضروري لمنع إساءة الاستخدام، والحماية من هجمات الحرمان من الخدمة (DoS)، وضمان الاستخدام العادل للموارد. يمكن تنفيذ تحديد المعدل على جانب العميل أو جانب الخادم أو كليهما.

لماذا نستخدم تحديد المعدل؟

• منع إساءة الاستخدام: يحد من عدد الطلبات التي يمكن لمستخدم واحد أو عميل واحد إجراؤها في فترة زمنية معينة، مما يمنعهم من إغراق الخادم بطلبات مفرطة.
• الحماية من هجمات DoS: يساعد في التخفيف من تأثير هجمات الحرمان من الخدمة الموزعة (DDoS) عن طريق تحديد المعدل الذي يمكن للمهاجمين إرسال الطلبات به.
• ضمان الاستخدام العادل: يسمح لمختلف المستخدمين أو العملاء بالوصول إلى الموارد بشكل عادل عن طريق توزيع الطلبات بالتساوي.
• تحسين الأداء: يمنع تحميل الخادم بشكل زائد، مما يضمن أنه يمكنه الاستجابة للطلبات في الوقت المناسب.
• تحسين التكلفة: يقلل من مخاطر تجاوز حصص استخدام واجهة برمجة التطبيقات وتكبد تكاليف إضافية من خدمات الجهات الخارجية.

تطبيق تحديد المعدل في JavaScript

هناك طرق مختلفة لتنفيذ تحديد المعدل في JavaScript، ولكل منها مفاضلاتها الخاصة. هنا، سنستكشف تطبيقًا من جانب العميل باستخدام خوارزمية دلو الرموز (token bucket) البسيطة.

            
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.

الجمع بين تجمعات الوعود وتحديد المعدل

في بعض السيناريوهات، قد ترغب في الجمع بين تجمعات الوعود وتحديد المعدل لتحقيق تحكم أكثر دقة في التزامن ومعدلات الطلب. على سبيل المثال، قد ترغب في تحديد عدد الطلبات المتزامنة لنقطة نهاية 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 أولاً رمزًا من RateLimiter قبل جلب البيانات من عنوان URL. هذا يضمن تحديد معدل الطلب، بغض النظر عن مستوى التزامن الذي يديره PromisePool.

اعتبارات للتطبيقات العالمية

عند تنفيذ تجمعات الوعود وتحديد المعدل في التطبيقات العالمية، من المهم مراعاة العوامل التالية:

• المناطق الزمنية: كن على دراية بالمناطق الزمنية عند تنفيذ تحديد المعدل. تأكد من أن منطق تحديد المعدل الخاص بك يعتمد على منطقة زمنية متسقة أو يستخدم نهجًا لا يعتمد على المنطقة الزمنية (مثل UTC).
• التوزيع الجغرافي: إذا تم نشر تطبيقك عبر مناطق جغرافية متعددة، ففكر في تنفيذ تحديد المعدل على أساس كل منطقة لمراعاة الاختلافات في زمن استجابة الشبكة وسلوك المستخدم. غالبًا ما توفر شبكات توصيل المحتوى (CDNs) ميزات تحديد المعدل التي يمكن تكوينها على الحافة.
• حدود معدل مزود واجهة برمجة التطبيقات: كن على دراية بحدود المعدل التي تفرضها واجهات برمجة التطبيقات التابعة لجهات خارجية والتي يستخدمها تطبيقك. قم بتنفيذ منطق تحديد المعدل الخاص بك للبقاء ضمن هذه الحدود وتجنب الحظر. ضع في اعتبارك استخدام التراجع الأسي مع التشويش (exponential backoff with jitter) للتعامل مع أخطاء تحديد المعدل برشاقة.
• تجربة المستخدم: قدم رسائل خطأ إعلامية للمستخدمين عندما يتم تحديد معدلهم، موضحًا سبب التحديد وكيفية تجنبه في المستقبل. فكر في تقديم مستويات مختلفة من الخدمة بمعدلات متفاوتة لتلبية احتياجات المستخدمين المختلفة.
• المراقبة والتسجيل: راقب تزامن تطبيقك ومعدلات الطلب لتحديد الاختناقات المحتملة والتأكد من فعالية منطق تحديد المعدل الخاص بك. قم بتسجيل المقاييس ذات الصلة لتتبع أنماط الاستخدام وتحديد إساءة الاستخدام المحتملة.

الخاتمة

تعد تجمعات الوعود وتحديد المعدل أدوات قوية لإدارة التزامن ومنع التحميل الزائد في تطبيقات JavaScript. من خلال فهم هذه الأنماط وتنفيذها بفعالية، يمكنك تحسين أداء تطبيقاتك واستقرارها وقابليتها للتوسع. سواء كنت تبني تطبيق ويب بسيطًا أو نظامًا موزعًا معقدًا، فإن إتقان هذه المفاهيم ضروري لبناء برامج قوية وموثوقة.

تذكر أن تدرس بعناية المتطلبات المحددة لتطبيقك وتختار استراتيجية إدارة التزامن المناسبة. جرب تكوينات مختلفة للعثور على التوازن الأمثل بين الأداء واستخدام الموارد. مع فهم قوي لتجمعات الوعود وتحديد المعدل، ستكون مجهزًا جيدًا لمواجهة تحديات تطوير JavaScript الحديث.