JVM 的垃圾回收机制 GC

C/C++ 这样的编程语言中,申请内存的时候,是需要用完了,进行手动释放的

C 申请内存

1)局部变量(不需要手动释放)

2)全局变量(不需要手动释放)

3)动态申请 malloc(通过 free 进行释放的)

C++ 申请内存

1)局部变量

2)全局变量/静态变量

3)动态申请 new 通过 delete 进行释放

上面的释放操作,是很容易遗忘的(执行不到),就会导致内存泄漏

很多编程语言,引入了 垃圾回收机制

不需要程序员写代码手动释放,会有专门的逻辑,帮助自动释放

垃圾回收,大大的解放了程序员,提高了开发效率

Java, Python,Go,PHP,JS 大多数主流语言都包含了GC功能

为啥C/C++ 没有引入 GC 呢?

C++ 的设计核心理念,有两个(C++的红线)

1)和 C 兼容(C语言写的代码,用 C++ 的编译器可以正常编译运行的)

2)把性能发挥到极致

引入 GC 会影响性能,引入了额外的运行时开销

GC 会影响执行效率

触发 GC 的时候,可能会涉及到 STW 问题,(stop the world 世界都停止),(GC 这样的"扫地"操作,就需要其他工作线程"抬脚",抬脚就无法继续工作了)

1.GC 回收的内存区域是哪个部分呢?

JVM

程序计数器

元数据区

栈

堆  => 主要是回收这个区域

2.GC 的目的是为了释放内存,是字节为单位"释放"的吗?

不是的,以"对象为单位"

按照对象为维度进行回收,更简单方便

如果是按照"字节维度",就可能针对每个对象都得描述出那部分需要回收,那部分不需要回收,比较麻烦了

堆上的内存 => new 的对象

3.如何回收?

1)找出垃圾,区分哪些对象是垃圾(后续代码不在使用)

2)释放这些垃圾对象的内存

如何"找出垃圾"(后续代码不在使用)

在 Java 使用对象,都是通过"引用"来进行的

使用对象,无非是使用的对象的属性/方法,都要通过 . 来进行 . 前面的部分就是指向对象的引用

如果一个对象以及没有任何引用指向它了,此时这个对象就注定无法使用了

判定一个对象是否是垃圾(抽象)

判定一个对象是是否有引用指向这个对象(具体,JVM 内部是有些办法可以做到的)

1.引用计数(Java 中没有使用,Python,PHP.. 采用的方案)

简单粗暴的方案

给每个对象都分配一个"计数器"

Python / PHP 等语言会搭配其他的算法机制,识别当前的引用是否构成循环引用

两个弊端

1)消耗额外的内存空间较大

        如果对象本身就很小(就 4 个字节)

        计数器占俩字节,相当于额外的内存空间多了 50%

2)循环引用问题(类似于死锁)

class Test {Test t;
}
Test a = new Test();
Test b = new Test();

class Test {Test t;
}
Test a = new Test();
Test b = new Test();a.t = b;
b.t = a;a = null;
b = null;

此时,这俩对象的引用计数是 1,不能释放.

但是,这俩对象却无法通过如何引用来访问到( A B 相互证明对方不是垃圾,实际上 AB 都是垃圾)

2.可达性分析(Java 的使用方案)

在 Java 代码中,每个"可访问的对象"一定是可以通过引用操作访问到的

JVM 安排专门的线程,负责上述的"扫描"的过程,会从一些特殊的引用开始扫描(GC roots)

1.栈上的局部变量(引用类型)

2.常量池里面指向的对象(final 修饰的,引用类型)

3.元数据区 (静态成员,引用类型)

这三组里面可能有很多变量,以这些变量为起点,尽可能的往里访问所有可能被访问到的对象

但凡是可以被访问到的对象,都"标记为可达"

JVM 又能知道所有的对象列表,去掉"标记为可达的",剩下的就是垃圾了

Node build() {Node a = new Node();Node b = new Node(); Node c = new Node();Node d = new Node();Node e = new Node();Node f = new Node();Node g = new Node();a.left = b;a.right = c;b.left = d;b.right = e;e.left = g;c.right = f;return a;
}

Node root = build();

此时通过 root 这个引用,是可以访问到这个树上的如何一个对象的

假设,写 root.right.right = null;

这样的代码会使 f 无法被访问到 (f 已经没有引用指向了)

假设,写 root.right = null

这样的代码会使 c 不可达,由于 f 必须依赖 c, f 也一起不可达

这种方法,不需要引入额外的内存空间,但是需要消耗较多的时间,进行上述的扫描过程,这些扫描过程中也是容易触发 STW 的(时间换了空间),这里也不会涉及到"循环引用"

如何释放垃圾(回收内存)

关于内存回收,涉及到几种算法

1.标记 - 清除

标记,就是可达性分析,找到垃圾的过程

清除,直接释放这部分的内存(相当于直接调用 free / delete 释放这个内存给操作系统)

存在内存碎片问题

总的空闲内存空间,是比较多的 (一共3MB),但是这些空闲的内存空间,不连续

在申请内存的时候,都是在申请连续的内存空间,当尝试申请 2MB 的内存时候,就会申请失败

2.复制算法,解决内存碎片

被红钩选择中的是"垃圾"

把不是垃圾的对象,复制到另外一侧,把整个空间都释放掉

很好的解决了内存碎片的问题

弊端

        1.内存浪费比较多

        2.如果存活的对象比较多/比较大,复制的开销是非常明显的

3.标记 - 整理

类似于顺序表删除元素 - 搬运元素

这个方案,能够解决内存碎片,也能避免负责算法的内存浪费,但是,搬运对象的成本也可能会比较高

4.分代回收(综合方案),把上述的几个方案,结合起来,扬长避短

整个堆空间,分成"新生代","老年代"

年龄:一个对象经过垃圾回收扫描线程的轮次

可达性分析中,JVM 会不停地使用线程扫描这些对象是否是垃圾,每隔一定的时间,就会扫描一次,如果一个对象扫描一次,不是垃圾,年龄就 + 1,一般来说年龄超过 15(可以配)的就进入老年代

对于年轻对象来说,是容易成为垃圾的,年老对象,着不容易成为垃圾

"要死早死了"

比如 C 语言,已经存在了50年了,还可以预见这个 C 语言还有很大的希望在活50年,和 C 语言同时期的语言,都死的差不多了

针对新新生代,老年代,不同的特点,就可以采用不同的方案了

刚创建的新对象,放到伊甸区

如果对象活过一轮 GC,进入幸存区(通过复杂算法)

新对象,大多数是生命周期非常低的"朝生夕死"

这俩幸存区,同一时刻使用一个(相当于是复杂算法,分出两个部分)

每次经过一轮 GC 都会淘汰掉幸存区中的一大部分对象,把存活的对象和伊甸区中新存活下来的对象,负责算法拷贝到另一个幸存区(新生代是非常适合负责算法的)

如果这个对象在新生代中存活多轮之后,就会进入老老年代

老年代的对象由于生命周期大概率是很长的,没有必要频繁扫描

如果这个对象是非常大的,不适合使用负责算法,直接进入老年代

老年代回收内存采取的是 标记 - 清除 / 标记 - 整理(取决于垃圾回收的具体算法实现了)