System.gc初步分析

     openjdk中的垃圾回收是一个庞大的课题，如何标记活动的对象，就涉及到了堆栈的、常量池的跟踪标记等，非常复杂。在此先做一个初步的分析。

     先从System.java中的gc方法开始阅读。

     public static void gc() {
        Runtime.getRuntime().gc();
     }

     跟踪进去，其实调用到了jvm.cpp里面的JVM_GC(void)

    {

              if (!DisableExplicitGC) { //如果可以直接进行垃圾回收，则执行下面的一步， -XX:+DisableExplicitGC 选项可以关闭jvm的直接垃圾回收

                     Universe::heap()->collect(GCCause::_java_lang_system_gc);
              }

     }

     垃圾回收的方式有多种，下面跟踪并发收集(ParallelScavengeHeap.cpp)。

     void ParallelScavengeHeap::collect(GCCause::Cause cause) {

             ...........

             VM_ParallelGCSystemGC op(gc_count, full_gc_count, cause);
             VMThread::execute(&op);

     }

     上面的exceute()方法，主要执行的是VM_ParallelGCSystemGC 的doit()方法，下面看看

     void VM_ParallelGCSystemGC::doit() {

             //在这主要看一下全部回收的代码

             ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap();

             heap->invoke_full_gc(false);

     }

     下面是invoke_full_gc代码

     inline void ParallelScavengeHeap::invoke_full_gc(bool maximum_compaction)
    {

             .......
             PSMarkSweep::invoke(maximum_compaction);//从名字看出这个方法主要做标记、清除操作
     }

     跟踪进入上面方法

     void PSMarkSweep::invoke(bool maximum_heap_compaction) {

            .........

            PSMarkSweep::invoke_no_policy(maximum_heap_compaction);

     }
     上面invoke_no_policy非常复杂，在这仅对其第一阶段的操作进行简单分析。

     void PSMarkSweep::mark_sweep_phase1(bool clear_all_softrefs) {

            .........

            //从根开始对强引用开始进行标记操作

            Universe::oops_do(mark_and_push_closure());
            ReferenceProcessor::oops_do(mark_and_push_closure());
            JNIHandles::oops_do(mark_and_push_closure());   // Global (strong) JNI handles

            //跟踪每个线程堆栈，对堆栈里面的对象引用进行跟踪
            Threads::oops_do(mark_and_push_closure());
            ObjectSynchronizer::oops_do(mark_and_push_closure());
            FlatProfiler::oops_do(mark_and_push_closure());
            Management::oops_do(mark_and_push_closure());
            JvmtiExport::oops_do(mark_and_push_closure());

            //跟踪常量池用到的每个类
            SystemDictionary::always_strong_oops_do(mark_and_push_closure());
            vmSymbols::oops_do(mark_and_push_closure());

     }

     简单提一下，上面用到的MarkAndPushClosure，它其实就是将对象打上标志，并将对象指针压入一个栈中。采用的是回调函数用法，由上面的oops_do调用。代码如下

     {

            if (!oopDesc::is_null(heap_oop)) {
                   oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
                  if (!obj->mark()->is_marked()) {
                          mark_object(obj);  //对遍历到的对象进行标志
                         _marking_stack->push(obj); //对象入栈
                 }

            }
     }

     好，回到前面，简单分析一下Threads::oops_do(mark_and_push_closure())。

     void Threads::oops_do(OopClosure* f) {

           for (JavaThread* p = _thread_list; p; p = X->next()){ //遍历所有用户线程

                   p->oops_do(f);

          }

          VMThread::vm_thread()->oops_do(f); //遍历vmThread

     }
     java对象的方法调用，其在方法内创建的局部变量都在线程堆栈内。javaThread::oops_do应该会对堆栈内的对象进行标记，下面看一下代码。

    void JavaThread::oops_do(OopClosure* f) {

           Thread::oops_do(f);

           ........

           //下面是堆栈桢的遍历

           for(StackFrameStream fst(this); !fst.is_done(); fst.next()) {
                   fst.current()->oops_do(f, fst.register_map());
           }

           ........

    }

    void  Frame::oops_do(OopClosure* f, RegisterMap* map) {

           oops_do_internal(f, map, true);

    }

    void frame::oops_do_internal(OopClosure* f, RegisterMap* map, bool use_interpreter_oop_map_cache) {

           if (is_interpreted_frame())    { //以解释桢为例

               oops_interpreted_do(f, map, use_interpreter_oop_map_cache);

            }

   }

   void frame::oops_interpreted_do(OopClosure* f, const RegisterMap* map, bool query_oop_map_cache) {

          ............

           oops_interpreted_locals_do(f, max_locals, mask);
    oops_interpreted_expressions_do(f, signature, is_static,
                                    m->max_stack(),
                                    max_locals, mask);

         ............

  }

  void frame::oops_interpreted_locals_do(OopClosure *f,
                                      int max_locals,
                                      InterpreterOopMap *mask) {

          for (int i = 0; i < max_locals; i++ ) {
                  Tag tag = interpreter_frame_local_tag(i);
                  if (tag == TagReference) { //如果是对象引用，则进行标记，总算找到了
                          oop* addr = (oop*) interpreter_frame_local_at(i);
                          assert((intptr_t*)addr >= sp(), "must be inside the frame");
                          f->do_oop(addr);
            }

 }

 堆栈里面存着基本类型及引用类型，它们的位置及垃圾回收算法是如何区分这些类型的，这个还需要进一步的分析。