Node.js环境下如何确保计数器正确递增？

首先纠正一个关键误解：async函数本身始终在主线程的Event Loop中执行，只有当函数内部调用了依赖libuv线程池的异步API（如文件读取、加密运算）时，对应的IO/计算任务才会被分配到libuv线程池执行，但这些任务的回调逻辑（包括await之后的代码）最终还是会回到主线程的Event Loop中串行执行。

因此，在常规的主线程异步场景下，你给出的代码并不会出现计数器更新错误——两个counter++会依次执行，最终结果必然是2。但如果你的场景涉及多线程（如worker_threads），或者你需要严格控制函数的执行顺序，就需要针对性处理：

1. 主线程异步场景：确保执行顺序（可选） #

如果只是需要保证f1执行完成后再执行f2，直接用await串行调用即可：

let counter = 0;

async function f1() {
  // 执行异步操作，比如await fs.promises.readFile('./file.txt')
  counter++;
}

async function f2() {
  // 执行异步操作
  counter++;
}

// 串行执行两个函数
async function run() {
  await f1();
  await f2();
  console.log(counter); // 输出2
}
run();

2. 多线程场景（如worker_threads）：线程安全的计数器更新 #

如果是用worker_threads创建了多个工作线程，多个线程需要共享并修改同一个计数器，必须用原子操作或消息传递来避免竞争：

方式一：原子操作（SharedArrayBuffer + Atomics） #

通过共享内存和原子API保证递增操作的线程安全：

// 主线程代码
const { Worker } = require('worker_threads');
// 创建共享内存存储32位整数
const sharedBuffer = new SharedArrayBuffer(4);
const counter = new Int32Array(sharedBuffer);

// 启动两个工作线程
new Worker('./worker.js', { workerData: sharedBuffer });
new Worker('./worker.js', { workerData: sharedBuffer });

// 等待线程执行完成后查看结果
setTimeout(() => {
  console.log(counter[0]); // 输出2
}, 1000);

// worker.js（工作线程代码）
const { workerData } = require('worker_threads');
const counter = new Int32Array(workerData);

// 原子递增操作，保证线程安全
Atomics.add(counter, 0, 1);

方式二：消息传递（避免共享内存） #

让主线程统一管理计数器，工作线程完成任务后发送消息通知主线程递增：

// 主线程代码
const { Worker } = require('worker_threads');
let counter = 0;
let completedWorkers = 0;

const worker1 = new Worker('./worker.js');
const worker2 = new Worker('./worker.js');

// 监听工作线程的完成消息
worker1.on('message', () => {
  counter++;
  completedWorkers++;
  if (completedWorkers === 2) {
    console.log(counter); // 输出2
  }
});

worker2.on('message', () => {
  counter++;
  completedWorkers++;
  if (completedWorkers === 2) {
    console.log(counter); // 输出2
  }
});

// worker.js（工作线程代码）
// 执行任务逻辑
// do something...

// 任务完成后向主线程发送消息
process.send('task-done');

3. 模拟竞争场景的互斥锁方案 #

如果是在主线程内需要模拟“互斥”（比如多个异步任务需要修改同一个共享资源），可以用Promise队列实现简单的互斥锁：

let counter = 0;
// 锁初始化为已释放状态
let lock = Promise.resolve();

// 获取锁的函数
function acquireLock() {
  let resolveLock;
  const newLock = new Promise(resolve => {
    resolveLock = resolve;
  });
  const currentLock = lock;
  lock = newLock;
  // 返回的Promise执行后会得到释放锁的函数
  return currentLock.then(() => resolveLock);
}

async function f1() {
  const release = await acquireLock();
  // do something
  counter++;
  // 释放锁
  release();
}

async function f2() {
  const release = await acquireLock();
  // do something
  counter++;
  release();
}

f1();
f2();

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