前情提要,当内存空间不足的时候,JVM 就会触发垃圾回收机制,对垃圾对象进行回收,清理出足够的内存空间,存放新的对象。那么,JVM 是怎么识别垃圾对象的?判断的标准是什么?接下来,让我们一起带着问题,去寻找答案吧!
引用计数法
何为垃圾?没用的、不需要的东西就是垃圾。
在代码的世界也是如此,当对象 不被引用 的时候,我们就可以认为,这就是一个垃圾对象。那么,有什么办法可以识别哪些对象不被引用呢?
最简单办法,就是对实例对象被引用的次数做一个记录,具体实现方式就是在对象头中增加了一个计数器属性。
◉ 当有一个引用指向实例对象,则引用计数器+1。
◉ 当有一个引用不再指向实例对象,则引用计数器-1。
◉ 当实例对象的引用计数器为0,那么它就是垃圾对象。
这个方法很简单,标记垃圾对象的效率高。
然而,引用计数有一个致命的缺点:循环引用,即实例对象的引用链形成闭环。这种情况,相当于我捉住你,你捉住我,我们彼此都不松开,只能一直维持现状,停留在原地,哪儿都去不了。
这导致实例对象的引用计数器永远都不为 0,意味着实例对象永远都不会被标记为垃圾对象,所占有的内存得不到释放,这就产生了 内存泄露。
下面用一段代码,进行例子说明:
// 创建实例A,且 a 引用实例A
// 实例A的引用计数+1 = 1
A a = new A();
// 创建实例B,且 b 引用实例B
// 实例B的引用计数器+1 = 1
B b = new B();
// a.instance 实际上是引用实例B
// 实例B的引用计数器+1 = 2
a.instance = b;
// b.instance 实际上是引用实例A
// 实例A的引用计数器+1 = 2
b.instance = a;
/** 至此,实例A 和 实例B 形成循环引用 **/
// 当 a 不再引用实例A
// 实例A的引用计数器-1 = 1
a = null;
// 当 b 不再引用实例B
// 实例B的引用计数器-1 = 1
b = null;
至此,实例A 和 实例B 的引用计数都不为0,而且,由于两个实例依然存在彼此的引用 且 无法取消引用,那么两个实例的引用计数器都无法归零,因此在采用引用计数法的场景下,两个实例占有的内存都将得不到释放,造成了内存泄漏。
配合两张内存空间的图片,方便大家理解。
![](https://i-blog.csdnimg.cn/blog_migrate/cb4d65503889c448841ffdeeb20a0c44.png)
![](https://i-blog.csdnimg.cn/blog_migrate/6d6fb29ba4a4041c930ee7e351d57667.png)
可达性算法
目前主流的虚拟机采用的都是 可达性算法(GC Roots Tracing),这个算法的核心是利用一系列 根对象(GC Roots)作为起始点,根据对象之间的引用关系搜索出一条 引用链(Reference Chain),通过 遍历 引用链来判断对象的是否存活。
如果对象不在任何一条 引用链,即这个对象没有被任何一个 GC Roots 相连,说明这个对象 不可达,那么将会被判定为可回收的垃圾对象。
举个例子,假设 GC Roots 就是迷宫的起点,每个实例对象 就是一块区域,引用链 就是通往各个区域的路线。那些没有任何一条路线可以到达的区域就是可回收的垃圾对象,因为不能到达的区域,并没有任何的意义,只能是浪费空间罢了。
那么,GC Roots 是什么呢?
◉ 虚拟机栈(栈帧的局部变量表)中的引用。
◉ 方法区中类静态属性引用。
◉ 方法区中常量引用。
◉ 本地方法栈JNI(Native方法)引用。
下面分别用几段代码,进行例子说明:
虚拟机栈(栈帧的局部变量表)中的引用
public class Demo {
public static void main(String[] args) {
// 创建实例A
// a1:就是虚拟机栈(栈帧的局部变量表)中引用
A a1 = new A();
// 当 a1 不再指向实例A的时候,实例A 将不可达
a1 = null;
}
}
方法区中类静态属性引用
public class Demo {
// 创建实例A
// a2:方法区中类静态属性引用
public static A a2 = new A();
public static void main(String[] args) {
// 当 a2 不再指向实例A的时候,实例A 将不可达
a2 = null;
}
}
方法区中常量引用
public class Demo {
// 创建实例A
// a3:方法区中常量引用
public static final A a3 = new A();
public static void main(String[] args) {
// 当 a3 不再指向实例A的时候,实例A 将不可达
a3 = null;
}
}
本地方法栈JNI(Native方法)引用
// 访问 java 的构造方法
JNIEXPORT jobject JNICALL Java_com_test_Demo_accessConstructor
(JNIEnv * env, jobject jobj) {
// 通过类的路径从 JVM 找到 A 类
// a4:本地方法栈JNI(Native方法)引用
jclass a4 = (*env)->FindClass(env, "java/test/A");
jmethodID jmid = (*env)->GetMethodID(env, jc, "<init>", "()V");
// 通过 NewObject 实例化,创建实例A
jobject date_obj = (*env)->NewObject(env, jc,jmid);
return date_obj;
}
配合一张内存空间的图片,方便大家理解。
![](https://i-blog.csdnimg.cn/blog_migrate/1bab25291464f26e2ffc1197dc836bf0.png)
再说一句
以上的内容,简单讲述了 JVM 标记垃圾对象的两个方法:引用计数法 和 可达性算法。其中,引用计数法 我们只需要简单了解,可达性算法 才是目前主流虚拟机所采用的算法。
然而,可达性算法 在真正实现的场景下,有什么值得深入了解的地方呢?例如:如何枚举 GC Roots?GC Roots 向下遍历的优化?并发场景下标记对象会有存在什么问题?学无止境,这里挖一个坑,后面将会带大家深入了解这些问题,敬请期待。