如何防止异步函数被多次同时调用？

你说的这个场景确实是异步编程里很容易踩的坑！单线程同步代码里，函数同一时间肯定只有一个执行上下文，但async/await里一旦遇到await，JS引擎就会把当前函数挂起，去处理其他任务——这时候如果这个异步函数被再次调用，就会出现多个实例同时处于“执行中”的状态（虽然是挂起的，但确实没完成）。

用事件发射器+队列做包装器是个非常靠谱的思路，核心就是把所有函数调用都放进队列里，保证同一时间只有一个调用在真正执行，上一个完成后再触发下一个。下面给你一个具体的实现方案：

包装器实现代码 #

我们可以基于Node.js的EventEmitter来实现这个逻辑（如果是浏览器环境，你也可以自己实现一个简单的事件触发/监听机制，原理是一样的）：

const { EventEmitter } = require('events');

function createSerialAsyncWrapper(asyncFn) {
  const emitter = new EventEmitter();
  let isExecuting = false;
  const taskQueue = [];

  // 负责处理队列的核心函数
  async function processNextTask() {
    // 如果当前正在执行或队列空，直接返回
    if (isExecuting || taskQueue.length === 0) return;

    isExecuting = true;
    const { args, resolve, reject } = taskQueue.shift();
    
    try {
      // 执行原异步函数
      const result = await asyncFn(...args);
      resolve(result);
    } catch (error) {
      reject(error);
    } finally {
      // 执行完成后标记为未执行，触发事件处理下一个任务
      isExecuting = false;
      emitter.emit('taskFinished');
    }
  }

  // 监听任务完成事件，自动启动下一个任务
  emitter.on('taskFinished', processNextTask);

  // 返回包装后的函数
  return function(...args) {
    return new Promise((resolve, reject) => {
      // 把当前调用的参数和Promise的resolve/reject加入队列
      taskQueue.push({ args, resolve, reject });
      // 尝试启动第一个任务（如果还没在执行的话）
      processNextTask();
    });
  };
}

如何使用这个包装器 #

举个实际的例子，比如你有一个需要串行执行的异步请求函数：

// 模拟一个耗时的异步操作（比如数据库查询或API请求）
async function slowAsyncOperation(taskId) {
  console.log(`开始执行任务 ${taskId}`);
  // 模拟2秒的耗时操作
  await new Promise(resolve => setTimeout(resolve, 2000));
  console.log(`完成任务 ${taskId}`);
  return `任务${taskId}的结果`;
}

// 创建串行执行的包装函数
const serialOperation = createSerialAsyncWrapper(slowAsyncOperation);

// 测试并发调用
async function runTests() {
  // 同时发起3个调用，它们会被串行处理
  const allPromises = [
    serialOperation(1),
    serialOperation(2),
    serialOperation(3)
  ];
  
  const results = await Promise.all(allPromises);
  console.log('所有任务结果:', results);
}

runTests();

运行这段代码后，你会看到输出是严格串行的：

开始执行任务 1
完成任务 1
开始执行任务 2
完成任务 2
开始执行任务 3
完成任务 3
所有任务结果: [ '任务1的结果', '任务2的结果', '任务3的结果' ]

核心逻辑说明 #

• isExecuting：标记当前是否有异步函数实例在执行，避免并发启动多个任务
• taskQueue：存储所有待执行的调用，每个队列项包含调用参数和对应Promise的resolve/reject方法
• processNextTask：负责从队列取出任务执行，完成后触发taskFinished事件，自动启动下一个任务
• 事件发射器的作用是解耦“任务完成”和“启动下一个任务”的逻辑，让代码更清晰

这样包装后的异步函数，就完全保证了同一时间最多只有一个调用在执行，完美解决了你提到的问题！

内容的提问来源于stack exchange，提问作者TheFlanCalculus