JS代码中如何避免竞态条件

在Ja vaScript中优雅规避竞态条件：从原理到实战

在Ja vaScript的异步世界里，setTimeout、Promise、async/await这些利器让我们的代码如虎添翼。但不知你是否遇到过这样的场景：多个异步任务同时扑向同一个共享资源，结果却变得扑朔迷离，每次运行都可能不一样？这就是典型的竞态条件（Race Conditions）在作祟。它就像一场没有发令枪的赛跑，结局难以预料。不过别担心，只要策略得当，完全可以将这种不确定性牢牢掌控。

1. 使用同步机制：设立一道“处理中”的标识

最直观的思路，就是确保关键代码段同一时刻只能被一个任务执行。这好比给房间挂上一块“请勿打扰”的牌子。

let isProcessing = false;

function process() {
  if (isProcessing) return; // 如果正在处理，直接返回
  isProcessing = true; // 挂上“请勿打扰”的牌子

  // 执行关键代码
  console.log('Processing...');

  setTimeout(() => {
    isProcessing = false; // 处理完毕，摘下牌子
  }, 1000);
}

这种方法简单有效，特别适合防止函数被重复触发。但需要注意的是，它本质上是一种“忙等待”的变体，在复杂场景下可能需要更精细的控制。

2. 使用锁机制：实现更精细的资源控制

当简单的布尔标志不够用时，我们可以引入一个真正的锁（Lock）机制。这就像给共享资源配了一把钥匙，谁拿到钥匙谁才能访问。

class Lock {
  constructor() {
    this.isLocked = false;
  }

  async acquire() {
    while (this.isLocked) { // 如果锁被占用，就循环等待
      await new Promise(resolve => setTimeout(resolve, 10));
    }
    this.isLocked = true; // 获取锁
  }

  release() {
    this.isLocked = false; // 释放锁
  }
}

const lock = new Lock();

async function process() {
  await lock.acquire(); // 等待并获取锁
  try {
    // 执行关键代码
    console.log('Processing...');
  } finally {
    lock.release(); // 无论如何，最终都要释放锁
  }
}

使用try...finally块来确保锁一定会被释放，这是避免死锁的关键一步。这种模式在处理数据库事务或复杂的文件操作时尤为有用。

3. 使用Promise.all：当任务可以并肩同行时

并不是所有异步任务都需要争个先后。如果多个任务可以并行执行，且最终结果不依赖于彼此的执行顺序，那么Promise.all就是你的最佳选择。它能等待所有任务“到齐”，然后一起交付结果。

async function processTasks(tasks) {
  const results = await Promise.all(tasks); // 等待所有Promise完成
  console.log(results);
}

const tasks = [
  fetch('https://api.example.com/data1'),
  fetch('https://api.example.com/data2'),
  fetch('https://api.example.com/data3')
];

processTasks(tasks);

这样一来，无论哪个请求先返回，最终的results数组顺序都会严格按照任务数组的顺序排列，从根源上消除了不确定性。当然，前提是这些任务之间没有共享状态的修改。

4. 使用队列：让任务乖乖排队

如果任务必须严格按照顺序执行，一个先进先出（FIFO）的任务队列就是理想的解决方案。想象一下银&行叫号系统，每个新来的任务都取个号排队，依次处理。

class Queue {
  constructor() {
    this.tasks = [];
    this.isProcessing = false;
  }

  enqueue(task) {
    this.tasks.push(task); // 任务入队
    this.process(); // 尝试启动处理
  }

  async process() {
    if (this.isProcessing) return; // 如果正在处理，则等待
    this.isProcessing = true;

    while (this.tasks.length > 0) {
      const task = this.tasks.shift(); // 取出队首任务
      await task(); // 执行任务
    }

    this.isProcessing = false;
  }
}

const queue = new Queue();
queue.enqueue(async () => { console.log('Task 1'); });
queue.enqueue(async () => { console.log('Task 2'); });
queue.enqueue(async () => { console.log('Task 3'); });

无论enqueue被调用得多快，任务都会按顺序执行。这对于处理用户连续点击提交按钮，或需要保证顺序的日志写入场景，效果立竿见影。

5. 使用事件驱动编程：用消息来协调

在Node.js等环境中，事件驱动模型本身就提供了一种优雅的协调方式。通过事件发射器（EventEmitter），我们可以定义清晰的事件处理流程，确保监听器按注册顺序执行。

const EventEmitter = require('events');
const emitter = new EventEmitter();

emitter.on('task1', async () => { console.log('Task 1'); });
emitter.on('task2', async () => { console.log('Task 2'); });
emitter.on('task3', async () => { console.log('Task 3'); });

emitter.emit('task1');
emitter.emit('task2');
emitter.emit('task3');

事件驱动将任务间的耦合度降到最低，每个任务只关心自己订阅的事件。这对于构建插件化系统或复杂的状态流转逻辑，能极大提升代码的可维护性和清晰度。

说到底，避免竞态条件的核心思想，就是将“不确定性”变为“确定性”。无论是加锁、排队，还是利用语言特性保证顺序，目的都是让异步代码的行为变得可预测。根据你的具体场景，选择最合适的一种或组合策略，就能让代码既健壮又可靠。