掌控异步洪流：多请求并发下的顺序控制艺术

Hi，我是前端人类学 ！ 在现代Web开发中，高效地处理多个网络请求是提升应用性能的关键。我们通常会采用并发（Concurrent）或并行（Parallel）的方式同时发起多个请求，以避免漫长的串行等待时间。然而，随之而来一个常见的挑战："当我有多个请求要发送，并且需要按照特定顺序处理它们的响应时，该怎么办？" 这篇文章将深入探讨这个问题，并提供从基础到高级的多种解决方案。

一、 问题场景：为什么顺序很重要？

首先，我们必须明确"控制发送顺序"和"控制响应处理顺序"的区别。在绝大多数情况下，我们无法也不应该控制HTTP请求的发送顺序。浏览器或Node.js环境会利用底层机制（如HTTP/1.1的管道化、HTTP/2的多路复用）尽可能快地发出所有请求，其到达服务器的顺序是不确定的，并且受网络状况影响。

我们真正需要控制的，其实是响应处理的顺序。即尽管请求A可能比请求B更晚返回，但我们希望先处理A的响应数据，再处理B的。

典型场景包括：

1. 数据依赖 ：请求B的参数依赖于请求A的返回结果。
   • 例如：先获取用户ID，再根据用户ID获取个人信息。
2. UI渲染顺序 ：需要按顺序渲染内容，如先渲染基础框架，再渲染列表。
   • 例如：一个 dashboard 页面，需要先加载核心指标，再加载详细的图表列表。
3. 操作依赖 ：后续操作必须在前一个操作成功之后才能执行。
   • 例如：先创建一条记录，创建成功后再上传该记录的附件。

二、 解决方案集锦

方案一：朴素的链式调用（Callback Hell / Promise Chain）

这是最直接、最易于理解的方式。既然后一个请求依赖前一个，那么就在前一个请求完成之后，再发起下一个。

// 使用 Promise 链
function fetchSequentially() {
  fetch('/api/first')
    .then(response => response.json())
    .then(firstData => {
      // 使用 firstData 的结果作为第二个请求的参数
      return fetch(`/api/second?param=${firstData.id}`);
    })
    .then(response => response.json())
    .then(secondData => {
      console.log('第一个结果:', firstData); // 注意：这里firstData需要闭包或上层变量
      console.log('第二个结果:', secondData);
      // 可以继续链式调用...
    })
    .catch(error => {
      console.error('某个请求失败了:', error);
    });
}

// 使用现代 async/await 语法，更清晰
async function fetchSequentiallyAsync() {
  try {
    const firstResponse = await fetch('/api/first');
    const firstData = await firstResponse.json();

    const secondResponse = await fetch(`/api/second?param=${firstData.id}`);
    const secondData = await secondResponse.json();

    console.log('顺序结果:', firstData, secondData);
  } catch (error) {
    console.error('请求出错:', error);
  }
}

优点 ：简单明了，代码可读性高。 缺点：请求是串行的，总等待时间是所有请求耗时的总和，性能最差。仅适用于有强依赖关系的场景。

方案二：并发发送，顺序处理（Promise.all + 排序）

当请求之间没有参数依赖，但需要按照发起顺序 来处理响应时，我们可以利用 Promise.all 或 Promise.allSettled 来并发请求，然后按固定顺序处理结果。

关键点：我们需要在发送请求时捕获其索引或顺序信息。

async function fetchConcurrentlyButProcessInOrder() {
  const urls = ['/api/a', '/api/b', '/api/c'];

  // 1. 并发发送所有请求，得到一个 Promise 数组
  const fetchPromises = urls.map(url => fetch(url));

  // 2. 等待所有请求完成 (如果有一个失败，Promise.all 会直接 reject)
  try {
    const responses = await Promise.all(fetchPromises);

    // 3. 按顺序提取 JSON 数据
    // 注意：responses 数组的顺序与 urls 的顺序完全一致
    const dataPromises = responses.map(response => response.json());
    const results = await Promise.all(dataPromises);

    // results[0] 对应 urls[0] 的结果，results[1] 对应 urls[1]...
    console.log('按顺序的结果数组:', results);

  } catch (error) {
    // 处理错误
  }
}

更健壮的版本（处理可能失败的请求）：

async function fetchWithOrder() {
  const requests = [
    fetch('/api/a'),
    fetch('/api/b'),
    fetch('/api/c'),
  ];

  // 使用 allSettled 即使有失败，也会等待所有Promise完成
  const settledResults = await Promise.allSettled(requests);

  // 然后按顺序处理每个结果
  const finalResults = [];
  for (const result of settledResults) {
    if (result.status === 'fulfilled') {
      const data = await result.value.json();
      finalResults.push(data);
    } else {
      finalResults.push({ error: result.reason });
    }
  }
  console.log(finalResults); // 顺序与 requests 一致
}

优点 ：充分利用并发，性能好（总耗时约等于最慢的那个请求）。 缺点：必须等所有请求都返回后才能开始处理，如果某个请求特别慢，会阻塞整个结果的处理。并且要求响应处理的顺序必须和发起顺序一致。

方案三：高级模式 - 自定义调度器（如优先级队列）

对于更复杂的场景，例如需要动态调整请求优先级（类似浏览器中资源加载的优先级），我们可以实现一个简单的请求调度器。

这个例子使用一个队列来管理待发送的请求，并控制并发数，但本质上它仍然是按顺序发送的。更高级的可以实现优先级队列。

class RequestScheduler {
  constructor(maxConcurrent = 2) {
    this.maxConcurrent = maxConcurrent; // 最大并发数
    this.currentConcurrent = 0;
    this.queue = [];
  }

  add(requestFn, priority = 0) {
    // 返回一个 Promise，其 resolve/reject 由实际请求决定
    return new Promise((resolve, reject) => {
      this.queue.push({ requestFn, resolve, reject, priority });
      this._tryToRun();
    });
  }

  _tryToRun() {
    // 如果并发数已满或队列为空，则返回
    if (this.currentConcurrent >= this.maxConcurrent || this.queue.length === 0) {
      return;
    }

    // 可以在这里根据 priority 对队列进行排序，实现优先级调度
    this.queue.sort((a, b) => b.priority - a.priority);

    // 取出下一个任务
    const task = this.queue.shift();
    this.currentConcurrent++;

    task.requestFn()
      .then(task.resolve)
      .catch(task.reject)
      .finally(() => {
        this.currentConcurrent--;
        this._tryToRun(); // 一个任务完成，尝试运行下一个
      });
  }
}

// 使用示例
const scheduler = new RequestScheduler(2); // 最大并发数为2

// 添加5个请求，第三个请求优先级最高
scheduler.add(() => fetch('/api/normal1'), 1);
scheduler.add(() => fetch('/api/normal2'), 1);
scheduler.add(() => fetch('/api/important'), 10); // 高优先级
scheduler.add(() => fetch('/api/normal3'), 1);
scheduler.add(() => fetch('/api/normal4'), 1);

// 尽管第三个是添加的，但因为优先级高，它会优先被发出

优点 ：极其灵活，可以实现复杂的调度策略（如优先级、依赖、重试）。 缺点：实现复杂，属于底层工具，通常只在有非常特殊需求的场景下使用。

三、 总结与选择建议

方案	适用场景	性能	复杂度
链式调用 (async/await)	请求间有强数据依赖	差 (串行)	低
Promise.all + 排序	请求独立 ，但需按发起顺序处理	优 (并发)	中
自定义调度器	复杂场景：优先级调度、流量控制、依赖管理等	可调节	高

如何选择？

1. 如果后一个请求需要前一个请求的结果作为参数 ：毫无疑问，使用方案一（链式调用）。
2. 如果所有请求彼此独立，且你只是希望最终结果是一个有序数组 ：使用方案二（Promise.all），这是最常见和高效的做法。
3. 如果你需要实现像"关键请求优先"、"失败自动重试"、"限制并发数以免压垮服务器"等高级功能 ：那么你需要研究方案三 ，或直接使用社区成熟的库（如 p-queue、axios 的拦截器与取消功能等）。

---

理解这些模式背后的核心思想------协调异步操作的完成时机------远比记住代码更重要。这将使你能在面对任何复杂的异步流程时，都能设计出清晰、高效且健壮的解决方案。