HotSpot Serial收集器

最新推荐文章于 2022-09-13 14:17:49 发布
最新推荐文章于 2022-09-13 14:17:49 发布
阅读量326 收藏 1
点赞数 1
分类专栏： HotSpot 文章标签： hotspot jvm java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013928208/article/details/108706470
版权

GC在HotSpot中的地位举足轻重。JDK9为止提供了四种收集器：Serial，CMS，Parallel，G1。按机器规模，分代类型，吞吐量，延时，CPU利用率等，结合不同的算法，每种收集器都有各自适用的使用场景，同时衍生出多种GC组合配置。今天来看Serial收集器。

  1. Serial收集器属于分代GC收集器。
  2. 年轻代主要算法为复制算法，老年代主要算法为标记压缩算法。
  3. Serial和SerialOld都是单线程GC。特点是需要STW。
  4. 适用于响应时间要求不高的桌面应用或开发调试环境。

一. Serial收集器初始化

使用 -XX:+UseSerialGC 切换到串行收集器模式，断点调试

hotspot/src/share/vm/runtime/init.cpp

jint init_globals() { jint status = universe_init();}

hotspot/src/share/vm/memory/universe.cpp

jint universe_init() { jint status = Universe::initialize_heap();}

hotspot/src/share/vm/memory/universe.cpp

jint Universe::initialize_heap() {
  _collectedHeap = create_heap();
  status = _collectedHeap->initialize();
}

hotspot/src/share/vm/memory/universe.cpp
使用UseSerialGC策略创建堆

CollectedHeap* Universe::create_heap() {
 if (UseParallelGC) {
    return Universe::create_heap_with_policy<ParallelScavengeHeap, GenerationSizer>();
  } else if (UseG1GC) {
    return Universe::create_heap_with_policy<G1CollectedHeap, G1CollectorPolicy>();
  } else if (UseConcMarkSweepGC) {
    return Universe::create_heap_with_policy<GenCollectedHeap, ConcurrentMarkSweepPolicy>();
  } else if (UseSerialGC) {
    return Universe::create_heap_with_policy<GenCollectedHeap, MarkSweepPolicy>();
  }
}

hotspot/src/share/vm/memory/universe.inline.hpp
策略模板函数

template <class Heap, class Policy>
CollectedHeap* Universe::create_heap_with_policy() {
  Policy* policy = new Policy(); //创建收集策略 MarkSweepPolicy是GenCollectorPolicy的一种
  policy->initialize_all();
  return new Heap(policy); //创建分代堆具体来说就是GenCollectedHeap
}

hotspot/src/share/vm/gc/shared/genCollectedHeap.cpp
GenCollectedHeap是CollectedHeap的一种，CardTableRS处理老年代对年轻代的跨代引用

jint GenCollectedHeap::initialize() {
  // Allocate space for the heap.
  char* heap_address; //堆空间地址
  ReservedSpace heap_rs; //映射堆空间
  size_t heap_alignment = collector_policy()->heap_alignment(); //堆大小
  heap_address = allocate(heap_alignment, &heap_rs); //分配堆空间
  //MemRegion到ReservedSpace的映射
  initialize_reserved_region((HeapWord*)heap_rs.base(), (HeapWord*)(heap_rs.base() + heap_rs.size()));
  //使用MemRegion为CardTableRS分配一块内存
  _rem_set = collector_policy()->create_rem_set(reserved_region());
  set_barrier_set(rem_set()->bs());
  //年轻代空间
  ReservedSpace young_rs = heap_rs.first_part(gen_policy()->young_gen_spec()->max_size(), false, false);
  //初始化年轻代空间
  _young_gen = gen_policy()->young_gen_spec()->init(young_rs, rem_set());
  //老年代空间
  heap_rs = heap_rs.last_part(gen_policy()->young_gen_spec()->max_size());
  ReservedSpace old_rs = heap_rs.first_part(gen_policy()->old_gen_spec()->max_size(), false, false);
  //初始化老年代空间
  _old_gen = gen_policy()->old_gen_spec()->init(old_rs, rem_set());

  return JNI_OK;
}

hotspot/src/share/vm/gc/shared/generationSpec.cpp
创建对应的收集器分代类型，Serial收集器对应DefNewGeneration和TenuredGeneration分代


#if INCLUDE_ALL_GCS
#include "gc/cms/concurrentMarkSweepGeneration.hpp"
#include "gc/cms/parNewGeneration.hpp"
#endif // INCLUDE_ALL_GCS

Generation* GenerationSpec::init(ReservedSpace rs, CardTableRS* remset) {
  switch (name()) {
    case Generation::DefNew:
      return new DefNewGeneration(rs, init_size());
    case Generation::MarkSweepCompact:
      return new TenuredGeneration(rs, init_size(), remset);
    #if INCLUDE_ALL_GCS
    case Generation::ParNew:
      return new ParNewGeneration(rs, init_size());
    case Generation::ConcurrentMarkSweep: {
      ConcurrentMarkSweepGeneration* g = NULL;
      g = new ConcurrentMarkSweepGeneration(rs, init_size(), remset);
      g->initialize_performance_counters();
      return g;
    }
    #endif // INCLUDE_ALL_GCS
}

hotspot/src/share/vm/gc/serial/defNewGeneration.cpp
创建年轻代，DefNewGeneration是Generation的一种，ContiguousSpace继承CompactibleSpace间接继承自Space

DefNewGeneration::DefNewGeneration(ReservedSpace rs,
                                   size_t initial_size,
                                   const char* policy)
  : Generation(rs, initial_size),
    _preserved_marks_set(false /* in_c_heap */),
    _promo_failure_drain_in_progress(false),
    _should_allocate_from_space(false)
{
 //初始化MemRegion
  MemRegion cmr((HeapWord*)_virtual_space.low(),
                (HeapWord*)_virtual_space.high());
  GenCollectedHeap* gch = GenCollectedHeap::heap();
  //初始化卡表CardTableModRefBS
  gch->barrier_set()->resize_covered_region(cmr);
  //创建eden,from,to三块连续空间
  _eden_space = new ContiguousSpace();
  _from_space = new ContiguousSpace();
  _to_space   = new ContiguousSpace();
  //计算空间尺寸
  uintx alignment = gch->collector_policy()->space_alignment();
  uintx size = _virtual_space.reserved_size();
  _max_survivor_size = compute_survivor_size(size, alignment);
  _max_eden_size = size - (2*_max_survivor_size);
  //计算三块空间的边界
  compute_space_boundaries(0, SpaceDecorator::Clear, SpaceDecorator::Mangle);
  _old_gen = NULL;
  //晋升到老年代阈值
  _tenuring_threshold = MaxTenuringThreshold;
  _pretenure_size_threshold_words = PretenureSizeThreshold >> LogHeapWordSize;
  //计时器
  _gc_timer = new (ResourceObj::C_HEAP, mtGC) STWGCTimer();
}

hotspot/src/share/vm/gc/serial/tenuredGeneration.cpp
创建老年代，tenuredGeneration是CardGeneration的一种

TenuredGeneration::TenuredGeneration(ReservedSpace rs,
                                     size_t initial_byte_size,
                                     CardTableRS* remset) :
  CardGeneration(rs, initial_byte_size, remset)
{
  HeapWord* bottom = (HeapWord*) _virtual_space.low();
  HeapWord* end    = (HeapWord*) _virtual_space.high();
  _the_space  = new TenuredSpace(_bts, MemRegion(bottom, end));
  _the_space->reset_saved_mark();
  _gc_stats = new GCStats();
  const char* gen_name = "old";
  GenCollectorPolicy* gcp = GenCollectedHeap::heap()->gen_policy();
  // Generation Counters -- generation 1, 1 subspace
  _gen_counters = new GenerationCounters(gen_name, 1, 1,gcp->min_old_size(), gcp->max_old_size(), &_virtual_space);
  _gc_counters = new CollectorCounters("MSC", 1);
  _space_counters = new CSpaceCounters(gen_name, 0,_virtual_space.reserved_size(),_the_space, _gen_counters);
}

hotspot/src/share/vm/gc/shared/cardGeneration.cpp

CardGeneration::CardGeneration(ReservedSpace rs,
                               size_t initial_byte_size,
                               CardTableRS* remset) :
  Generation(rs, initial_byte_size), _rs(remset),
  _shrink_factor(0), _min_heap_delta_bytes(), _capacity_at_prologue(),
  _used_at_prologue()
{
  HeapWord* start = (HeapWord*)rs.base(); //起始
  size_t reserved_byte_size = rs.size(); //空间大小
  MemRegion reserved_mr(start, heap_word_size(reserved_byte_size));
  //BlockOffsetSharedArray辅助提升对象起始地址查找效率
  _bts = new BlockOffsetSharedArray(reserved_mr,heap_word_size(initial_byte_size));
  MemRegion committed_mr(start, heap_word_size(initial_byte_size));
  _rs->resize_covered_region(committed_mr);
  _min_heap_delta_bytes = MinHeapDeltaBytes;
  _capacity_at_prologue = initial_byte_size;
  _used_at_prologue = 0;
}

hotspot/src/share/vm/gc/shared/generation.cpp

Generation::Generation(ReservedSpace rs, size_t initial_size) :
  _ref_processor(NULL) {
  //初始化虚空间，ReservedSpace到VirtualSpace的映射
  _virtual_space.initialize(rs, initial_size)
  //VirtualSpace到MemRegion的映射
  _reserved = MemRegion((HeapWord*)_virtual_space.low_boundary(),
          (HeapWord*)_virtual_space.high_boundary());
}

二.分代

hotspot/src/share/vm/gc/shared/generation.hpp
分代基类提供了一组虚函数，包括对象分配，对象提升，内存回收，压缩，对象遍历等，模板设计模式具体算法由各子类提供

class Generation: public CHeapObj<mtGC> {
  //
  virtual HeapWord* allocate(size_t word_size, bool is_tlab) = 0;
  virtual HeapWord* par_allocate(size_t word_size, bool is_tlab) = 0;
  virtual oop promote(oop obj, size_t obj_size);
  virtual oop par_promote(int thread_num, oop obj, markOop m, size_t word_sz);
  virtual void collect(bool   full,bool   clear_all_soft_refs,size_t word_size,bool   is_tlab) = 0;
  virtual HeapWord* expand_and_allocate(size_t word_size, bool is_tlab, bool parallel = false) = 0;
 // Mark sweep support phase2
  virtual void prepare_for_compaction(CompactPoint* cp);
  // Mark sweep support phase3
  virtual void adjust_pointers();
  // Mark sweep support phase4
  virtual void compact();
  virtual void post_compact() { ShouldNotReachHere(); }
  ReferenceProcessor* const ref_processor() { return _ref_processor; }
  virtual void oop_iterate(ExtendedOopClosure* cl);
  virtual void object_iterate(ObjectClosure* cl);
  virtual void safe_object_iterate(ObjectClosure* cl);
  virtual void younger_refs_iterate(OopsInGenClosure* cl, uint n_threads) = 0;
  virtual void clear_remembered_set() { }
  virtual void invalidate_remembered_set() { }
  virtual HeapWord* block_start(const void* addr) const;
                                       
}

hotspot/src/share/vm/gc/serial/defNewGeneration.hpp
年轻代DefNewGeneration提供了如年龄表，标记栈，对象遍历操作等，并实现了基类的虚函数

class DefNewGeneration: public Generation {
   AgeTable    _age_table;
   Stack<oop, mtGC> _promo_failure_scan_stack;
   oop copy_to_survivor_space(oop old);
   class FastKeepAliveClosure: public KeepAliveClosure {virtual void do_oop(oop* p);}
   void compute_space_boundaries(uintx minimum_eden_size,bool clear_space,bool mangle_space);
   size_t adjust_for_thread_increase(size_t new_size_candidate,size_t new_size_before,size_t alignment) const;
   void swap_spaces(); //from，to空间交换
   //......
}

hotspot/src/share/vm/gc/shared/cardGeneration.hpp
老年代TenuredGeneration继承自CardGeneration，提供了卡表，块偏移集合，并实现了基类的虚函数

class CardGeneration: public Generation {
  // This is shared with other generations.
  CardTableRS* _rs;
  // This is local to this generation.
  BlockOffsetSharedArray* _bts;
  void space_iterate(SpaceClosure* blk, bool usedOnly = false);
  //对年轻代的引用遍历
  void younger_refs_iterate(OopsInGenClosure* blk, uint n_threads);
  //......
}

HotSpot中的分代在每种收集器中都有自己的实现，CMS是Serial的并发版本，因此共享了部分分代逻辑。如CMS的年轻代ParNewGeneration 集成自 DefNewGeneration 。CMS老年代ConcurrentMarkSweepGeneration:继承自CardGeneration。而Parallel的分代则另起炉灶，Parallel的年轻代为PSYoungGen，老年代为PSOldGen，两者皆集成自CHeapObj。而G1更进一步，由于其算法的特殊性，将空间离散化为多个堆区间，并将gen,from,to,old的堆空间映射到这些离散的堆空间上，分代的概念在此被拆散了。

三.堆空间。

Serial收集器初始化时会创建收集堆GenCollectedHeap继承自CollectedHeap，CollectedHeap的子类还有G1CollectedHeap，ParallelScavengeHeap两者分别用于G1和Parallel收集器。
hotspot/src/share/vm/gc/shared/collectedHeap.hpp
CollectedHeap 提供了一组虚函数，由子类实现堆内存的分配，垃圾收集，管理

class CollectedHeap : public CHeapObj<mtInternal> {
   MemRegion _reserved; //对应的内存区
   BarrierSet* _barrier_set; //读写屏障
   virtual HeapWord* allocate_new_tlab(size_t size); //分配TLAB
   inline static HeapWord* allocate_from_tlab(KlassHandle klass, Thread* thread, size_t size);//通用分配
   inline static HeapWord* common_mem_allocate_noinit(KlassHandle klass, size_t size, TRAPS);
   virtual bool is_in(const void* p) const = 0; //对象存在判断
   inline static oop obj_allocate(KlassHandle klass, int size, TRAPS);//对象分配
   virtual HeapWord* mem_allocate(size_t size,bool* gc_overhead_limit_was_exceeded) = 0;
   virtual void collect(GCCause::Cause cause) = 0; //收集
   virtual void do_full_collection(bool clear_all_soft_refs) = 0;//全量收集
   virtual void object_iterate(ObjectClosure* cl) = 0; //对象遍历
   virtual HeapWord* block_start(const void* addr) const = 0;
}

hotspot/src/share/vm/gc/shared/genCollectedHeap.hpp
GenCollectedHeap代表年轻代，老年代的分代堆。提供了一组算法用于实现对象分配，对象遍历，垃圾收集，其中一些与CMS收集器共享复用。

class GenCollectedHeap : public CollectedHeap {
  Generation* _young_gen;
  Generation* _old_gen;
  CardTableRS* _rem_set;
  SubTasksDone* _process_strong_tasks; //并行收集有关
  void collect_generation(Generation* gen, bool full, size_t size, bool is_tlab,
                          bool run_verification, bool clear_soft_refs,
                          bool restore_marks_for_biased_locking);
 void do_collection(bool           full,
                     bool           clear_all_soft_refs,
                     size_t         size,
                     bool           is_tlab,
                     GenerationType max_generation);
 HeapWord* satisfy_failed_allocation(size_t size, bool is_tlab);
 WorkGang* workers() const { return _workers; } //并行收集有关
 char* allocate(size_t alignment, ReservedSpace* heap_rs);
 HeapWord* mem_allocate(size_t size, bool*  gc_overhead_limit_was_exceeded);
 void collect(GCCause::Cause cause);
 void collect(GCCause::Cause cause, GenerationType max_generation);
 void oop_iterate_no_header(OopClosure* cl);
 void oop_iterate(ExtendedOopClosure* cl);
 void object_iterate(ObjectClosure* cl);
 void safe_object_iterate(ObjectClosure* cl);
 Space* space_containing(const void* addr) const;
 void generation_iterate(GenClosure* cl, bool old_to_young);
 void process_roots(StrongRootsScope* scope,
                     ScanningOption so,
                     OopClosure* strong_roots,
                     OopClosure* weak_roots,
                     CLDClosure* strong_cld_closure,
                     CLDClosure* weak_cld_closure,
                     CodeBlobToOopClosure* code_roots);
void young_process_roots(StrongRootsScope* scope,
                           OopsInGenClosure* root_closure,
                           OopsInGenClosure* old_gen_closure,
                           CLDClosure* cld_closure);
void cms_process_roots(StrongRootsScope* scope,
                         bool young_gen_as_roots,
                         ScanningOption so,
                         bool only_strong_roots,
                         OopsInGenClosure* root_closure,
                         CLDClosure* cld_closure);
void gen_process_weak_roots(OopClosure* root_closure);
void prepare_for_compaction();
bool create_cms_collector();
}

如同上述分代一样,CMS收集器仍然共享了Serial收集器的分代堆GenCollectedHeap 。而Parallel和G1中则另起炉灶。Parallel的分代堆不再是GenCollectedHeap 而是ParallelScavengeHeap。G1则是G1CollectedHeap。

四.垃圾收集

1.触发GC

修改之前的Hello类如下循环创建大对象，触发GC

import java.util.ArrayList;
import java.util.List;

public class Hello{
    public static void main(String[] args){
        for (int i = 0; i < 5; i++) {
            createBigObject(21);
            System.gc()
        }
    }

    private static void createBigObject(int n) {
        List<byte[]> bytesList = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            bytesList.add(new byte[1024 * 1024 * 10]);
        }
        if (bytesList.size() < 20) {
            throw new RuntimeException("this is test");
        }
    }
}

hotspot/src/share/vm/runtime/vmThread.cpp
VMThread线程循环等待VM_Operation操作的到来，如上一篇当对象分配时空间不足时触发VM_GenCollectForAllocation类型的GC

void VMThread::loop() {
  evaluate_operation(_cur_vm_operation);
}

hotspot/src/share/vm/runtime/vmThread.cpp

void VMThread::evaluate_operation(VM_Operation* op) {
 op->evaluate();
}

hotspot/src/share/vm/runtime/vm_operations.cpp

void VM_Operation::evaluate() {
   doit();
}

hotspot/src/share/vm/gc/shared/vmGCOperations.cpp

void VM_GenCollectForAllocation::doit() {
  GenCollectedHeap* gch = GenCollectedHeap::heap();
  GCCauseSetter gccs(gch, _gc_cause);
  _result = gch->satisfy_failed_allocation(_word_size, _tlab);
}

hotspot/src/share/vm/gc/shared/genCollectedHeap.cpp

HeapWord* GenCollectedHeap::satisfy_failed_allocation(size_t size, bool is_tlab) {
  return gen_policy()->satisfy_failed_allocation(size, is_tlab);
}

2.收集策略

hotspot/src/share/vm/gc/shared/collectorPolicy.cpp
由收集策略决定收集方式，分配流程如下：

  1. 如果存在GC锁，尝试扩展分配
  2. 如果最近一次回收没有失败，进行一次MinorGC
  3. 如果最近一次回收失败了，进行一次fullGC
  4. 2或3步GC后，再尝试分配
  5. 如果分配还是失败了，尝试扩展堆分配
  6. 如果还是没分配到则一定是堆内存溢出了，强制进行一次FullGC
  7. 强制FullGc后，再次试图分配
HeapWord* GenCollectorPolicy::satisfy_failed_allocation(size_t size, bool   is_tlab) {
  GenCollectedHeap *gch = GenCollectedHeap::heap();
  GCCauseSetter x(gch, GCCause::_allocation_failure);
  HeapWord* result = NULL;
  if (GCLocker::is_active_and_needs_gc()) {
    //尝试分配
    if (!gch->is_maximal_no_gc()) {
      result = expand_heap_and_allocate(size, is_tlab);
    }
    return result;
  } else if (!gch->incremental_collection_will_fail(false /* don't consult_young */)) { //最近一次回收没有失败
    //进行一次MinorGc
    gch->do_collection(false,                     // full
                       false,                     // clear_all_soft_refs
                       size,                      // size
                       is_tlab,                   // is_tlab
                       GenCollectedHeap::OldGen); // max_generation
  } else { //最近一次回收失败了
    //进行一次fullGC
    gch->do_collection(true,                      // full
                       false,                     // clear_all_soft_refs
                       size,                      // size
                       is_tlab,                   // is_tlab
                       GenCollectedHeap::OldGen); // max_generation
  }

  //尝试分配
  result = gch->attempt_allocation(size, is_tlab, false /*first_only*/);
  if (result != NULL) {
    return result;
  }

  //尝试扩展堆分配
  result = expand_heap_and_allocate(size, is_tlab);
  if (result != NULL) {
    return result;
  }
  //走到这里一定是内存溢出了，进行一次强制回收，软引用被回收
  {
    UIntFlagSetting flag_change(MarkSweepAlwaysCompactCount, 1); // Make sure the heap is fully compacted

    gch->do_collection(true,                      // full
                       true,                      // clear_all_soft_refs
                       size,                      // size
                       is_tlab,                   // is_tlab
                       GenCollectedHeap::OldGen); // max_generation
  }
  //再次试图分配
  result = gch->attempt_allocation(size, is_tlab, false /* first_only */);
  if (result != NULL) {
    return result;
  }
  //始终没分配到
  return NULL;
}

hotspot/src/share/vm/gc/shared/genCollectedHeap.cpp
do_collection是分代堆里封装的适用于各代的收集算法,对哪个分代收集取决于入参。主要流程如下：

  1. 如果do_young_collection成立，进行年轻代回收
  2. 如果最大分代为老年代且老年代应该回收（年轻代空间不足），进行一次老年代回收
  3. 重新调整堆大小
void GenCollectedHeap::do_collection(bool full,......) {
  {
    //进行一次年轻代GC
    if (do_young_collection) {
      collect_generation(_young_gen,
                         full,
                         size,
                         is_tlab,
                         run_verification && VerifyGCLevel <= 0,
                         do_clear_all_soft_refs,
                         false);
    }

    bool must_restore_marks_for_biased_locking = false;
     //进行一次老年代收集
    if (max_generation == OldGen && _old_gen->should_collect(full, size, is_tlab)) {
      if (!complete) {
        increment_total_full_collections();
      }
      if (do_young_collection) {
        // 已经进行了一次yuongGC
        GCIdMarkAndRestore gc_id_mark;
        collect_generation(_old_gen, full, size, is_tlab, run_verification && VerifyGCLevel <= 1, do_clear_all_soft_refs, true);
      } else {
        // No young GC done. Use the same GC id as was set up earlier in this method.
        collect_generation(_old_gen, full, size, is_tlab, run_verification && VerifyGCLevel <= 1, do_clear_all_soft_refs, true);
      }
      collected_old = true;
    }
    //重新调整个代堆大小
    if (collected_old) {
      _old_gen->compute_new_size();
    }
    _young_gen->compute_new_size();
    //重新恢复偏向锁标记
    if (must_restore_marks_for_biased_locking) {
      BiasedLocking::restore_marks();
    }
  }
}

hotspot/src/share/vm/gc/shared/genCollectedHeap.cpp
调用具体的分代去回收

void GenCollectedHeap::collect_generation(Generation* gen,...) {
    gen->collect(full, clear_soft_refs, size, is_tlab);
   
}

3.年轻代回收

hotspot/src/share/vm/gc/serial/defNewGeneration.cpp
年轻代回收，使用复制算法，将Eden空间的对象拷贝提升到to空间。各Closure分别对应各种对象遍历操作。主要流程：

  1. 遍历堆空间，线程栈等root引用链，将对象提升。
  2. 遍历所有promote到老年代的对象，恢复其对象头。
  3. Survivor的form和to空间交换。
void DefNewGeneration::collect(bool   full,bool   clear_all_soft_refs,size_t size,bool   is_tlab) {
  GenCollectedHeap* gch = GenCollectedHeap::heap();
  _old_gen = gch->old_gen();
  // These can be shared for all code paths
  IsAliveClosure is_alive(this);
  ScanWeakRefClosure scan_weak_ref(this);
  age_table()->clear();
  to()->clear(SpaceDecorator::Mangle);
  // The preserved marks should be empty at the start of the GC.
  _preserved_marks_set.init(1);
  gch->rem_set()->prepare_for_younger_refs_iterate(false);
  // Not very pretty.
  CollectorPolicy* cp = gch->collector_policy();
  FastScanClosure fsc_with_no_gc_barrier(this, false);
  FastScanClosure fsc_with_gc_barrier(this, true);
  KlassScanClosure klass_scan_closure(&fsc_with_no_gc_barrier, gch->rem_set()->klass_rem_set());
  CLDToKlassAndOopClosure cld_scan_closure(&klass_scan_closure, &fsc_with_no_gc_barrier,false);
  set_promo_failure_scan_stack_closure(&fsc_with_no_gc_barrier);
  FastEvacuateFollowersClosure evacuate_followers(gch,&fsc_with_no_gc_barrier,&fsc_with_gc_barrier);
  {
    gch->young_process_roots(&srs,
                             &fsc_with_no_gc_barrier,
                             &fsc_with_gc_barrier,
                             &cld_scan_closure);
  }
  //遍历所有promote到老年代的对象，恢复其对象头，遍历其引用类型属性
  evacuate_followers.do_void();

  FastKeepAliveClosure keep_alive(this, &scan_weak_ref);
  ReferenceProcessor* rp = ref_processor();
  rp->setup_policy(clear_all_soft_refs);
  const ReferenceProcessorStats& stats =
  rp->process_discovered_references(&is_alive, &keep_alive, &evacuate_followers,
                                    NULL, _gc_timer);

  if (!_promotion_failed) {
    swap_spaces();
    adjust_desired_tenuring_threshold();
  } else {
    swap_spaces();   // For uniformity wrt ParNewGeneration.
    from()->set_next_compaction_space(to());
    gch->set_incremental_collection_failed();
  }

}

hotspot/src/share/vm/gc/shared/genCollectedHeap.cpp
根对象遍历

void GenCollectedHeap::young_process_roots(StrongRootsScope* scope,
                                           OopsInGenClosure* root_closure,
                                           OopsInGenClosure* old_gen_closure,
                                           CLDClosure* cld_closure) {
  MarkingCodeBlobClosure mark_code_closure(root_closure, CodeBlobToOopClosure::FixRelocations);
  process_roots(scope, SO_ScavengeCodeCache, root_closure, root_closure,
                cld_closure, cld_closure, &mark_code_closure);
  process_string_table_roots(scope, root_closure);
  //......
}

hotspot/src/share/vm/gc/shared/genCollectedHeap.cpp
根对象遍历，Universe::oops_do是对堆空间的遍历，其他如线程栈上根对象的引用遍历未列出

void GenCollectedHeap::process_roots(StrongRootsScope* scope,
                                     ScanningOption so,
                                     OopClosure* strong_roots,
                                     OopClosure* weak_roots,
                                     CLDClosure* strong_cld_closure,
                                     CLDClosure* weak_cld_closure,
                                     CodeBlobToOopClosure* code_roots) {
  if (!_process_strong_tasks->is_task_claimed(GCH_PS_ClassLoaderDataGraph_oops_do)) {
    ClassLoaderDataGraph::roots_cld_do(strong_cld_closure, weak_cld_closure);
  }
  // Only process code roots from thread stacks if we aren't visiting the entire CodeCache anyway
  CodeBlobToOopClosure* roots_from_code_p = (so & SO_AllCodeCache) ? NULL : code_roots;
  bool is_par = scope->n_threads() > 1;
  Threads::possibly_parallel_oops_do(is_par, strong_roots, roots_from_code_p);
  if (!_process_strong_tasks->is_task_claimed(GCH_PS_Universe_oops_do)) {
    Universe::oops_do(strong_roots);
  }
  //......
 
}

hotspot/src/share/vm/memory/universe.cpp
OopClosure对应FastScanClosure

void Universe::oops_do(OopClosure* f, bool do_all) {

  f->do_oop((oop*) &_int_mirror);
  //......
}

hotspot/src/share/vm/gc/serial/defNewGeneration.cpp

void FastScanClosure::do_oop(oop* p)       { FastScanClosure::do_oop_work(p); }

hotspot/src/share/vm/gc/shared/genOopClosures.inline.hpp
这里进行对象提升等操作，具体copy_to_survivor_space

template <class T> inline void FastScanClosure::do_oop_work(T* p) {
  T heap_oop = oopDesc::load_heap_oop(p);
  // Should we copy the obj?
  if (!oopDesc::is_null(heap_oop)) {
    oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
    if ((HeapWord*)obj < _boundary) {
      assert(!_g->to()->is_in_reserved(obj), "Scanning field twice?");
      oop new_obj = obj->is_forwarded() ? obj->forwardee()
                                        : _g->copy_to_survivor_space(obj);
      oopDesc::encode_store_heap_oop_not_null(p, new_obj);
      if (is_scanning_a_klass()) {
        do_klass_barrier();
      } else if (_gc_barrier) {
        // Now call parent closure
        do_barrier(p);
      }
    }
  }
}

hotspot/src/share/vm/gc/serial/defNewGeneration.cpp
如果是to空间不足则提升到老年代空间，老年代空间不足时将触发FullGC

oop DefNewGeneration::copy_to_survivor_space(oop old) {
  size_t s = old->size();
  oop obj = NULL;

  // 尝试在to空间分配
  if (old->age() < tenuring_threshold()) {
    obj = (oop) to()->allocate_aligned(s);
  }

  //尝试在老年代分配
  if (obj == NULL) {
    obj = _old_gen->promote(old, s);
    if (obj == NULL) {
      handle_promotion_failure(old);
      return old;
    }
  } else {
    // Copy obj
    Copy::aligned_disjoint_words((HeapWord*)old, (HeapWord*)obj, s);
    // 递增年龄
    obj->incr_age();
    age_table()->add(obj, s);
  }

  // Done, insert forward pointer to obj in this header
  old->forward_to(obj);

  return obj;
}

4.老年代回收

hotspot/src/share/vm/gc/serial/tenuredGeneration.cpp
老年代收集，使用标记压缩算法，特点是节省空间，防止内存碎片化

void TenuredGeneration::collect(bool   full,
                                bool   clear_all_soft_refs,
                                size_t size,
                                bool   is_tlab) {
  GenCollectedHeap* gch = GenCollectedHeap::heap();
  //进入收集器
  GenMarkSweep::invoke_at_safepoint(ref_processor(), clear_all_soft_refs);

}

hotspot/src/share/vm/gc/serial/genMarkSweep.cpp
老年代收集流程如下：

  1. 使用标记栈标记存活对象
  2. 为标记栈中的对象计算一个新地址
  3. 将新地址更新到对象指针
  4. 移动对象到新地址处
void GenMarkSweep::invoke_at_safepoint(ReferenceProcessor* rp, bool clear_all_softrefs) {
  GenCollectedHeap* gch = GenCollectedHeap::heap();
  set_ref_processor(rp);
  rp->setup_policy(clear_all_softrefs);
  CodeCache::gc_prologue();
  // Increment the invocation count
  _total_invocations++;
  gch->save_used_regions();
  //分配标记栈
  allocate_stacks();
  //标记存活的对象
  mark_sweep_phase1(clear_all_softrefs); 
 //为存活的对象计算一个新的地址
  mark_sweep_phase2();
  //更新存活对象的对象指针
  mark_sweep_phase3();
  //移动存活对象到新的地址处
  mark_sweep_phase4();
  //销毁标记栈
  deallocate_stacks();
  //清除卡表信息
  CardTableRS* rs = gch->rem_set();
  Generation* old_gen = gch->old_gen();
  //不存在引用，则清空。否则刷新
  if (gch->young_gen()->used() == 0) {
    // We've evacuated the young generation.
    rs->clear_into_younger(old_gen);
  } else {
    rs->invalidate_or_clear(old_gen);
  }

}

每一种收集算法都有自己的适用场景。如分代是基于大量对象存活周期较短的原则上产生的。标记压缩是基于空间利用率产生的。复制算法是基于回收效率因素产生的。而收集器是依据问题空间的大小来挑选合适的算法组建的。因此每种收集器都有其适用范围。虚拟机调优便是在问题空间和解空间找到最佳平衡点，这需要对虚拟机的足够了解也需要实践经验。

SherlockCharlie
关注
专栏目录
5.3HotSpot VM 的垃圾收集器
十年呵护的专栏
09-05 550
HotSpot VM 垃圾收集器 一、前言 垃圾收集器是垃圾回收算法（标记-清除算法、复制算法、标记-整理算法、火车算法）的具体实现，不同商家、不同版本的JVM所提供的垃圾收集器可能会有很在差别，本文主要介绍HotSpot虚拟机中的垃圾收集器。 二、HotSpot VM介绍 JDK7/8后，HotSpot虚拟机所有收集器及组合（连线），如下图 （A）图中展示了7种不同分代的收集器： ​ Serial、ParNew、Parallel Scavenge、Serial Old、Parallel
HotSpot垃圾收集器
微信搜：import_bigdata，大数据领域硬核原创作者
02-20 339
GitHub：https://github.com/wangzhiwubigdata/God-Of-BigData 关注公众号,内推,面试,资源下载,关注更多大数据技术~ 大数据成神之路~预计更新500+篇文章，已经更新50+篇~ HotSpot垃圾收集器 HotSpot 虚拟机提供了多种垃圾收集器，每种收集...
JVM篇-结合源码分析JVM堆内存&元空间的申请分配
Feverasa的博客
02-28 1166
一、堆内存的结构 1、结构图 ​ 我们可以看到官方给的这张图。可以看到其堆可以有两种分配类型：一种就是JVM申请提交的内存(committed)以及目前还没有使用到的内存(Virtual)，另一种就是按照分代的概念：年轻代(Young Generation)老年代(Tenured Generation)。 ​ 同时根据这个结构图我们可以知道在代与代之间还有空出来暂时没有使用到的内存。 2、年轻代&老年代分配 ​ 我们可以看到在年轻代是有两个概念的划分的：Eden、Survivor，然后Surviv
Java GC 源码分析(1)
Aegeaner的专栏
11-05 3255
Java GC 源码分析(1)System.gc()入口hotspot/src/share/vm/memory/universe.cpp：jint Universe::initialize_heap() { if (UseParallelGC) { #if INCLUDE_ALL_GCS Universe::_collectedHeap = new ParallelScavengeHeap
HotSpot 类解析
Sherlock的博客
08-17 1324
上一篇了解了Java字节码文件组织结构，继HotSpot类加载后本篇来探讨HotSpot类解析。Java字节码文件是以二进制流的形式由HotSpot加载，然后HotSpot将字节码解析转换成虚拟机内部的对象模型。并将这个对象模型存储在虚拟机的元空间供虚拟机引擎重复使用。所以关于类解析有三个问题：类如何被解析，对象模型是什么样的，元空间（MetaSpace）的存储结构。在类加载一篇我们知道字节码的二进制流由ClassFileStream加载到内存，然后由ClassFileParser解析。 一，HotSpot
JVM源码分析之自定义类加载器如何拉长YGC
weixin_34187862的博客
04-10 130
概述 本文重点讲述毕玄大师在其公众号上发的一个GC问题一个jstack/jmap等不能用的case，对于毕大师那篇文章，题目上没有提到GC的那个问题，不过进入到文章里可以看到，既然文章提到了jstack/jmap的问题，这里也简单回答下jstack/jmap无法使用的问题，其实最常见的场景是使用jstack/jmap的用户和目标进程不是同一个用户，哪...
Hotspot GC Root 对应调用链
lxlmycsdnfree的博客
07-11 1033
GC Root GC Root全称是garbage collection root, 即垃圾回收的根. 回到我们的葡萄比喻上来, 也就是一串葡萄的柄. 实际上JVM中的GC Root不只一个, 也就是多个这样的 “柄”.   来看看hotspot网站的解释: garbage collection root A pointer into the Java object heap from...
深入探索JVM垃圾收集器 — 经典垃圾收集器之Serial收集器、ParNew收集器
cupkss的博客
09-13 186
Serial收集器 （基于 标记-复制算法 新生代）、ParNew收集器 （基于 标记-复制算法 新生代）
【HotSpot、G1】垃圾回收算法和垃圾收集器
05-03 968
前言 上一篇我们说了如何判断一个对象是否存活，这一篇呢，就是接着前面几篇文章来的，我们知道堆中分为年轻代和老年代，有着不同的特点；每个区域有着不同的特点，也就有了多种垃圾回收算法，每种算法也是根据内存情况进行不同程度的优化 就像上一篇提到的打扫屋子，接下来就是需要找到打扫屋子的最合适的方法，比如屋子的哪些东西归为一类，哪些可以扔掉，哪些可以摆放到一起 JVM的算法有很多，大鱼这里只说比较常见的四种： 标记-清楚算法 复制算法 标记-整理算法 分代收集算法 说完了算法，就会介绍下JVM的流行的各种收集器，.
深入探索JVM垃圾收集器 — 经典垃圾收集器之Parallel Scavenge收集器、Serial Old收集器、Parallel Old收集器
cupkss的博客
09-13 1069
Parallel Scavenge收集器、Serial Old收集器、Parallel Old收集器
[Java JVM] Hotspot GC研究- 串行GC(Serial GC)实现解析
lqp276的博客
09-07 1232
Serial GC 介绍串行GC是hotspot中最简单的一种GC, 不过麻雀虽小, 五脏俱全. 除了速度相较其他几种GC比较慢之外, 完成的功能是一样的: 回收不再使用的对象, 为新的对象分配空间. 从简单的情况下手, 我们可以撇去很多边边角角的细节, 从而更好的接近事物的本质, 对于研究GC, 道理也是如此.Serial GC 的内存分布Serial GC的heap采用的是分代分布, 默认情况下
关于死锁以及如何查看线程是否有死锁
Objectobj的博客
04-14 1860
在 Java 的并发编程中，有一个问题需要特别注意，那就是死锁，如果发生了死锁，基本就是重启，而重启将会丢失运行中的数据。所以，了解死锁的形成并排查死锁到预防死锁成了一个重要的问题。 什么是死锁？ package cn.sxt.game; /* 死锁 * * */ public class DeadLock { public static void main(String[] args...
源码分析HotSpot GC过程(二)：DefNewGeneration的GC过程
weixin_34242658的博客
12-08 205
　　由于虚拟机的分代实现，虚拟机不会考虑各个内存代如何实现垃圾回收，具体的工作(对象内存的分配也是一样)由各内存代根据垃圾回收策略自行实现。 　　DefNewGeneration的使用复制算法进行回收。复制算法的思想是将eden和from区活跃的对象复制到to区，并清空eden区和from区，如果to区满了，那么部分对象将会被晋升移动到老年代，随后交换from和to区，即原来的to区存放了存活的...
【理解HotSpot虚拟机】串行垃圾收集器Serial和Serial Old原理
linxd
10-03 4605
转载请注明出处：http://blog.csdn.net/linxdcn/article/details/73839685 上一篇GC垃圾收集器的对比分析分析和对比了JVM中常见的垃圾收集器，本篇先来探究串行垃圾收集器的原理。 1 Serial 收集器 Serial 收集器是在 DefNewGeneration 新生代上实现收集的，DefNewGeneration上分为3个区：e
JVM垃圾回收
懒猫的脚印
03-10 503
通过《编译原理》系列文章，我们可以创造出运行环境，然后根据程序的语义直接执行，也可能翻译成中间代码(机器码，汇编码)。这两种方式分别被称为解释执行和编译执行。 JVM中的编译器 在部分商用虚拟机中（如HotSpot），Java程序最初是通过解释器（Interpreter）进行解释执行的，当虚拟机发现某个方法或代码块的运行特别频繁时，就会把这些代码认定为“热点代码”。为了提高热点代码的执行效率，在运...
Java GC 源码分析(2)
Aegeaner的专栏
11-05 701
Mark-Sweep Policy 类继承关系：CollectorPolicy=>GenCollectorPolicy =>TwoGenerationCollectorPolicy TwoGenerationCollectorPolicy类： class TwoGenerationCollectorPolicy : public GenCollectorPolicy { protected:
G1垃圾收集器调优-精简版
augsm的专栏
12-25 871
本篇是对Java官网G1收集器调优的精简版。针对G1垃圾的收集阶段可能出现的问题，非合理内存分配，大对象占用，Full GC等问题作出解决方式和操作参数。
IL2CPP 深入讲解：方法调用介绍（四）
阿龙的博客
09-09 5254
IL2CPP深入讲解：方法调用介绍 IL2CPP INTERNALS: METHOD CALLS 作者：JOSH PETERSON 翻译：Bowie 这里是本系列的第四篇博文。在这篇文章里，我们将看到il2cpp.exe如何为托管代码中的各种函数调用生成C++代码。我们在这里会着重的分析6种不同类型的函数调用： 类实例的成员函数调用和类的静态函数调用。 编译期生成的代理函数调用
JVM堆模型、GC垃圾算法
黑白猪的世界
06-20 178
基本概念 堆/Heap JVM管理的内存叫堆；在32Bit操作系统上有4G的限制，一般来说Windows下为2G，而Linux 下为3G；64Bit的就没有这个限制。 JVM初始分配的内存由-Xms指定，默认是物理内存的1/64但小于1G。 JVM最大分配的内存由-Xmx指定，默认是物理内存的1/4但小于1G。 默认空余堆内存小于40%时，JVM就会增大堆直到-Xmx的最大限制，可以由 ...
Java Hotspot JVM垃圾收集基础教程
在教程的第二部分，逐步解释了垃圾收集的过程，包括新生代和老年代的内存分配、Minor和Full GC的区别、以及不同收集器（如Serial、Parallel、CMS和G1等）的工作机制和适用场景。这些内容有助于读者理解垃圾收集策略...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值