# 垃圾回收机制
JavaScript 中的内存管理是自动执行的，而且是不可见的。
# 垃圾?
- 没有被引用的对象
- 几个对象引用形成一个环,互相引用,但无法访问到
# 可达性
简单地说，“可达性” 值就是那些以某种方式可访问或可用的值，它们被保证存储在内存中
- 有一组基本的固有可达值，由于显而易见的原因无法删除
- 本地函数的局部变量和和参数
- 嵌套调用链上的其它函数的变量与参数
- 全局变量
- 其它的内部变量
这些值称为根。
- 如果引用或引用链可以从根访问任何其他值，则认为该值是可访问的
- 如果局部变量中有对象，并且该对象具有引用另一个对象的属性，则该对象被视为可达性，它引用的那些也是可以访问的
# 例子
- 单个对象的引用
let user = {name:'xiaoming'}
// user --> {name:'xiaoming'}
user = null
// user -x- {name:xiaoming}
// 回收
// 因为{name:'小明'} 无法再被访问到
1
2
3
4
5
6
7
8
2
3
4
5
6
7
8
- 两个对象引用同一个
let user1 = {name:'xiaoming'}
// user --> {name:'xiaoming'}
let user2 = {name:'xiaoming'}
// user1 --> {name:'xiaoming'} <-- user2
user1 = null
// user1 -x- {name:'xiaoming'} <-- user2
// 这里还可以通过user访问到{name:'xiaoming'} 所以不会回收
user2 = null
// user1 -x- {name:'xiaoming'} -x- user2
// 回收{name:'小明'}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
2
3
4
5
6
7
8
9
10
11
12
13
14
- 相互引用
function marray(woman, man) {
woman.husband = man
man.wife = woman
return {
male: man,
female: woman
}
}
let woman = { name: 'qq' }
// woman --> qq
let man = { name: 'tb' }
// man --> tb
let couple = marray(woman, man)
// couple --> male --> tb x qq <-- female <--couple
// tb x qq = tb -->wife --> qq qq --> husband -->tb
// 如果要回收 {name:'tb'}
man = null
// man -x- tb
couple.male = null
// couple --> male -x- tb
couple.female.husband = null
// qq --> husband -x- tb
console.log(couple)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
- 无法访问的数据块
let a = marray({name:'a'},{name:'b'})
a = null
// 直接回收数据块
1
2
3
4
2
3
4
# 总结
- 不具有可达性的块或值会被清理
# 内部算法
# 标记-清除算法
- 垃圾回收器获取根并“标记”(记住)它们。
- 然后它访问并“标记”所有来自它们的引用。
- 然后它访问标记的对象并标记它们的引用。所有被访问的对象都被记住，以便以后不再访问同一个对象两次。
- 以此类推，直到没有未访问的引用(能从根访问)为止。
- 除标记的对象外，其它对象都被删除。
# 优化
- 分代回收——对象分为两组:“新对象”和“旧对象”。许多对象出现，完成它们的工作并迅速结 ，它们很快就会被清理干净。那些活得足够久的对象，会变“老”，并且很少接受检查。
- 增量回收——如果有很多对象，并且我们试图一次遍历并标记整个对象集，那么可能会花费一些时间，并在执行中会有一定的延迟。因此，引擎试图将垃圾回收分解为多个部分。然后，各个部分分别执行。这需要额外的标记来跟踪变化，这样有很多微小的延迟，而不是很大的延迟。
- 空闲时间收集——垃圾回收器只在 CPU 空闲时运行，以减少对执行的可能影响。