JavaScript 非同期タスクキューとレート制限ライブラリ：実戦比較

フロントエンドおよび Node.js 開発において、非同期処理の順序制御、並行処理数の制限、API レート制限の管理は重要な課題です。async、bottleneck、p-queue、promise-queue、queue-promise はそれぞれ異なるアプローチでこの問題に対処します。本記事では、実務での選択基準を明確にするために、これら 5 つのパッケージを技術的に深く比較します。

🏗️ アーキテクチャと設計思想

各ライブラリは異なる設計思想を持っており、それが機能セットと使用场景に影響します。

async は 2010 年頃から存在する最も歴史のあるライブラリで、非同期コレクション操作とフロー制御を包括的に提供します。Promise 以前のコールバック時代から進化し、現在は Promise ベースの API も提供しています。

// async: 非同期 map 処理
import { map } from 'async';

const results = await map(['file1.txt', 'file2.txt'], async (file) => {
  return await readFile(file);
});

bottleneck はレート制限と負荷分散に特化したライブラリです。単なるキューではなく、時間ベースの制限（例：1 秒間に 5 リクエスト）を厳密に管理します。

// bottleneck: レート制限付き実行
import Bottleneck from 'bottleneck';

const limiter = new Bottleneck({ minTime: 200, maxConcurrent: 5 });

const result = await limiter.schedule(() => fetch('/api/data'));

p-queue は Promise ベースの軽量キューで、並行処理数の制御に焦点を当てています。Sindre Sorhus 氏によってメンテナンスされており、モダンな JavaScript プロジェクトとの親和性が高いです。

// p-queue: 並行処理制限
import PQueue from 'p-queue';

const queue = new PQueue({ concurrency: 5 });

await queue.add(() => fetch('/api/item/1'));
await queue.add(() => fetch('/api/item/2'));

promise-queue と queue-promise はよりシンプルな FIFO キュー実装で、機能は限定的ですが、特定のユースケースでは十分です。

// promise-queue: 基本的なキュー
import PromiseQueue from 'promise-queue';

const queue = new PromiseQueue(5, 1); // 5 並行、無限待機

queue.add(() => fetch('/api/data'));

// queue-promise: シンプル実装
import Queue from 'queue-promise';

const queue = new Queue();

queue.add(() => fetch('/api/data'));

⚡ 並行処理制御の仕組み

並行処理数を制限する方法は、ライブラリによって大きく異なります。

async は並行処理制御というより、コレクション操作の非同期バージョンを提供します。parallel、series、waterfall などのフロー制御関数がありますが、動的な並行数制限はできません。

// async: 並列実行（全タスク同時開始）
import { parallel } from 'async';

await parallel([
  (cb) => setTimeout(() => cb(null, 1), 100),
  (cb) => setTimeout(() => cb(null, 2), 100)
]);

bottleneck は最も高度な制御を提供し、minTime（タスク間の最小時間）と maxConcurrent（最大並行数）の両方を設定できます。

// bottleneck: 詳細なレート制限
const limiter = new Bottleneck({
  maxConcurrent: 5,      // 最大 5 並列
  minTime: 100,          // タスク間 100ms 以上
  highWater: 100,        // キューの警告閾値
  strategy: Bottleneck.strategy.OVERFLOW // 超過時の戦略
});

p-queue は concurrency オプションで並行処理数を制限しますが、時間ベースのレート制限は built-in で提供していません。

// p-queue: 並行数制限のみ
const queue = new PQueue({ 
  concurrency: 5,
  interval: 1000,        // 追加機能：時間ベース制限も可能
  intervalCap: 10        // 1 秒間に 10 タスク
});

promise-queue はコンストラクタで並行数と待機時間を指定しますが、柔軟性は低いです。

// promise-queue: 固定設定
const queue = new PromiseQueue(
  5,    // 並行処理数
  1000  // 待機時間（使用されない場合あり）
);

queue-promise は最もシンプルで、並行処理制御機能は限定的または存在しません。

// queue-promise: 基本的なキュー
const queue = new Queue();
// 並行制御オプションは限定的

🔄 エラーハンドリングと回復

プロダクション環境では、エラーハンドリングの挙動が重要です。

async は伝統的に Node.js のエラーファーストコールバックパターンに従いますが、Promise ベースの API も提供しています。エラー発生時の挙動は関数によって異なります。

// async: エラーハンドリング
import { map } from 'async';

try {
  const results = await map(files, async (file) => {
    if (file === 'bad.txt') throw new Error('Failed');
    return await readFile(file);
  });
} catch (error) {
  // 最初のエラーで停止
  console.error(error);
}

bottleneck はエラー発生後もキューを継続でき、再試行ロジックを組み込むことができます。

// bottleneck: エラー後の継続
limiter.schedule(async () => {
  try {
    return await api.call();
  } catch (error) {
    // エラーを握りつぶして継続
    return null;
  }
});

p-queue は Promise の標準的なエラーハンドリングに従い、個別のタスクエラーがキュー全体を停止させることはありません。

// p-queue: 個別タスクのエラー処理
queue.add(async () => {
  try {
    return await fetch('/api/data');
  } catch (error) {
    console.error('Task failed:', error);
    return null; // キューは継続
  }
});

promise-queue と queue-promise も同様に Promise の標準挙動に従いますが、エラー回復の機能は限定的です。

// promise-queue: エラー処理
queue.add(() => {
  return fetch('/api/data').catch(err => {
    console.error(err);
    return null;
  });
});

📦 実装サイズと依存関係

バンドルサイズを気にするフロントエンドプロジェクトでは、依存関係の少なさが重要です。

• async: 依存関係なし、ただしコードベースが大きい
• bottleneck: 依存関係なし、中程度のサイズ
• p-queue: 依存関係あり（eventemitter3）、軽量
• promise-queue: 依存関係なし、非常に軽量
• queue-promise: 依存関係なし、軽量

// インポート例の比較
import { map } from 'async';           // 全体または個別
import Bottleneck from 'bottleneck';   // デフォルトエクスポート
import PQueue from 'p-queue';          // デフォルトエクスポート
import PromiseQueue from 'promise-queue'; // デフォルトエクスポート
import Queue from 'queue-promise';     // デフォルトエクスポート

🌐 ブラウザと Node.js の互換性

すべてのパッケージがブラウザと Node.js の両方で動作しますが、注意点があります。

async は最も広い互換性を持ち、古いブラウザでも動作しますが、ポリフィルが必要な場合があります。

bottleneck は Redis アダプターを使用する場合、Node.js 環境でのみ完全な機能を利用できます。ブラウザではローカルモードになります。

// bottleneck: Redis 連携（Node.js のみ）
const limiter = new Bottleneck({
  datastore: 'redis',
  redisClient: new Redis()
});

p-queue はブラウザと Node.js の両方で完全に動作し、モダンな JavaScript 機能を使用しています。

promise-queue と queue-promise も両環境で動作しますが、機能セットが限定的です。

🛠️ 保守状況とコミュニティ

パッケージの長期的な使用を考えると、メンテナンス状況が重要です。

• async: 非常に活発にメンテナンスされており、事実上の標準ライブラリ
• bottleneck: 活発にメンテナンスされており、企業でも使用されている
• p-queue: 活発にメンテナンスされており、Sindre Sorhus 氏のエコシステムの一部
• promise-queue: メンテナンス頻度は低く、新機能追加は少ない
• queue-promise: メンテナンス状況を確認が必要、機能追加は限定的

💡 実戦での選択ガイド

シナリオ 1: API レート制限の厳守

外部 API を呼び出す際に、レート制限（例：1 分間に 100 リクエスト）を厳守する必要がある場合：

✅ 推奨: bottleneck

const limiter = new Bottleneck({
  minTime: 600,  // 600ms ごとに 1 リクエスト
  maxConcurrent: 1
});

const results = await Promise.all(
  urls.map(url => limiter.schedule(() => fetch(url)))
);

シナリオ 2: 画像の並列アップロード

複数の画像を並列でアップロードしたいが、ブラウザを重くしたくない場合：

✅ 推奨: p-queue

const queue = new PQueue({ concurrency: 5 });

const uploadJobs = images.map(img => 
  queue.add(() => uploadImage(img))
);

await Promise.all(uploadJobs);

シナリオ 3: レガシーコードの維持

既存のコードベースで async が既に使用されており、新しい機能追加が必要な場合：

✅ 推奨: async（一貫性の維持）

import { series } from 'async';

await series([
  (cb) => migrateDatabase(cb),
  (cb) => clearCache(cb),
  (cb) => restartService(cb)
]);

シナリオ 4: シンプルな FIFO キュー

非常にシンプルなキュー機能のみが必要で、依存関係を増やしたくない場合：

✅ 推奨: promise-queue または queue-promise

const queue = new PromiseQueue(1, Infinity);

queue.add(() => processItem(item1));
queue.add(() => processItem(item2));

📊 総合比較表

🎯 結論：どのパッケージを選ぶべきか

新規プロジェクトでは、p-queue または bottleneck の使用を推奨します。これらはモダンな Promise ベースの API を提供し、活発にメンテナンスされています。

• レート制限が必要 → bottleneck
• シンプルな並行制御 → p-queue
• コレクション操作も必要 → async
• 最小限の依存関係 → promise-queue

レガシープロジェクトでは、既存のコードベースとの一貫性を保つために、既に使用されているライブラリを継続使用することが賢明です。

最終的に、プロジェクトの要件（レート制限、並行制御、保守性）とチームの習熟度を考慮して選択してください。どのライブラリも適切に使用すれば、非同期処理の制御を大幅に改善できます。