Node.js如何处理MySQL并发请求？账户余额更新异常求助

嘿，你遇到的是数据库并发场景下典型的**竞争条件（Race Condition）**问题！咱们先搞清楚为啥会出这种错，再给你几个靠谱的解决办法。

问题根源 #

你现在的逻辑是「先查max(id)获取当前余额 → 计算新余额 → 写入数据库」，这个流程不是原子操作。当两个请求同时进来时，它们会同时读到同一个旧余额，各自计算后再写入，后面的写入直接覆盖了前面的结果：

比如初始余额100，请求A和B同时读到100，A算完写200，B算完写300，最后数据库里就只剩300了，相当于A的操作被"吞"了。

解决方案（按推荐优先级排序） #

1. 用数据库原子更新（最推荐，最简单） #

直接让数据库在单条SQL里完成「读余额+更新余额」的操作，数据库会自动保证这个操作的原子性，同一时间只有一个请求能修改该行数据。

MySQL示例代码：

router.post('/saveBalance', async (req, res) => {
  const { accountId, addAmount } = req.body; // 假设你传账户ID和要加的金额
  try {
    // 原子更新：直接在数据库里把余额加上指定金额，同时返回更新后的结果
    const [updateResult, queryResult] = await db.query(`
      UPDATE t_account SET balance = balance + ? WHERE account_id = ?;
      SELECT balance FROM t_account WHERE account_id = ?;
    `, [addAmount, accountId, accountId]);

    const updatedBalance = queryResult[0].balance;
    res.json({ success: true, balance: updatedBalance });
  } catch (err) {
    console.error('余额更新失败:', err);
    res.status(500).json({ success: false, message: '系统异常，请稍后重试' });
  }
});

PostgreSQL示例（支持RETURNING更简洁）：

router.post('/saveBalance', async (req, res) => {
  const { accountId, addAmount } = req.body;
  try {
    const [result] = await db.query(`
      UPDATE t_account SET balance = balance + ? 
      WHERE account_id = ? 
      RETURNING balance;
    `, [addAmount, accountId]);

    const updatedBalance = result[0].balance;
    res.json({ success: true, balance: updatedBalance });
  } catch (err) {
    console.error('余额更新失败:', err);
    res.status(500).json({ success: false, message: '系统异常，请稍后重试' });
  }
});

2. 事务+行锁（适合复杂业务逻辑） #

如果你的业务需要先做一些校验（比如判断账户是否存在、金额是否合法）再更新余额，可以用数据库事务结合行锁，把整个「校验-读-改-写」流程变成原子操作。

router.post('/saveBalance', async (req, res) => {
  const { accountId, addAmount } = req.body;
  let dbConnection;

  try {
    // 获取独立数据库连接
    dbConnection = await db.getConnection();
    // 开启事务
    await dbConnection.beginTransaction();

    // 锁定目标账户行，其他请求必须等当前事务提交后才能修改
    const [accountList] = await dbConnection.query(`
      SELECT balance FROM t_account WHERE account_id = ? FOR UPDATE;
    `, [accountId]);

    if (!accountList.length) {
      await dbConnection.rollback();
      return res.status(404).json({ success: false, message: '账户不存在' });
    }

    // 这里可以加各种业务校验，比如金额不能为负等
    if (addAmount < 0) {
      await dbConnection.rollback();
      return res.status(400).json({ success: false, message: '新增金额不能为负数' });
    }

    const newBalance = accountList[0].balance + addAmount;
    // 更新余额
    await dbConnection.query(`
      UPDATE t_account SET balance = ? WHERE account_id = ?;
    `, [newBalance, accountId]);

    // 提交事务，释放行锁
    await dbConnection.commit();
    res.json({ success: true, balance: newBalance });
  } catch (err) {
    // 出错回滚事务
    if (dbConnection) await dbConnection.rollback();
    console.error('余额更新失败:', err);
    res.status(500).json({ success: false, message: '系统异常，请稍后重试' });
  } finally {
    // 释放数据库连接
    if (dbConnection) dbConnection.release();
  }
});

3. 分布式锁（多实例部署场景） #

如果你的Express API是多实例部署的，后端内存锁会失效，这时候可以用Redis做分布式锁，确保同一账户同时只有一个请求在处理。

先安装依赖：

npm install async-lock redis

示例代码：

const AsyncLock = require('async-lock');
const redis = require('redis');
// 初始化Redis客户端（根据你的Redis配置修改）
const redisClient = redis.createClient({ host: 'localhost', port: 6379 });
// 配置分布式锁
const lock = new AsyncLock({ driver: 'redis', client: redisClient });

router.post('/saveBalance', async (req, res) => {
  const { accountId, addAmount } = req.body;
  // 用账户ID作为锁的唯一标识，确保同一账户的请求串行处理
  const lockKey = `account:balance:${accountId}`;

  try {
    // 获取锁，超时时间设为5秒，避免死锁
    const updatedBalance = await lock.acquire(lockKey, async () => {
      // 这里的代码同一时间只有一个请求能执行
      const [accountList] = await db.query(`
        SELECT balance FROM t_account WHERE account_id = ?;
      `, [accountId]);

      if (!accountList.length) throw new Error('账户不存在');
      if (addAmount < 0) throw new Error('新增金额不能为负数');

      const newBalance = accountList[0].balance + addAmount;
      await db.query(`UPDATE t_account SET balance = ? WHERE account_id = ?;`, [newBalance, accountId]);
      return newBalance;
    }, { timeout: 5000 });

    res.json({ success: true, balance: updatedBalance });
  } catch (err) {
    console.error('余额更新失败:', err);
    if (err.message.includes('timeout')) {
      res.status(429).json({ success: false, message: '请求太频繁，请稍后重试' });
    } else {
      res.status(500).json({ success: false, message: err.message || '系统异常，请稍后重试' });
    }
  }
});

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