java 申请完整root java root对象

.

• 一 .前言
• 二 .总结
• 三 .详情

• 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集。

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)