Node.js中MongoDB并发请求重复插入的低内存非索引解决方案

我完全理解你的痛点——并发请求同时查不到目标条目，结果齐刷刷插入造成重复，又因为集合数据量大、存多种数据，不想加全量唯一索引占内存。下面给你几个实用的解决方案，按推荐优先级排序：

1. 用MongoDB原子操作findOneAndUpdate（最优方案） #

MongoDB的单文档操作是原子性的，findOneAndUpdate可以把「查询是否存在+插入/返回」合并成一个原子步骤，从根本上避免并发冲突。而且配合稀疏索引/部分索引，既能保证查询性能，又能大幅降低索引的内存占用。

代码示例 #

async function getOrCreateDocument(targetXYZ) {
  const collection = db.collection('yourCollection');
  
  // 原子执行：不存在则插入，存在则返回已有文档
  const result = await collection.findOneAndUpdate(
    { xyz: targetXYZ }, // 匹配你的唯一条目XYZ
    { 
      $setOnInsert: { 
        // 这里放只有插入时才需要设置的字段，比如创建时间、其他业务字段
        createdAt: new Date(),
        // ... 其他字段
      } 
    },
    {
      upsert: true, // 开启插入模式：无匹配则插入
      returnDocument: 'after', // 返回操作后的文档（插入的新文档或已存在的旧文档）
      projection: { /* 可选：指定要返回的字段，减少数据传输 */ }
    }
  );

  return result.value; // 这就是你要的目标文档
}

优化查询性能：稀疏/部分索引 #

如果XYZ字段不是所有文档都有（因为集合存多种数据），可以给XYZ字段建稀疏索引，只包含有XYZ值的文档，索引大小会比全量索引小很多：

await db.collection('yourCollection').createIndex(
  { xyz: 1 }, 
  { sparse: true } // 只索引存在xyz字段的文档
);

如果只有特定条件的文档需要XYZ唯一判断，还可以用部分索引进一步缩小索引范围，比如只索引type: 'xyz_type'的文档：

await db.collection('yourCollection').createIndex(
  { xyz: 1 }, 
  { partialFilterExpression: { type: 'xyz_type' } } // 只索引符合该条件的文档
);

这个方案不需要唯一索引，完全靠原子操作避免重复，同时索引内存占用极低，完美匹配你的需求。

2. 分布式锁（适合无法加任何索引的场景） #

如果原集合实在不能加任何索引，那可以用分布式锁来控制并发，同一时间只有一个请求能执行「查询+插入」操作。可以用MongoDB自己实现轻量锁：

代码示例 #

// 先创建一个锁集合（只需初始化一次）
await db.createCollection('resource_locks');
await db.collection('resource_locks').createIndex({ resource: 1 }, { unique: true });

async function getOrCreateWithLock(targetXYZ) {
  const lockKey = `xyz_${targetXYZ}`;
  const lockTTL = 5000; // 锁有效期5秒，防止死锁，根据业务调整

  // 尝试获取锁
  const lockResult = await db.collection('resource_locks').findOneAndUpdate(
    { 
      resource: lockKey,
      expiresAt: { $lt: new Date() } // 只抢已过期的锁
    },
    { 
      $set: { expiresAt: new Date(Date.now() + lockTTL) } 
    },
    { upsert: true, returnDocument: 'after' }
  );

  // 判断是否获取到锁：新插入锁或更新过期时间都算成功
  if (lockResult.lastErrorObject.upserted || lockResult.lastErrorObject.nModified > 0) {
    try {
      // 执行正常的查询+插入逻辑
      const existingDoc = await db.collection('yourCollection').findOne({ xyz: targetXYZ });
      if (existingDoc) {
        return existingDoc;
      }
      const newDoc = await db.collection('yourCollection').insertOne({ 
        xyz: targetXYZ,
        createdAt: new Date()
        // ... 其他字段
      });
      return newDoc.ops[0];
    } finally {
      // 释放锁
      await db.collection('resource_locks').deleteOne({ resource: lockKey });
    }
  } else {
    // 没抢到锁，等待后重试
    await new Promise(resolve => setTimeout(resolve, 100));
    return getOrCreateWithLock(targetXYZ); // 递归重试
  }
}

这个方案的缺点是代码复杂度高，有一定性能开销，但胜在不需要修改原集合的任何索引。

3. 应用层内存锁（仅单实例Node.js适用） #

如果你的Node.js应用是单实例部署的，可以用内存中的Map来做简单的锁，控制同一时间只有一个请求处理某个XYZ值。

代码示例 #

// 内存锁：key是XYZ值，value是Promise（用于等待锁释放）
const processingLocks = new Map();

async function getOrCreateWithMemoryLock(targetXYZ) {
  // 如果已有请求在处理这个XYZ，等待它完成
  if (processingLocks.has(targetXYZ)) {
    await processingLocks.get(targetXYZ);
    // 等待后直接查询返回（前面的请求已经插入或找到了文档）
    return db.collection('yourCollection').findOne({ xyz: targetXYZ });
  }

  // 创建一个Promise作为锁
  let resolveLock;
  const lockPromise = new Promise(resolve => {
    resolveLock = resolve;
  });
  processingLocks.set(targetXYZ, lockPromise);

  try {
    const existingDoc = await db.collection('yourCollection').findOne({ xyz: targetXYZ });
    if (existingDoc) {
      return existingDoc;
    }
    const newDoc = await db.collection('yourCollection').insertOne({ 
      xyz: targetXYZ,
      createdAt: new Date()
      // ... 其他字段
    });
    return newDoc.ops[0];
  } finally {
    // 释放锁
    resolveLock();
    processingLocks.delete(targetXYZ);
  }
}

这个方案最简单，但只适合单实例，如果是多实例部署（比如PM2集群、容器化多实例），内存锁不互通会失效，需注意适用场景。

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