JavaScript使用Promise实现并发请求数限制

作者：木棉时间：2026-10-26 12:54:29浏览：484

本文详解如何在JavaScript中利用Promise机制限制并发异步请求数量。通过对比传统回调函数的维护难点，展示使用Promise.all结合计数器与执行队列的方法，有效避免服务器过载或浏览器内存溢出，提供简洁可维护的并发控制方案。

没有Promise的并发请求

在Web开发场景中，获取数据往往涉及发起多个异步请求，例如从服务器拉取用户信息、文章详情或评论列表等。若采用传统的JavaScript回调函数模式，代码结构可能如下所示：

function getUsers(callback) {
  fetch('https://example.com/users', (response) => {
    if (response.status === 200) {
      response.json((data) => {
        callback(data);
      });
    } else {
      console.error('Error fetching users');
    }
  });
}

function getPosts(callback) {
  fetch('https://example.com/posts', (response) => {
    if (response.status === 200) {
      response.json((data) => {
        callback(data);
      });
    } else {
      console.error('Error fetching posts');
    }
  });
}

function getComments(callback) {
  fetch('https://example.com/comments', (response) => {
    if (response.status === 200) {
      response.json((data) => {
        callback(data);
      });
    } else {
      console.error('Error fetching comments');
    }
  });
}

getUsers((users) => {
  console.log(users);
});

getPosts((posts) => {
  console.log(posts);
});

getComments((comments) => {
  console.log(comments);
});

上述示例中，定义了三个用于获取不同数据的函数，每个函数均接收一个回调函数作为参数。当响应成功返回时，调用该回调函数并传递响应数据。这种写法虽然直观，但随着请求数量的增加，代码的可维护性会显著下降。

此外，若需在多个请求全部完成后执行后续逻辑，必须借助特定技巧确保所有请求已完成。例如，可通过计数器跟踪已完成的请求数量，待所有请求结束后再执行回调。这种方式容易出错，尤其在请求失败的情况下更为明显。

使用Promise限制并发请求

JavaScript提供了强大的异步处理工具：Promise。利用Promise，可将异步请求封装为返回Promise对象的函数，并通过链式调用处理请求结果，从而提升代码的清晰度与可靠性。

例如，可将前述代码重构为基于Promise的形式：

function getUsers() {
  return fetch('https://example.com/users').then((response) => {
    if (response.status === 200) {
      return response.json();
    } else {
      throw new Error('Error fetching users');
    }
  });
}

function getPosts() {
  return fetch('https://example.com/posts').then((response) => {
    if (response.status === 200) {
      return response.json();
    } else {
      throw new Error('Error fetching posts');
    }
  });
}

function getComments() {
  return fetch('https://example.com/comments').then((response) => {
    if (response.status === 200) {
      return response.json();
    } else {
      throw new Error('Error fetching comments');
    }
  });
}

Promise.all([getUsers(), getPosts(), getComments()]).then(([users, posts, comments]) => {
  console.log(users);
  console.log(posts);
  console.log(comments);
}).catch((error) => {
  console.error(error);
});

在此示例中，每个数据获取函数被改写为返回Promise对象。响应成功时，通过then方法处理数据；若响应失败，则使用throw语句抛出错误，确保错误状态可被捕获。

随后，使用Promise.all函数等待所有请求完成，并将响应数据存储于数组中。请求全部完成后，可通过解构赋值获取各响应数据进行处理。若存在请求失败，可通过catch方法统一处理错误。

相较于回调函数，这种方式更为简洁且易于维护。然而，若同时发起过多请求，可能导致服务器过载或网络拥塞。因此，必须对并发请求数进行限制，以保障应用程序的稳定运行。

使用Promise实现并发请求数限制

在JavaScript中，可使用Promise.all函数等待所有请求完成。但需注意，Promise.all函数会等待所有Promise对象解析完毕后才返回结果。若同时发起过多请求，可能导致浏览器崩溃或内存溢出。

为解决此问题，可采用特定技巧限制并发请求数。例如，使用计数器跟踪当前正在进行的请求数量，待所有请求完成后执行回调。这种方法能有效避免同时发起过多请求，从而防止服务器过载或网络拥塞。

以下示例展示了如何使用Promise实现并发请求数的限制：

function limitRequest(urls, limit) {
  let index = 0; // 初始化请求索引为0
  const results = []; // 存储所有请求的响应结果
  const inProgress = []; // 存储当前正在进行的请求

  const executeRequest = (url) => { // 定义执行请求的函数
    const promise = fetch(url).then((response) => response.json()); // 发起请求并返回一个Promise对象
    inProgress.push(promise); // 将Promise对象添加到inProgress数组中
    const removeInProgress = () => { // 定义一个函数，用于将Promise对象从inProgress数组中删除
      const i = inProgress.indexOf(promise);
      if (i !== -1) {
        inProgress.splice(i, 1);
      }
    };
    promise.then((result) => { // 请求成功的回调函数
      removeInProgress(); // 将Promise对象从inProgress数组中删除
      results.push(result); // 将响应结果存储到results数组中
      if (index < urls.length) { // 如果还有未完成的请求，继续执行下一个请求
        executeRequest(urls[index++]);
      }
    }).catch((error) => { // 请求失败的回调函数
      removeInProgress(); // 将Promise对象从inProgress数组中删除
      console.error(error); // 打印错误信息
    });
  };

  while (index < limit && index < urls.length) { // 启动最初的一批请求
    executeRequest(urls[index++]);
  }

  return Promise.all(inProgress).then(() => results); // 等待所有请求完成，并返回results数组的Promise对象
}

该示例定义了一个limitRequest函数，用于限制并发请求数，并将所有请求的响应结果存储于results数组中。通过executeRequest函数执行具体请求，并跟踪当前正在进行的请求。利用while循环启动初始批次的请求，并在请求完成后继续执行后续请求，直至所有请求完成。最后，使用Promise.all函数等待所有请求完成，并返回results数组。

总结

本文介绍了如何利用Promise处理异步请求，并通过Promise.all函数等待所有请求完成。同时探讨了限制并发请求数的方法，以确保应用程序正常运行。使用Promise能够编写出更简洁、可维护的代码，并更好地处理异步请求。

到此这篇关于JavaScript使用Promise实现并发请求数限制的文章就介绍到这了,更多相关JavaScript Promise并发请求限制内容请搜索本站以前的文章或继续浏览下面的相关文章希望大家以后多多支持本站！

作者最新文章

JS合并多个数组的三种方法：concat、spread与flat

2026-11-05 17:39:45

JavaScript怎么准确判断数据类型：typeof、instanceof与Object.prototype.toString

2026-11-05 17:09:21

JS中将数组和对象混合组装为JSON字符串

2026-11-05 16:41:42

JS运算符优先级与结合性的区别是什么？

2026-11-05 13:22:02

JS Map怎么只遍历Key或Value

2026-11-05 13:00:36