深入理解V8引擎的内存管理：新生代、老生代、标记-清除和分代回收的底层工作原理。 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

V8 引擎内存管理深度剖析：新生代、老生代、标记-清除与分代回收

大家好，今天我们来深入探讨 V8 引擎的内存管理机制。V8 引擎作为 Chrome 和 Node.js 的核心引擎，其内存管理效率直接影响着应用的性能。理解 V8 的内存管理，能够帮助我们编写更高效的代码，避免内存泄漏，并更好地进行性能优化。

V8 的内存管理主要依赖于垃圾回收机制 (Garbage Collection, GC)。它负责自动回收不再使用的内存，释放资源，防止程序因内存耗尽而崩溃。V8 的 GC 采用分代回收策略，将内存划分为不同的区域，并针对不同区域采用不同的回收算法。

1. 内存空间划分：新生代与老生代

V8 的堆内存主要分为两个大的区域：新生代 (Young Generation) 和老生代 (Old Generation)。这种划分基于一个重要的观察：大部分对象在创建后很快就会变得不可访问，只有少部分对象会长期存活。

新生代 (Young Generation): 用于存放新创建的对象。这个区域的特点是空间较小，垃圾回收频率高。新生代又进一步划分为两个小的半空间 (semispace)：From Space 和 To Space。
老生代 (Old Generation): 用于存放经过多次新生代垃圾回收后仍然存活的对象。这个区域的空间较大，垃圾回收频率较低。老生代也分为两个区域：老对象区 (Old Object Space) 和大对象区 (Large Object Space)。老对象区存放大小适中的对象，大对象区存放体积较大的对象，比如字符串或数组。

下面用一个表格总结一下：

区域	描述	回收频率
新生代	存放新创建的对象，分为 From Space 和 To Space	高
老生代	存放经过多次新生代垃圾回收仍然存活的对象，分为老对象区和大对象区	低
From Space	新生代中的一个半空间，用于存放正在使用的对象。当进行新生代垃圾回收时，From Space 中的存活对象会被复制到 To Space
To Space	新生代中的另一个半空间，始终处于空闲状态。当进行新生代垃圾回收时，From Space 中的存活对象会被复制到 To Space，然后 From Space 和 To Space 的角色互换
老对象区	老生代中存放大小适中的对象
大对象区	老生代中存放体积较大的对象，例如字符串或数组。大对象通常不会被移动，因为移动它们的成本很高

2. 新生代垃圾回收：Scavenge 算法

新生代的垃圾回收采用 Scavenge 算法，也称为 Cheney 算法。这个算法的核心思想是：将内存空间分为两个半空间，每次只使用其中一个，另一个始终处于空闲状态。

Scavenge 算法的工作流程如下：

分配对象到 From Space: 新创建的对象首先被分配到 From Space。
扫描根对象: 当 From Space 空间快要用完时，触发新生代垃圾回收。GC 会扫描根对象 (例如全局对象、函数调用栈中的变量等)。
复制存活对象到 To Space: 从根对象开始，GC 遍历 From Space 中的所有对象，如果对象仍然可达 (即被根对象或其它存活对象引用)，则将该对象复制到 To Space。
角色互换: From Space 中不再被引用的对象会被直接释放。然后，From Space 和 To Space 的角色互换。原来的 To Space 变成新的 From Space，原来的 From Space 变成新的 To Space，等待下一次垃圾回收。

代码示例 (模拟 Scavenge 算法):

class Memory {
  constructor(size) {
    this.size = size;
    this.fromSpace = new Array(size).fill(null);
    this.toSpace = new Array(size).fill(null);
    this.fromSpacePointer = 0;
  }

  allocate(obj) {
    if (this.fromSpacePointer + 1 > this.size) {
      return null; // From Space 已满
    }
    this.fromSpace[this.fromSpacePointer] = obj;
    this.fromSpacePointer++;
    return this.fromSpacePointer - 1; // 返回对象在 From Space 中的索引
  }

  gc(roots) {
    // 复制存活对象到 To Space
    const toSpaceMap = new Map(); // 记录对象在 To Space 中的新位置
    let toSpacePointer = 0;

    const copyObject = (index) => {
      if (toSpaceMap.has(index)) {
        return toSpaceMap.get(index); // 对象已复制，直接返回新位置
      }

      const obj = this.fromSpace[index];
      if (!obj) {
        return null; // 对象已被回收
      }

      this.toSpace[toSpacePointer] = obj;
      toSpaceMap.set(index, toSpacePointer);
      const newIndex = toSpacePointer;
      toSpacePointer++;
      return newIndex;
    };

    const updateReferences = (obj) => {
      // 模拟更新对象内部的引用
      if (obj && obj.children) {
        for (let i = 0; i < obj.children.length; i++) {
          const oldIndex = obj.children[i];
          if (oldIndex !== null && oldIndex !== undefined) {
            obj.children[i] = copyObject(oldIndex);
          }

        }
      }
    };

    // 扫描根对象并复制
    const newRoots = roots.map(index => copyObject(index));

    // 更新所有复制对象的引用 (模拟深度复制)
    for (let i = 0; i < toSpacePointer; i++) {
        updateReferences(this.toSpace[i]);
    }

    // 清空 From Space
    this.fromSpace = new Array(this.size).fill(null);

    // 角色互换
    const temp = this.fromSpace;
    this.fromSpace = this.toSpace;
    this.toSpace = temp;

    this.fromSpacePointer = toSpacePointer; // 更新 From Space 指针

    return newRoots; //返回新的根节点位置
  }
}

// 示例用法
class MyObject {
  constructor(name) {
    this.name = name;
    this.children = []; // 模拟对象间的引用
  }
}

const memory = new Memory(10);

// 创建一些对象
const obj1 = new MyObject("Object 1");
const obj2 = new MyObject("Object 2");
const obj3 = new MyObject("Object 3");

// 分配对象到 From Space
const index1 = memory.allocate(obj1);
const index2 = memory.allocate(obj2);
const index3 = memory.allocate(obj3);

// 创建对象间的引用
obj1.children = [index2, index3];
obj2.children = [index3];

// 设置根对象
let roots = [index1];

console.log("Before GC:");
console.log("From Space:", memory.fromSpace);
console.log("To Space:", memory.toSpace);

// 执行垃圾回收
roots = memory.gc(roots);

console.log("nAfter GC:");
console.log("From Space:", memory.fromSpace);
console.log("To Space:", memory.toSpace);
console.log("New Roots:", roots); // 打印新的根对象位置

Scavenge 算法的优点：

高效: 每次只处理 From Space 中的存活对象，速度快。
简单: 算法逻辑简单，易于实现。

Scavenge 算法的缺点：

空间浪费: 需要两个大小相同的半空间，浪费一半的内存空间。
不适合老生代: 对于存活对象较多的情况，复制成本较高，不适合老生代。

3. 老生代垃圾回收：Mark-Sweep & Mark-Compact

老生代由于空间较大，且对象存活时间较长，因此不能采用 Scavenge 算法。V8 主要采用 Mark-Sweep (标记-清除) 和 Mark-Compact (标记-整理) 两种算法来回收老生代的垃圾。

3.1 Mark-Sweep (标记-清除) 算法:

Mark-Sweep 算法分为两个阶段：

标记 (Mark): 从根对象开始，遍历所有可达对象，并将其标记为 "存活"。
清除 (Sweep): 扫描整个堆内存，将没有被标记为 "存活" 的对象回收，释放其占用的内存。

代码示例 (模拟 Mark-Sweep 算法):

class MarkSweepMemory {
  constructor(size) {
    this.size = size;
    this.memory = new Array(size).fill(null);
    this.marks = new Array(size).fill(false); // 用于标记对象是否存活
    this.allocationCount = 0;
  }

  allocate(obj) {
    if (this.allocationCount >= this.size) {
      return null; // 内存已满
    }
    this.memory[this.allocationCount] = obj;
    const index = this.allocationCount;
    this.allocationCount++;
    return index;
  }

  mark(roots) {
    const markRecursive = (index) => {
      if (index === null || index === undefined || index < 0 || index >= this.size) {
        return;
      }
      if (this.marks[index]) {
        return; // 已经标记过
      }

      this.marks[index] = true;
      const obj = this.memory[index];
      if (obj && obj.children) {
        for (const childIndex of obj.children) {
          markRecursive(childIndex);
        }
      }
    };

    for (const rootIndex of roots) {
      markRecursive(rootIndex);
    }
  }

  sweep() {
    let freed = 0;
    for (let i = 0; i < this.size; i++) {
      if (!this.marks[i]) {
        // 对象未被标记，回收
        this.memory[i] = null;
        freed++;
      }
    }
    // 重置标记
    this.marks = new Array(this.size).fill(false);
    return freed;
  }

  gc(roots) {
    this.mark(roots);
    const freed = this.sweep();
    return freed;
  }
}

// 示例用法
class MarkSweepObject {
  constructor(name) {
    this.name = name;
    this.children = [];
  }
}

const markSweepMemory = new MarkSweepMemory(10);

const obj1 = new MarkSweepObject("Object 1");
const obj2 = new MarkSweepObject("Object 2");
const obj3 = new MarkSweepObject("Object 3");

const index1 = markSweepMemory.allocate(obj1);
const index2 = markSweepMemory.allocate(obj2);
const index3 = markSweepMemory.allocate(obj3);

obj1.children = [index2, index3];
obj2.children = [index3];

const roots = [index1];

console.log("Before GC:");
console.log("Memory:", markSweepMemory.memory);

const freed = markSweepMemory.gc(roots);

console.log("nAfter GC:");
console.log("Memory:", markSweepMemory.memory);
console.log("Freed:", freed);

Mark-Sweep 算法的优点：

不需要移动对象: 回收过程中不需要移动对象，减少了开销。
空间利用率高: 没有空间浪费。

Mark-Sweep 算法的缺点：

内存碎片: 回收后会产生大量的内存碎片，导致后续分配大对象时可能失败。
暂停时间较长: 需要扫描整个堆内存，暂停时间较长。

3.2 Mark-Compact (标记-整理) 算法:

Mark-Compact 算法是在 Mark-Sweep 算法的基础上进行的改进，它在清除阶段会进行内存整理，消除内存碎片。

Mark-Compact 算法分为三个阶段：

标记 (Mark): 与 Mark-Sweep 算法相同，标记所有可达对象。
整理 (Compact): 将所有存活对象移动到内存的一端，空出另一端连续的内存空间。
更新指针: 由于对象的位置发生了改变，需要更新所有指向这些对象的指针。

代码示例 (模拟 Mark-Compact 算法):

class MarkCompactMemory {
  constructor(size) {
    this.size = size;
    this.memory = new Array(size).fill(null);
    this.marks = new Array(size).fill(false);
    this.allocationCount = 0;
  }

  allocate(obj) {
    if (this.allocationCount >= this.size) {
      return null; // 内存已满
    }
    this.memory[this.allocationCount] = obj;
    const index = this.allocationCount;
    this.allocationCount++;
    return index;
  }

  mark(roots) {
    const markRecursive = (index) => {
      if (index === null || index === undefined || index < 0 || index >= this.size) {
        return;
      }
      if (this.marks[index]) {
        return; // 已经标记过
      }

      this.marks[index] = true;
      const obj = this.memory[index];
      if (obj && obj.children) {
        for (const childIndex of obj.children) {
          markRecursive(childIndex);
        }
      }
    };

    for (const rootIndex of roots) {
      markRecursive(rootIndex);
    }
  }

  compact() {
    let freeIndex = 0; // 指向空闲位置
    const relocationMap = new Map(); // 存储对象的新位置

    // 移动存活对象
    for (let i = 0; i < this.size; i++) {
      if (this.marks[i]) {
        // 对象存活，移动到空闲位置
        if (i !== freeIndex) {
          this.memory[freeIndex] = this.memory[i];
          this.memory[i] = null; // 清空原位置
          relocationMap.set(i, freeIndex); // 记录对象的新位置
        }
        freeIndex++;
      }
    }

    // 更新引用
    for (let i = 0; i < freeIndex; i++) {
      const obj = this.memory[i];
      if (obj && obj.children) {
        for (let j = 0; j < obj.children.length; j++) {
          const oldIndex = obj.children[j];
          if (relocationMap.has(oldIndex)) {
            obj.children[j] = relocationMap.get(oldIndex); // 更新引用
          }
        }
      }
    }

    // 重置标记
    this.marks = new Array(this.size).fill(false);
    this.allocationCount = freeIndex; // 更新 allocationCount
  }

  gc(roots) {
    this.mark(roots);
    this.compact();
  }
}

// 示例用法
class MarkCompactObject {
  constructor(name) {
    this.name = name;
    this.children = [];
  }
}

const markCompactMemory = new MarkCompactMemory(10);

const obj1 = new MarkCompactObject("Object 1");
const obj2 = new MarkCompactObject("Object 2");
const obj3 = new MarkCompactObject("Object 3");

const index1 = markCompactMemory.allocate(obj1);
const index2 = markCompactMemory.allocate(obj2);
const index3 = markCompactMemory.allocate(obj3);

obj1.children = [index2, index3];
obj2.children = [index3];

const roots = [index1];

console.log("Before GC:");
console.log("Memory:", markCompactMemory.memory);

markCompactMemory.gc(roots);

console.log("nAfter GC:");
console.log("Memory:", markCompactMemory.memory);

Mark-Compact 算法的优点：

消除内存碎片: 整理内存，减少了内存碎片。
有利于分配大对象: 整理后的内存空间更加连续，有利于分配大对象。

Mark-Compact 算法的缺点：

需要移动对象: 回收过程中需要移动对象，开销较大。
需要更新指针: 对象移动后需要更新所有指向这些对象的指针，增加了复杂性。
暂停时间较长: 同样需要扫描整个堆内存，暂停时间较长。

4. 增量标记 (Incremental Marking)

为了减少垃圾回收造成的暂停时间，V8 引入了增量标记技术。增量标记将标记过程分解为多个小步骤，每次只标记一部分对象，然后暂停，让 JavaScript 代码执行一段时间，然后再继续标记。这样可以避免一次性扫描整个堆内存，从而减少暂停时间。

增量标记并不是一种独立的垃圾回收算法，而是对 Mark-Sweep 和 Mark-Compact 算法的优化。

5. 写屏障 (Write Barrier)

在增量标记过程中，由于 JavaScript 代码可能在垃圾回收器暂停期间修改对象的引用关系，导致垃圾回收器无法正确标记存活对象。为了解决这个问题，V8 引入了写屏障技术。

写屏障是在修改对象引用关系时执行的一段代码，用于通知垃圾回收器对象引用关系的变化。这样，垃圾回收器就可以在后续的标记过程中正确处理这些变化。

6. 分代回收的优势

分代回收策略的优势在于：

针对性优化: 针对不同区域的对象特点，采用不同的回收算法，提高了垃圾回收的效率。
减少暂停时间: 通过频繁回收新生代，可以快速回收大部分垃圾，减少老生代的回收频率，从而减少了暂停时间。

7. 总结

V8 引擎的内存管理是一个复杂但精妙的系统。通过分代回收、Scavenge 算法、Mark-Sweep & Mark-Compact 算法、增量标记和写屏障等技术，V8 能够高效地管理内存，减少垃圾回收造成的性能影响。理解这些底层原理，有助于我们编写更高效的 JavaScript 代码，避免内存泄漏，并更好地进行性能优化。

V8 内存管理的要点回顾

V8 的内存管理依赖于分代垃圾回收机制，将内存划分为新生代和老生代，并采用不同的算法进行垃圾回收。新生代使用 Scavenge 算法，老生代使用 Mark-Sweep 和 Mark-Compact 算法。为了减少垃圾回收造成的暂停时间，V8 还引入了增量标记和写屏障等技术。

编写高效 JavaScript 代码的建议

尽量避免创建不必要的对象。
及时释放不再使用的对象。
避免全局变量，减少根对象的数量。
注意闭包的使用，避免意外的内存泄漏。
使用性能分析工具，找出代码中的性能瓶颈。