那些可作为GC Roots的对象
原文：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的对象的更多相关文章
- 【JVM底层策略 一】GC roots如何判断对象不可达
查找内存中不再使用的对象 引用计数法 引用计数法就是如果一个对象没有被任何引用指向,则可视之为垃圾.这种方法的缺点就是不能检测到环的存在. 2.根搜索算法 根搜索算法的基本思路就是通过一系列名为”GC ...
- GC Roots的几种对象
在java语言里,可作为GC Roots的对象包括下面几种: >虚拟机栈(栈帧中的本地变量表)中的引用的对象: >方法区中类静态属性引用的对象: >方法区中常量引用的对象: > ...
- gc roots 垃圾回收
gc roots包括以下几个: 虚拟机栈(栈桢中的本地变量表)中的引用对象 方法区中的类静态属性引用的对象 方法区中的常量引用的对象 本地方法栈中JNI(即native方法)的引用的对象 java,c ...
- JVM 垃圾回收GC Roots Tracing
1.跟搜索算法: JVM中对内存进行回收时,需要判断对象是否仍在使用中,可以通过GC Roots Tracing辨别. 定义: 通过一系列名为”GCRoots”的对象作为起始点,从这个节点向下搜索,搜 ...
- Java GC如何判断对象是否为垃圾
查找内存中不再使用的对象 引用计数法 引用计数法就是如果一个对象没有被任何引用指向,则可视之为垃圾.这种方法的缺点就是不能检测到环的存在. 2.根搜索算法 根搜索算法的基本思路就是通过一系列名为”GC ...
- GC回收的对象
垃圾收集(Carbage Collection) java内存在运行时区域,程序计数器.java虚拟机栈.本地方法三个区域都是线程私有的内存区域,随着线程的启动和销毁而分配和回收.栈帧随着方法的调 ...
- JVM GC Roots
如何确定一个堆中的对象是否死去? 两个思路: 1.引用计数法 给每个对象添加一个引用,用来统计指向该对象的引用计数.有引用时就加1,引用失效时就减1.任何时候引用计数为0,该对象就死亡了.可以被当做垃 ...
- JVM：GC Roots
JVM:GC Roots 本笔记是根据bilibili上 尚硅谷 的课程 Java大厂面试题第二季 而做的笔记 JVM 垃圾回收的时候如何确定垃圾 什么是垃圾 简单来说就是内存中已经不再被使用的空间就 ...
- Gc如何判断对象可以被回收？
Gc如何判断对象可以被回收? 1 引用计数器 引用计数法的算法思路:给对象增加一个引用计数器,每当对象增加一个引用计数器+1,失去一个引用-1,所以当计数器是0的时候对象就没有引用了,就会被认为可回收 ...
随机推荐
- [LeetCode] 503. Next Greater Element II 下一个较大的元素 II
Given a circular array (the next element of the last element is the first element of the array), pri ...
- 【SSH进阶之路】Spring的AOP逐层深入——AOP的基本原理(六)
经过我们对Spring的IOC不断的深入学习,Spring的面貌逐渐变得清晰,我们对Spring的了解也更加的深入.从这篇博文开始我们学习Spring的第二大核心内容:AOP. 什么是AOP AOP( ...
- zabbix详解
官网地址 https://www.zabbix.com/documentation/3.0/manual/config/items/itemtypes/zabbix_agent 使用率
- 05 Mybatis的CRUD操作和Mybatis连接池
1.CRUD的含义 CRUD是指在做计算处理时的增加(Create).读取(Retrieve)(重新得到数据).更新(Update)和删除(Delete)几个单词的首字母简写.主要被用在描述软件系统中 ...
- Response的应用
1．HttpServletResponse概述 service方法中的response的类型是ServletResponse,而doGet/doPost方法的response的类型是HttpServl ...
- Python-09-文件处理
一.文件操作流程 打开文件,得到文件句柄并赋值给一个变量 通过句柄对文件进行操作 关闭文件 #1. 打开文件,得到文件句柄并赋值给一个变量 f=open('a.txt','r',encoding='u ...
- vim实用操作指南
一.查看文件编码 :set fileencoding :set fileencoding=utf-8 通过该命令可直接将文件修改为UTF-8编码 强制以指定编码打开,vim中 :e ++enc=utf ...
- Oracle 11g Java驱动包ojdbc6.jar安装到maven库，并查看jar具体版本号
ojdbc6.jar下载 Oracle官方宣布的Oracle数据库11g的驱动jar包是ojdbc6.jar ojdbc6.jar下载地址:https://www.oracle.com/technet ...
- 如何将 Redis 用于微服务通信的事件存储
来源:Redislabs作者:Martin Forstner 翻译:Kevin (公众号:中间件小哥) 以我的经验,将某些应用拆分成更小的.松耦合的.可协同工作的独立逻辑业务服务会更易于构建和维护.这 ...
- navicat 连接 mysql 提示Client does not support authentication protocol requested by server错误
安装完mysql后,命令行登录没问题,但是用Navicat连接出现提示性错误.Mysql版本为:8.0.15 命令如下: 1.use mysql; 2.alter user 'root'@'local ...