为何MongoDB（Mongoose）事务内不支持Promise.all等并行操作？

我在使用Mongoose操作MongoDB事务时，注意到官方文档的并发警告让我很困惑。官方文档中关于ClientSession.startTransaction()的提示：

【重要提示】事务期间不支持并行运行操作。使用Promise.all、Promise.allSettled、Promise.race等方法在事务内并行化操作属于未定义行为。

我编写了如下代码：

await withTransaction(async (session) => {
    await Driver.create(driverData, { session });

    await Promise.all([
        Document.create(
            { recordId: driverId, type: 'LICENSE_FRONT' },
            { session }
        ),
        Document.create(
            { recordId: driverId, type: 'LICENSE_BACK' },
            { session }
        ),
        Document.create(
            { recordId: driverId, type: 'CNIC_FRONT' },
            { session }
        ),
        Document.create(
            { recordId: driverId, type: 'CNIC_BACK' },
            { session }
        )
    ]);
});

所有操作满足以下条件：

• 使用同一个session
• 为独立写入操作
• 不修改同一文档

实际运行中这段代码通常能正常工作，但文档明确指出这属于未定义行为。我有以下疑问：

1. 为何MongoDB事务内即使使用同一session也不支持并行操作？
2. 这种做法实际会引发哪些问题（如写入冲突、session损坏、部分执行等）？
3. 这是MongoDB的限制、Mongoose的限制，还是两者共同的限制？
4. 推荐做法是否是即使操作独立也要始终按顺序执行事务操作？
5. 是否存在既能实现并发又能保证原子性的安全模式？

我希望理解该限制背后的原因，而非盲目规避，并了解替代方案（如顺序操作）。

1. 为何MongoDB事务内即使使用同一session也不支持并行操作？ #

MongoDB的事务会话设计是单线程串行执行的，事务内部需要维护一致的操作上下文、锁状态和事务日志。当你在同一session下并行发起操作时，这些操作会抢占会话的执行资源，导致事务内部的状态管理混乱——比如事务日志的写入顺序可能被打乱，锁的获取和释放逻辑出现冲突，MongoDB无法保证这些并行操作的执行顺序与事务的原子性要求匹配。

另外，MongoDB的事务是基于会话的，每个会话在同一时间只能处理一个请求，并行操作本质上是在同一个会话里同时发起多个请求，这违背了会话的单请求处理模型。

2. 这种做法实际会引发哪些问题？ #

虽然多数情况下可能正常运行，但未定义行为意味着无法保证一致性，可能出现的问题包括：

• 事务部分提交/回滚异常：部分并行操作成功，部分失败，但事务无法正确回滚所有操作，导致数据不一致。
• 会话状态损坏：并行操作可能导致会话的事务状态被篡改，后续操作（甚至非事务操作）出现不可预期的错误。
• 锁竞争死锁：并行操作可能同时尝试获取相同的资源锁，导致死锁，最终事务超时失败。
• 数据顺序异常：事务内的操作顺序被打乱，比如后续依赖前置操作结果的逻辑可能读取到未提交的数据。

3. 这是MongoDB的限制、Mongoose的限制，还是两者共同的限制？ #

这本质上是MongoDB服务器端的限制。Mongoose作为驱动层，只是遵循了MongoDB的官方规范，在文档中明确提示这种未定义行为。即使你直接使用Node.js的MongoDB原生驱动做同样的操作，也会面临相同的问题——因为服务器端不支持同一事务会话下的并行请求。

4. 推荐做法是否是即使操作独立也要始终按顺序执行事务操作？ #

是的，顺序执行是事务内操作的安全做法。虽然性能上会有轻微损失，但能保证事务的原子性、一致性和可预测性。对于你代码中的多个Document.create，可以改成顺序await：

await withTransaction(async (session) => {
    await Driver.create(driverData, { session });

    await Document.create({ recordId: driverId, type: 'LICENSE_FRONT' }, { session });
    await Document.create({ recordId: driverId, type: 'LICENSE_BACK' }, { session });
    await Document.create({ recordId: driverId, type: 'CNIC_FRONT' }, { session });
    await Document.create({ recordId: driverId, type: 'CNIC_BACK' }, { session });
});

如果担心性能，也可以考虑使用批量写入操作（比如Document.insertMany），一次请求插入多个文档，既保证了原子性，又比顺序执行多个create更高效：

await withTransaction(async (session) => {
    await Driver.create(driverData, { session });

    await Document.insertMany([
        { recordId: driverId, type: 'LICENSE_FRONT' },
        { recordId: driverId, type: 'LICENSE_BACK' },
        { recordId: driverId, type: 'CNIC_FRONT' },
        { recordId: driverId, type: 'CNIC_BACK' }
    ], { session });
});

5. 是否存在既能实现并发又能保证原子性的安全模式？ #

如果想在保证原子性的前提下提升写入效率，有两种可行方案：

• 使用批量操作：如上面提到的insertMany、bulkWrite，这些操作是单请求多文档，服务器端会原子性处理，且比多个并行请求更高效。
• 跨会话并行事务（谨慎使用）：如果你的操作可以拆分为多个独立的事务（即事务之间没有数据依赖），可以开启多个会话分别执行事务，但这种场景下每个事务是独立的，无法保证全局原子性——只有当所有事务都提交才算成功，需要自己处理回滚逻辑，复杂度较高。

需要注意的是，不存在同一事务内安全并行操作的模式，因为这违背了MongoDB事务的会话模型设计。

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