原文:https://blog.csdn.net/u010798968/article/details/72835255

一、名词解释

根搜索算法是JVM用来的判断对象是否存活的算法,此算法基本思路为通过一系列的“GC Roots”对象作为起始点,从这些节点往下搜索,当一个对象和GC Roots不可达时,则该对象是无用的,可被回收的。如下图所示:object5、object6、object7虽然互相有关联,但是他们到GC Roots是不可达的,因此他们都可以被回收。

在java中,可作为GC Roots的对象有:

1.虚拟机栈(栈帧中的本地变量表)中引用的对象;

2.方法区中的类静态属性引用的对象;

3.方法区中常量引用的对象;

4.本地方法栈中JNI(即一般说的Native方法)中引用的对象

二、验证以上可作为GC Roots的对象(此处只做最简单的验证,不涉及很复杂的GCRoots引用链)。

1.验证虚拟机栈(栈帧中的局部变量)中引用的对象 作为GC Roots

/**

* GCRoots 测试:虚拟机栈(栈帧中的局部变量)中引用的对象作为GCRoots

* -Xms1024m -Xmx1024m -Xmn512m -XX:+PrintGCDetails

*

* 扩展:虚拟机栈中存放了编译器可知的八种基本数据类型,对象引用,returnAddress类型(指向了一条字节码指令的地址)

* @author ljl

*/

public class TestGCRoots01 {

private int _10MB = 10 * 1024 * 1024;

private byte[] memory = new byte[8 * _10MB];

public static void main(String[] args) {

method01();

System.out.println("返回main方法");

System.gc();

System.out.println("第二次GC完成");

}

public static void method01() {

TestGCRoots01 t = new TestGCRoots01();

System.gc();

System.out.println("第一次GC完成");

}

}

控制台打印日志:

[GC [PSYoungGen: 105513K->616K(458752K)] 105513K->82536K(983040K), 0.0945986 secs] [Times: user=0.17 sys=0.06, real=0.09 secs]

[Full GC [PSYoungGen: 616K->0K(458752K)] [ParOldGen: 81920K->82430K(524288K)] 82536K->82430K(983040K) [PSPermGen: 2547K->2546K(21504K)], 0.0273364 secs] [Times: user=0.06 sys=0.01, real=0.03 secs]

第一次GC完成

返回main方法

[GC [PSYoungGen: 15728K->64K(458752K)] 98159K->82494K(983040K), 0.0014739 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]

[Full GC [PSYoungGen: 64K->0K(458752K)] [ParOldGen: 82430K->510K(524288K)] 82494K->510K(983040K) [PSPermGen: 2546K->2546K(21504K)], 0.0118484 secs] [Times: user=0.02 sys=0.00, real=0.01 secs]

第二次GC完成

第一次GC:

t为局部变量,引用了new出的对象(80M),作为GC Roots,在Minor GC后被转移到老年代中,且Full GC也不会回收该对象,仍保留在老年代中。

第二次GC:

method01方法执行完后,局部变量t跟随方法消失,不再有引用类型指向该对象,该对象在Full GC后,被完全回收,老年代腾出该对象之前所占的空间。

2.验证方法区中的静态变量引用的对象作为GC Roots

/**

* 测试方法区中的静态变量引用的对象作为GCRoots

* -Xms1024m -Xmx1024m -Xmn512m -XX:+PrintGCDetails

*

* 扩展:方法区存与堆一样,是各个线程共享的内存区域,用于存放已被虚拟机加载的类信息,常量,静态变量,即时编译器编译后的代码等数据。

* @author ljl

* */

public class TestGCRoots02 {

private static int _10MB = 10 * 1024 * 1024;

private byte[] memory;

private static TestGCRoots02 t;

public TestGCRoots02(int size) {

memory = new byte[size];

}

public static void main(String[] args) {

TestGCRoots02 t2 = new TestGCRoots02(4 * _10MB);

t2.t = new TestGCRoots02(8 * _10MB);

t2 = null;

System.gc();

}

}

控制台打印日志:

[GC [PSYoungGen: 138608K->632K(458752K)] 138608K->82552K(983040K), 0.0684508 secs] [Times: user=0.19 sys=0.06, real=0.07 secs]

[Full GC [PSYoungGen: 632K->0K(458752K)] [ParOldGen: 81920K->82427K(524288K)] 82552K->82427K(983040K) [PSPermGen: 2513K->2512K(21504K)], 0.0162803 secs] [Times: user=0.02 sys=0.00, real=0.02 secs]

t2被置为null,Minor GC后t2之前引用的对象(40M)被完全回收;t为静态变量,存放于方法区中,引用了对象(80M),在Minor GC后,被转移到老年代中,且在Full GC后,也不会被回收,继续保留在老年代中。

3.验证方法区中常量引用对象作为GC Roots

/**

* 测试常量引用对象作为GCRoots

* 注意:t修饰符如果只是final会被回收,static final不会被回收,所以static final 才是常量的正确写法

* -Xms1024m -Xmx1024m -Xmn512m -XX:+PrintGCDetails

* @author ljl

*/

public class TestGCRoots03 {

private static int _10MB = 10 * 1024 * 1024;

private static final TestGCRoots03 t = new TestGCRoots03(8 * _10MB);

private byte[] memory;

public TestGCRoots03(int size) {

memory = new byte[size];

}

public static void main(String[] args) {

TestGCRoots03 t3 = new TestGCRoots03(4 * _10MB);

t3 = null;

System.gc();

}

}

控制台打印日志:

[GC [PSYoungGen: 138608K->688K(458752K)] 138608K->82608K(983040K), 0.0514407 secs] [Times: user=0.13 sys=0.02, real=0.05 secs]

[Full GC [PSYoungGen: 688K->0K(458752K)] [ParOldGen: 81920K->82428K(524288K)] 82608K->82428K(983040K) [PSPermGen: 2515K->2514K(21504K)], 0.0153884 secs] [Times: user=0.06 sys=0.00, real=0.01 secs]

t3被置为null,Minor GC后t3之前引用的对象(40M)被完全回收;t为常量,存放于方法区中,引用了对象(80M),在Minor GC后,被转移到老年代中,且在Full GC后,也不会被回收,继续保留在老年代中。

4.测试成员变量是否可作为GC Roots

/**

* 测试成员变量引用对象是否可作为GCRoots

* -Xms1024m -Xmx1024m -Xmn512m -XX:+PrintGCDetails

*

* @author ljl

*/

public class TestGCRoots04 {

private static int _10MB = 10 * 1024 * 1024;

private TestGCRoots04 t;

private byte[] memory;

public TestGCRoots04(int size) {

memory = new byte[size];

}

public static void main(String[] args) {

TestGCRoots04 t4 = new TestGCRoots04(4 * _10MB);

t4.t = new TestGCRoots04(8 * _10MB);

t4 = null;

System.gc();

}

}

控制台打印日志:

[GC [PSYoungGen: 138608K->600K(458752K)] 138608K->600K(983040K), 0.0015591 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]

[Full GC [PSYoungGen: 600K->0K(458752K)] [ParOldGen: 0K->507K(524288K)] 600K->507K(983040K) [PSPermGen: 2513K->2512K(21504K)], 0.0144441 secs] [Times: user=0.06 sys=0.00, real=0.02 secs]

t4被置为null,Minor GC后t4之前引用的对象(40M)被完全回收;t为成员变量,也叫实例变量,不同于类变量(静态变量),前面讲到类变量是存储在方法区中,而成员变量是存储在堆内存的对象中的,和对象共存亡,所以是不能作为GC Roots的,从日志中也可看出t在MinorGC后,跟随t4一起被完全回收。不再占用任何空间。

以上为一个非常简单的可作为GC Roots的对象的验证,不涉及较复杂的GC Roots引用链,其实作为使用者来讲,我们只要知道,哪些对象是可作为GC Roots的,在实际开发过程中要特别注意这些对象,不要让无谓的大对象消耗了资源,拖累了性能。

一、名词解释根搜索算法是JVM用来的判断对象是否存活的算法,此算法基本思路为通过一系列的“GC Roots”对象作为起始点,从这些节点往下搜索,当一个对象和GC Roots不可达时,则该对象是无用的,可被回收的。如下图所示:object5、object6、object7虽然互相有关联,但是他们到GC Roots是不可达的,因此他们都可以被回收。
       
在java中,可作为GC Roots的对象有:
1.虚拟机栈(栈帧中的本地变量表)中引用的对象;
2.方法区中的类静态属性引用的对象;
3.方法区中常量引用的对象;
4.本地方法栈中JNI(即一般说的Native方法)中引用的对象
二、验证以上可作为GC Roots的对象(此处只做最简单的验证,不涉及很复杂的GCRoots引用链)。
1.验证虚拟机栈(栈帧中的局部变量)中引用的对象 作为GC Roots
/** * GCRoots 测试:虚拟机栈(栈帧中的局部变量)中引用的对象作为GCRoots  * -Xms1024m -Xmx1024m -Xmn512m -XX:+PrintGCDetails *  * 扩展:虚拟机栈中存放了编译器可知的八种基本数据类型,对象引用,returnAddress类型(指向了一条字节码指令的地址) * @author ljl */public class TestGCRoots01 {private int _10MB = 10 * 1024 * 1024;private byte[] memory = new byte[8 * _10MB]; public static void main(String[] args) {method01();System.out.println("返回main方法");System.gc();System.out.println("第二次GC完成");} public static void method01() {TestGCRoots01 t = new TestGCRoots01();System.gc();System.out.println("第一次GC完成");}}
控制台打印日志:[GC [PSYoungGen: 105513K->616K(458752K)] 105513K->82536K(983040K), 0.0945986 secs] [Times: user=0.17 sys=0.06, real=0.09 secs] [Full GC [PSYoungGen: 616K->0K(458752K)] [ParOldGen: 81920K->82430K(524288K)] 82536K->82430K(983040K) [PSPermGen: 2547K->2546K(21504K)], 0.0273364 secs] [Times: user=0.06 sys=0.01, real=0.03 secs] 第一次GC完成返回main方法[GC [PSYoungGen: 15728K->64K(458752K)] 98159K->82494K(983040K), 0.0014739 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] [Full GC [PSYoungGen: 64K->0K(458752K)] [ParOldGen: 82430K->510K(524288K)] 82494K->510K(983040K) [PSPermGen: 2546K->2546K(21504K)], 0.0118484 secs] [Times: user=0.02 sys=0.00, real=0.01 secs] 第二次GC完成第一次GC:
t为局部变量,引用了new出的对象(80M),作为GC Roots,在Minor GC后被转移到老年代中,且Full GC也不会回收该对象,仍保留在老年代中。
第二次GC:
method01方法执行完后,局部变量t跟随方法消失,不再有引用类型指向该对象,该对象在Full GC后,被完全回收,老年代腾出该对象之前所占的空间。

2.验证方法区中的静态变量引用的对象作为GC Roots
/** * 测试方法区中的静态变量引用的对象作为GCRoots * -Xms1024m -Xmx1024m -Xmn512m -XX:+PrintGCDetails *  * 扩展:方法区存与堆一样,是各个线程共享的内存区域,用于存放已被虚拟机加载的类信息,常量,静态变量,即时编译器编译后的代码等数据。 * @author ljl * */public class TestGCRoots02 {private static int _10MB = 10 * 1024 * 1024;private byte[] memory; private static TestGCRoots02 t; public TestGCRoots02(int size) {memory = new byte[size];} public static void main(String[] args) {TestGCRoots02 t2 = new TestGCRoots02(4 * _10MB);t2.t = new TestGCRoots02(8 * _10MB);t2 = null;System.gc();}}

控制台打印日志:[GC [PSYoungGen: 138608K->632K(458752K)] 138608K->82552K(983040K), 0.0684508 secs] [Times: user=0.19 sys=0.06, real=0.07 secs] [Full GC [PSYoungGen: 632K->0K(458752K)] [ParOldGen: 81920K->82427K(524288K)] 82552K->82427K(983040K) [PSPermGen: 2513K->2512K(21504K)], 0.0162803 secs] [Times: user=0.02 sys=0.00, real=0.02 secs] 
t2被置为null,Minor GC后t2之前引用的对象(40M)被完全回收;t为静态变量,存放于方法区中,引用了对象(80M),在Minor GC后,被转移到老年代中,且在Full GC后,也不会被回收,继续保留在老年代中。

3.验证方法区中常量引用对象作为GC Roots
/** * 测试常量引用对象作为GCRoots  * 注意:t修饰符如果只是final会被回收,static final不会被回收,所以static final 才是常量的正确写法 * -Xms1024m -Xmx1024m -Xmn512m -XX:+PrintGCDetails * @author ljl */public class TestGCRoots03 {private static int _10MB = 10 * 1024 * 1024;private static final TestGCRoots03 t = new TestGCRoots03(8 * _10MB);private byte[] memory; public TestGCRoots03(int size) {memory = new byte[size];} public static void main(String[] args) {TestGCRoots03 t3 = new TestGCRoots03(4 * _10MB);t3 = null;System.gc();}}
控制台打印日志:[GC [PSYoungGen: 138608K->688K(458752K)] 138608K->82608K(983040K), 0.0514407 secs] [Times: user=0.13 sys=0.02, real=0.05 secs] [Full GC [PSYoungGen: 688K->0K(458752K)] [ParOldGen: 81920K->82428K(524288K)] 82608K->82428K(983040K) [PSPermGen: 2515K->2514K(21504K)], 0.0153884 secs] [Times: user=0.06 sys=0.00, real=0.01 secs] 
t3被置为null,Minor GC后t3之前引用的对象(40M)被完全回收;t为常量,存放于方法区中,引用了对象(80M),在Minor GC后,被转移到老年代中,且在Full GC后,也不会被回收,继续保留在老年代中。

4.测试成员变量是否可作为GC Roots
/** * 测试成员变量引用对象是否可作为GCRoots * -Xms1024m -Xmx1024m -Xmn512m -XX:+PrintGCDetails * * @author ljl */public class TestGCRoots04 {private static int _10MB = 10 * 1024 * 1024;private TestGCRoots04 t;private byte[] memory; public TestGCRoots04(int size) {memory = new byte[size];} public static void main(String[] args) {TestGCRoots04 t4 = new TestGCRoots04(4 * _10MB);t4.t = new TestGCRoots04(8 * _10MB);t4 = null;System.gc();}}
控制台打印日志:[GC [PSYoungGen: 138608K->600K(458752K)] 138608K->600K(983040K), 0.0015591 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] [Full GC [PSYoungGen: 600K->0K(458752K)] [ParOldGen: 0K->507K(524288K)] 600K->507K(983040K) [PSPermGen: 2513K->2512K(21504K)], 0.0144441 secs] [Times: user=0.06 sys=0.00, real=0.02 secs]t4被置为null,Minor GC后t4之前引用的对象(40M)被完全回收;t为成员变量,也叫实例变量,不同于类变量(静态变量),前面讲到类变量是存储在方法区中,而成员变量是存储在堆内存的对象中的,和对象共存亡,所以是不能作为GC Roots的,从日志中也可看出t在MinorGC后,跟随t4一起被完全回收。不再占用任何空间。

以上为一个非常简单的可作为GC Roots的对象的验证,不涉及较复杂的GC Roots引用链,其实作为使用者来讲,我们只要知道,哪些对象是可作为GC Roots的,在实际开发过程中要特别注意这些对象,不要让无谓的大对象消耗了资源,拖累了性能。

———————————————— 版权声明:本文为CSDN博主「Etyero」的原创文章,遵循CC 4.0 by-sa版权协议,转载请附上原文出处链接及本声明。原文链接:https://blog.csdn.net/u010798968/article/details/72835255

那些可作为GC Roots的对象的更多相关文章

  1. 【JVM底层策略 一】GC roots如何判断对象不可达

    查找内存中不再使用的对象 引用计数法 引用计数法就是如果一个对象没有被任何引用指向,则可视之为垃圾.这种方法的缺点就是不能检测到环的存在. 2.根搜索算法 根搜索算法的基本思路就是通过一系列名为”GC ...

  2. GC Roots的几种对象

    在java语言里,可作为GC Roots的对象包括下面几种: >虚拟机栈(栈帧中的本地变量表)中的引用的对象: >方法区中类静态属性引用的对象: >方法区中常量引用的对象: > ...

  3. gc roots 垃圾回收

    gc roots包括以下几个: 虚拟机栈(栈桢中的本地变量表)中的引用对象 方法区中的类静态属性引用的对象 方法区中的常量引用的对象 本地方法栈中JNI(即native方法)的引用的对象 java,c ...

  4. JVM 垃圾回收GC Roots Tracing

    1.跟搜索算法: JVM中对内存进行回收时,需要判断对象是否仍在使用中,可以通过GC Roots Tracing辨别. 定义: 通过一系列名为”GCRoots”的对象作为起始点,从这个节点向下搜索,搜 ...

  5. Java GC如何判断对象是否为垃圾

    查找内存中不再使用的对象 引用计数法 引用计数法就是如果一个对象没有被任何引用指向,则可视之为垃圾.这种方法的缺点就是不能检测到环的存在. 2.根搜索算法 根搜索算法的基本思路就是通过一系列名为”GC ...

  6. GC回收的对象

    垃圾收集(Carbage Collection)   java内存在运行时区域,程序计数器.java虚拟机栈.本地方法三个区域都是线程私有的内存区域,随着线程的启动和销毁而分配和回收.栈帧随着方法的调 ...

  7. JVM GC Roots

    如何确定一个堆中的对象是否死去? 两个思路: 1.引用计数法 给每个对象添加一个引用,用来统计指向该对象的引用计数.有引用时就加1,引用失效时就减1.任何时候引用计数为0,该对象就死亡了.可以被当做垃 ...

  8. JVM:GC Roots

    JVM:GC Roots 本笔记是根据bilibili上 尚硅谷 的课程 Java大厂面试题第二季 而做的笔记 JVM 垃圾回收的时候如何确定垃圾 什么是垃圾 简单来说就是内存中已经不再被使用的空间就 ...

  9. Gc如何判断对象可以被回收?

    Gc如何判断对象可以被回收? 1 引用计数器 引用计数法的算法思路:给对象增加一个引用计数器,每当对象增加一个引用计数器+1,失去一个引用-1,所以当计数器是0的时候对象就没有引用了,就会被认为可回收 ...

随机推荐

  1. QLineEdit 加省略号

    第一种方法: QFontMetrics elidfont(ui->lineEdit->font()); ui->lineEdit->setText (elidfont.elid ...

  2. [LeetCode] 351. Android Unlock Patterns 安卓解锁模式

    Given an Android 3x3 key lock screen and two integers m and n, where 1 ≤ m ≤ n ≤ 9, count the total ...

  3. Saltack 针对用户进行权限控制

    一. client_acl 配置使用 1.1 client_acl概述 开启对系统上非root的系统用户在master上执行特殊的模块,这些模块名可以使用正则表达式进行表示,不能指定对那些minion ...

  4. Qt编译理解(Qt 对 C++ 的扩展主要是3个方面)

    沉沉的黑夜都是白天的前奏.--郭小川 舍弃IDE或qmake.cmake等工具的束缚,通过几个例子, 一步步从标准 C++ 的编译过渡到 Qt 的编译. Qt 对 C++ 的扩展主要是3个方面: 1) ...

  5. 08 Tomcat+Java Web项目的创建和War的生成

    1.web服务器软件:服务器:安装了服务器软件的计算机服务器软件:接收用户的请求,处理请求,做出响应 * web服务器软件:接收用户的请求,处理请求,做出响应. 在web服务器软件中,可以部署web项 ...

  6. Python知识点图片

  7. Select与Epoll的区别

      相同点: 都是IO多路转接,都是一个线程能同一时间等待一堆描述符 不同点: 1.select接口使用不方便,每次调用完select都需要重新设置fd_set,因为输入输出未分离,返回的fd_set ...

  8. 一天一个Linux命令,第三天cat命令

    命令:cat (中文猫的意思) 解释:cat命令连接文件并打印到标准输出设备上(如显示器),cat经常用来显示文件的内容 注意:当文件较大时,文本在屏幕上迅速闪过(滚屏),用户往往看不清所显示的内容. ...

  9. Python生成流水线《无限拍卖》文字!

    话说,原文也是这样流水线生产的吧··· 代码 import random one_char_word=["烈","焰","冰"," ...

  10. Luogu4548 CTSC2006 歌唱王国 概率生成函数、哈希

    传送门 orz ymd 考虑构造生成函数:设\(F(x) = \sum\limits_{i=0}^\infty f_ix^i\),其中\(f_i\)表示答案为\(i\)的概率:又设\(G(x) = \ ...