Java 哪些对象才能作为gc root

「爱情、让人受尽委屈。」 2022-10-09 12:20 340阅读 0赞

### . ###

*  一 .前言
 *  二 .总结
 *  三 .详情
 *   *  3.1. 所有已加载的类(ClassLoaderDataGraph::roots\_cld\_do)
     *  3.2. 所有Java线程当前栈帧的引用和虚拟机内部线程(Threads::possibly\_parallel\_oops\_do)
     *  3.3. JVM内部使用的引用(Universe::oops\_do和SystemDictionary::oops\_do)
     *  3.4. JNI handles(JNIHandles::oops\_do)
     *  3.5. 所有synchronized锁住的对象引用(ObjectSynchronizer::oops\_do)
     *  3.6. 内存池/线程对象和线程快照对象(Management::oops\_do)
     *  3.7. JVMTI导出(JvmtiExport::oops\_do)
     *  3.8. AOT代码的堆(AOTLoader::oops\_do)
     *  3.9. code cache(CodeCache::blobs\_do)
     *  3.10. String常量池(StringTable::oops\_do)

# 一 .前言 #

GC Roots基本思路就是通过一系列的称为“GC Roots”的对象作为起始点， 从这些节点开始向下搜索， 搜索所走过的路径称为引用链（ Reference Chain），当一个对象到 GC Roots 没有任何引用链相连（ 用图论的话来 说，就是从GC Roots到这个对象不可达）时，则证明此对象是不可用的。

**翻了一下JVM的代码,发现JVM GC的类型是一个枚举类, 一共有 十种.**

enum RootType { 
        universe              = 1,
        jni_handles           = 2,
        threads               = 3,
        object_synchronizer   = 4,
        flat_profiler         = 5,
        management            = 6,
        jvmti                 = 7,
        system_dictionary     = 8,
        class_loader_data     = 9,
        code_cache            = 10
      };

# 二 .总结 #

一个对象可以属于多个root，GC Roots有以下几种：

1、**在虚拟机栈中引用的对象，例如各个线程被调用的方法堆栈中使用到的参数、局部变量、临时变量等。**  
2、**在方法区中类静态属性引用的对象，例如java类的引用类型静态变量。**  
3、**在方法区中常量引用的对象，例如字符串常量池里的引用。**  
4、在本地方法栈中JNI引用的对象。  
5、**Java虚拟机内部的引用，如基本数据类型对应的class对象，一些常驻的异常对象等，还有类加载器。**  
6、**所有被同步锁持有的对象。**  
7、**所有活着的线程 .**  
8、反映Java虚拟机内部情况的JMXBean、JVMTI中注册的回调、本地代码缓存等。除了这些固定的GC Roots集合外，根据用户所选用的垃圾收集器以及当前回收的内存区域不同，还可以有其他对象临时性地加入，共同构成完整GC Roots集合。

# 三 .详情 #

*  先贴一下扫描root的任务代码 :

void ScavengeRootsTask::do_it(GCTaskManager* manager, uint which) { 
      assert(Universe::heap()->is_gc_active(), "called outside gc");
    
      PSPromotionManager* pm = PSPromotionManager::gc_thread_promotion_manager(which);
      PSScavengeRootsClosure roots_closure(pm);
      PSPromoteRootsClosure  roots_to_old_closure(pm);
    
      switch (_root_type) { 
        case universe:
          Universe::oops_do(&roots_closure);
          break;
    
        case jni_handles:
          JNIHandles::oops_do(&roots_closure);
          break;
    
        case threads:
        { 
          ResourceMark rm;
          CLDClosure* cld_closure = NULL; // Not needed. All CLDs are already visited.
          Threads::oops_do(&roots_closure, cld_closure, NULL);
        }
        break;
    
        case object_synchronizer:
          ObjectSynchronizer::oops_do(&roots_closure);
          break;
    
        case flat_profiler:
          FlatProfiler::oops_do(&roots_closure);
          break;
    
        case system_dictionary:
          SystemDictionary::oops_do(&roots_closure);
          break;
    
        case class_loader_data:
        { 
          PSScavengeKlassClosure klass_closure(pm);
          ClassLoaderDataGraph::oops_do(&roots_closure, &klass_closure, false);
        }
        break;
    
        case management:
          Management::oops_do(&roots_closure);
          break;
    
        case jvmti:
          JvmtiExport::oops_do(&roots_closure);
          break;
    
    
        case code_cache:
          { 
            MarkingCodeBlobClosure each_scavengable_code_blob(&roots_to_old_closure, CodeBlobToOopClosure::FixRelocations);
            CodeCache::scavenge_root_nmethods_do(&each_scavengable_code_blob);
          }
          break;
    
        default:
          fatal("Unknown root type");
      }
    
      // Do the real work
      pm->drain_stacks(false);
    }

## 3.1. 所有已加载的类(ClassLoaderDataGraph::roots\_cld\_do) ##

## 3.2. 所有Java线程当前栈帧的引用和虚拟机内部线程(Threads::possibly\_parallel\_oops\_do) ##

Java代码new一个对象引用，这个对象引用所在的地方。

## 3.3. JVM内部使用的引用(Universe::oops\_do和SystemDictionary::oops\_do) ##

基本类型的Class对象，和一些异常对象(比如NPE,OOM)等，还有类加载器，它们的成员分配在堆上面，如果没有指向成员的引用就会被当作垃圾回收，所以需要保留它们作为GC Root

## 3.4. JNI handles(JNIHandles::oops\_do) ##

JNI方法里面new的对象，以及传给JNI的对象。比如调用一个static jni方法:

package pkg;
    public class Foo{ 
    	public static native void func();
    }

它的JNI签名大概是这样：

JNIEXPORT void JNICALL Java_pkg_Foo_func
    	(JNIEnv*, jclass);

第二个参数表示当前Foo.class对象，由于要传到JNI里面去，需要把它包装成JNI handle传进去

## 3.5. 所有synchronized锁住的对象引用(ObjectSynchronizer::oops\_do) ##

## 3.6. 内存池/线程对象和线程快照对象(Management::oops\_do) ##

java.lang.management可以获取用于表示JVM内部堆状态的Bean，这些Bean是java对象，它们的实体就是Eden，From等区内部保存的一个用于表示该区域的对象，它们也要加入GC Root集。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nbG9uZ180NDQ0_size_16_color_FFFFFF_t_70]

## 3.7. JVMTI导出(JvmtiExport::oops\_do) ##

JVMTI可以在用户分配对象的时候调用用户注册的回调，其中用户分配的对象会放到一个数组作为GC Root。举个例子，假设用户Java代码是这样：

public class Foo{ 
    	public void alloc(){ 
    		new Object();
    	}
    }

JVMTI会在虚拟机分配Object对象的时候调用回调函数

void JNICALL VMObjectAlloc(jvmtiEnv *jvmti_env,
                JNIEnv* jni_env,
                jthread thread,
                jobject object,
                jclass object_klass,
                jlong size){ 
    	...
    }

然后用户可以在自定义的回调里面对这个对象做一些操作，问题如果发生垃圾回收Object很可能被当作垃圾释放掉，但是这样是有问题的，因为JVMTI还在使用它，所以JVMTI对象分配事件保存的这些对象也需要作为GC Root。

## 3.8. AOT代码的堆(AOTLoader::oops\_do) ##

## 3.9. code cache(CodeCache::blobs\_do) ##

比如JIT将Java的一个Foo编译成本地代码(nmethod)，但是本地代码执行过一次后就不执行了（相当于Foo只调用一次），这个时候需要回收本地代码，因为本地代码也是占用内存的。

## 3.10. String常量池(StringTable::oops\_do) ##

参考:  
《深入理解java虚拟机》  
https://www.zhihu.com/question/50381439  
https://www.huaweicloud.com/articles/789c219b9bb15654807e78f214ea6029.html

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nbG9uZ180NDQ0_size_16_color_FFFFFF_t_70]: /images/20221005/2a76faa3edb848aaae83cf0a56846291.png