通常来说,内存管理有两种方式,一种是手动管理,一种是自动管理。

手动管理需要开发者自己管理内存,什么时候申请内存空间,什么时候释放都需要小心处理,否则容易形成内存泄漏和指针乱飞的局面。C 语言开发是典型的需要手动管理内存的例子。

自动管理通常通过垃圾回收的机制来实现内存管理。NodeJS 中的内存管理是自动管理的。

垃圾回收

垃圾回收器(garbage collector,GC)通过判断对象是否还在被其他对象引用来决定是否回收该对象的内存空间。

垃圾回收之前的内存

在下面的图中,有一些对象还在被其他对象使用,而有一些对象已经是完全孤立状态,没有其他对象使用它了。这些已经完全孤立状态的对象是可以被垃圾回收器回收的。

垃圾回收之前的内存

垃圾回收之后的内存

垃圾回收一旦开始运行,内存中的那些完全孤立(不可到达)的对象会被删除,内存空间会被释放。

垃圾回收之后的内存

垃圾回收是如何工作的

要搞清楚垃圾回收是如何工作的,需要先了解一些基本概念。

基本概念

  • 常驻集大小(resident set size):NodeJS 进程运行时占据的内存大小,通常包含:代码、栈和堆。

  • 栈(stack):包含原始类型数据和指向对象的引用数据。

    栈中保存着局部变量和指向堆上对象的指针或定义应用程序控制流的指针(比如函数调用等)。

    下面代码中,ab 都保存在栈中。

    function add (a, b) {
      return a + b
    }
    add(4, 5)
    
    1
    2
    3
    4
  • 堆(heap):存放引用类型数据,比如对象、字符串、闭包等。

    下面代码中,创建的 Car 对象会被保存在堆中。

    function Car (opts) {
    this.name = opts.name
    }
    
    const LightningMcQueen = new Car({name: 'Lightning McQueen'})
    
    1
    2
    3
    4
    5

    对象创建后,堆内存状态如下:

    堆内存

    现在我们添加更多的对象:

    const SallyCarrera = new Car({name: 'Sally Carrera'})
    const Mater = new Car({name: 'Mater'})
    
    1
    2

    堆内存状态如下:

    堆内存

    如果现在执行垃圾回收,没有任何内存会被释放,因为每个对象都在被使用(可到达)。

    现在我们修改代码,如下:

    function Engine (power) {
    this.power = power
    }
    
    function Car (opts) {
    this.name = opts.name
    this.engine = new Engine(opts.power)
    }
    
    let LightningMcQueen = new Car({name: 'Lightning McQueen', power: 900})
    let SallyCarrera = new Car({name: 'Sally Carrera', power: 500})
    let Mater = new Car({name: 'Mater', power: 100})
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12

    堆内存状态变成:

    堆内存

    如果我们不在使用 Mater 的话,通过 Mater = undefined 删除了对内存中对象的引用,则内存状态变化为:

    堆内存

    此时内存中的 Mater 不再被其他对象使用了(不可达),当垃圾回收运行的时候,Mater 对象会被回收,其占据的内存会被释放。

    堆内存

  • 对象的浅层大小(shallow size of an object):对象本身占据的内存大小。

  • 对象的保留大小(retained size of an object):删除对象及其依赖对象后释放的内存大小

垃圾回收器是如何工作的

NodeJS 的垃圾回收通过 V8 实现。大多数对象的生命周期都很短,而少数对象的寿命往往更长。为了利用这种行为,V8 将堆分成两个部分,年轻代(Young Generation)老年代(Old Generation)

年轻代

新的内存需求都在年轻代中分配。年轻代的大小很小,在 1 到 8 MB 之间。在年轻代中内存分配非常便宜,V8 在内存中会逐个为对象分配空间,当到达年轻代的边界时,会触发一次垃圾回收。

V8 在年轻代会采用 Scavenge 回收策略。Scavenge 采用复制的方式进行垃圾回收。它将内存一分为二,每一部分空间称为 semispace。这两个空间,只有一个空间处于使用中,另一个则处于闲置。使用中的 semispace 称为 「From 空间」,闲置的 semispace 称为 「To 空间」。

年轻代的内存分配过程如下:

  1. 从 From 空间分配对象,若 semispace 被分配满,则执行 Scavenge 算法进行垃圾回收。
  2. 检查 From 空间中的对象,若对象可到达,则检查对象是否符合提升条件,若符合条件则提升到老生代,否则将对象从 From 空间复制到 To 空间。
  3. 若对象不可到达,则释放不可到达对象的空间。
  4. 完成复制后,将 From 空间与 To 空间进行角色翻转(flip)。

在年轻代中幸存的对象会被提升到老年代。

老年代

老年代中的对象有两个特点,第一是存活对象多,第二个存活时间长。若在老年代中使用 Scavenge 算法进行垃圾回收,将会导致复制存活对象的效率不高,且还会浪费一半的空间。因此在老年代中,V8 通常采用 Mark-Sweep 和 Mark-Compact 策略回收。

Mark-Sweep 就是标记清除,它主要分为标记和清除两个阶段。

  • 标记阶段,将遍历堆中所有对象,并对存活的对象进行标记;
  • 清除阶段,对未标记对象的空间进行回收。

与 Scavenge 策略不同,Mark-Sweep 不会对内存一分为二,因此不会浪费空间。但是,经历过一次 Mark-Sweep 之后,内存的空间将会变得不连续,这样会对后续内存分配造成问题。比如,当需要分配一个比较大的对象时,没有任何一个碎片内支持分配,这将提前触发一次垃圾回收,尽管这次垃圾回收是没有必要的。

标记清除

为了解决内存碎片的问题,提高对内存的利用,引入了 Mark-Compact (标记整理)策略。Mark-Compact 是在 Mark-Sweep 算法上进行了改进,标记阶段与 Mark-Sweep 相同,但是对未标记的对象处理方式不同。与Mark-Sweep是对未标记的对象立即进行回收,Mark-Compact则是将存活的对象移动到一边,然后再清理端边界外的内存。

标记整理

由于 Mark-Compact 需要移动对象,所以执行速度上,比 Mark-Sweep 要慢。所以,V8 主要使用 Mark-Sweep 算法,然后在当空间内存分配不足时,采用 Mark-Compact 算法。

关注微信公众号,获取最新推送~