JavaScript堆内存不足-插入mongodb时出错

Question

我想在 MongoDB 中插入 1500000 个文档。首先，我查询一个数据库并从那里获取 15000 名教师的列表，我想为每个教师插入 100 门课程。

我运行了两个循环：首先它遍历所有讲师，其次，在每次迭代中，它将为该 ID 插入 100 个文档，如下面的代码所示：

const instructors = await Instructor.find();
//const insrtuctor contains 15000 instructor
instructors.forEach((insructor) => {
    for(let i=0; i<=10; i++) {
        const course = new Course({
            title: faker.lorem.sentence(),
            description: faker.lorem.paragraph(),
            author: insructor._id,
            prise: Math.floor(Math.random()*11),
            isPublished: 'true',
            tags: ["java", "Nodejs", "javascript"]
        });
        course.save().then(result => {
            console.log(result._id);
            Instructor.findByIdAndUpdate(insructor._id, { $push: { courses: course._id } })
            .then(insructor => {
                console.log(`Instructor Id : ${insructor._id} add Course : ${i} `);
            }).catch(err => next(err));
            console.log(`Instructor id: ${ insructor._id } add Course: ${i}`)
        }).catch(err => console.log(err));
    }
});

这是我的package.json 文件，我在其中放置了我在互联网上找到的东西：

{
    "scripts": {
        "start": "nodemon app.js",
        "fix-memory-limit": "cross-env LIMIT=2048 increase-memory-limit"
    },
    "devDependencies": {
        "cross-env": "^5.2.0",
        "faker": "^4.1.0",
        "increase-memory-limit": "^1.0.6",
    }
}

这是我的课程模型定义

const mongoose = require('mongoose');

const Course = mongoose.model('courses', new mongoose.Schema({

title: {
    type: String,
    required: true,
    minlength: 3
},
author: {
    type: mongoose.Schema.Types.ObjectId,
    ref: 'instructor'
},
description: {
    type: String,
    required: true,
    minlength: 5
},
ratings: [{
    user: {
        type: mongoose.Schema.Types.ObjectId,
        ref: 'users',
        required: true,
        unique: true
    },
    rating: {
        type: Number,
        required: true,
        min: 0,
        max: 5
    },
    description: {
        type: String,
        required: true,
        minlength: 5
    }
}],
tags: [String],
rating: {
    type: Number,
    min: 0,
    default: 0
},
ratedBy: {
    type: Number,
    min: 0,
    default: 0
},
prise: {
    type: Number,
    required: function() { this.isPublished },
    min: 0
},
isPublished: {
    type: Boolean,
    default: false
}
}));

module.exports = Course;

Answer 1

对于大量 数据，您必须使用光标。

想法是处理文档尽快，因为您从数据库获得一个。

就像您要求 db 给指导员，并且 db 发回小批量，然后您使用该批次操作并处理它们直到达到所有批次的结束。

否则await Instructor.find()将加载所有数据内存并填充 实例带有你不需要的猫鼬方法。

即使await Instructor.find().lean() 也不会给内存带来好处。

光标是 mongodb 的功能，当你在收集时执行find。

使用 mongoose 可以使用：Instructor.collection.find({})

观看this video。

下面我写了使用游标批量处理数据的解决方案。

在模块内的某处添加这个：

const createCourseForInstructor = (instructor) => {
  const data = {
    title: faker.lorem.sentence(),
    description: faker.lorem.paragraph(),
    author: instructor._id,
    prise: Math.floor(Math.random()*11), // typo: "prise", must be: "price"
    isPublished: 'true',
    tags: ["java", "Nodejs", "javascript"]
  };
  return Course.create(data);
}

const assignCourseToInstructor = (course, instructor) => {
  const where = {_id: instructor._id};
  const operation = {$push: {courses: course._id}};
  return Instructor.collection.updateOne(where, operation, {upsert: false});
}

const processInstructor = async (instructor) => {
  let courseIds = [];
  for(let i = 0; i < 100; i++) {
    try {
      const course = await createCourseForInstructor(instructor)
      await assignCourseToInstructor(course, instructor);
      courseIds.push(course._id);
    } 
    catch (error) {
      console.error(error.message);
    }
  }
  console.log(
    'Created ', courseIds.length, 'courses for', 
    'Instructor:', instructor._id, 
    'Course ids:', courseIds
  );
};

并在您的异步块中将您的循环替换为：

const cursor = await Instructor.collection.find({}).batchSize(1000);

while(await cursor.hasNext()) {
  const instructor = await cursor.next();
  await processInstructor(instructor);
}

附：我使用原生 collection.find 和 collection.updateOne 来实现 性能 以 避免 mongoose 将 extra heap 用于 mongoose 方法和字段 on模型实例。

奖励：

即使如果 使用这个光标解决方案您的代码也会内存不足问题再次, run 你的代码就像这个例子一样（根据服务器的内存定义大小，以兆字节为单位）：

nodemon --expose-gc --max_old_space_size=10240 app.js

Answer 2

原因是您没有等待save 返回的承诺，而是立即继续for 和forEach 循环的下一次迭代。这意味着您正在启动大量（待处理的）save 操作，这确实会增加 mongodb 库的内存使用量。

在继续下一次迭代之前，最好等待save（和链接的findByIdAndUpdate）解决。

由于您显然处于async 函数上下文中，因此您可以为此使用await，前提是您将forEach 循环替换为for 循环（以便您保持在相同的函数上下文中） ：

async function yourFunction() {
    const instructors = await Instructor.find();
    for (let instructor of instructors) { // Use `for` loop to allow for more `await`
        for (let i=0; i<10; i++) { // You want 10 times, right?
            const course = new Course({
                title: faker.lorem.sentence(),
                description: faker.lorem.paragraph(),
                author: instructor._id,
                prise: Math.floor(Math.random()*11),
                isPublished: 'true',
                tags: ["java", "Nodejs", "javascript"]
            });
            const result = await course.save();
            console.log(result._id);
            instructor = await Instructor.findByIdAndUpdate(instructor._id, { $push: { courses: course._id } });
            console.log(`Instructor Id : ${instructor._id} add Course : ${i}`);
        }
    }
}

现在所有的save 操作都被序列化了：下一个只有在前一个完成后才开始。

请注意，我没有包括您的错误处理：最好使用链接到此 async 函数调用的 catch 调用来完成。