HotSpot CMS收集器

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

HotSpot中CMS收集器通过牺牲系统吞吐量来实现响应速度优先。适合追求垃圾收集速度的服务器上。

  1. CMS收集器属于分代收集器
  2. 年轻代算法并发复制算法，老年代算法为并发标记清除算法。
  3. 年轻代分代为ParNewGeneration，老年代分代为ConcurrentMarkSweepGeneration。
  4. 适用于对响应时间要求高的应用场景。

一.CMS收集器初始化

使用-XX:+UseConcMarkSweepGC启用CMS。
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
使用UseConcMarkSweepGC策略创建堆,和Serial收集器一样使用分代堆GenCollectedHeap,收集策略为ConcurrentMarkSweepPolicy继承自分代策略GenCollectorPolicy

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
分代堆创建WorkGang

GenCollectedHeap::GenCollectedHeap(GenCollectorPolicy *policy) :
  CollectedHeap(),...
{
  //创建WorkGang来管理GC线程
  if (UseConcMarkSweepGC) {
    _workers = new WorkGang("GC Thread", ParallelGCThreads,
                            /* are_GC_task_threads */true,
                            /* are_ConcurrentGC_threads */false);
    _workers->initialize_workers();
  } else {
    // Serial GC does not use workers.
    _workers = NULL;
  }
}

hotspot/src/share/vm/gc/shared/genCollectedHeap.cpp
创建CMSCollector

jint GenCollectedHeap::initialize() {
 ......
#if INCLUDE_ALL_GCS
  // If we are running CMS, create the collector responsible
  // for collecting the CMS generations.
  if (collector_policy()->is_concurrent_mark_sweep_policy()) {
    bool success = create_cms_collector();
  }
#endif // INCLUDE_ALL_GCS

  return JNI_OK;
}

hotspot/src/share/vm/gc/cms/concurrentMarkSweepGeneration.cpp
初始化CMSCollector，创建YieldingFlexibleWorkGang管理CMS GC线程，创建后台常驻线程ConcurrentMarkSweepThread用于CMS后台垃圾收集

CMSCollector::CMSCollector(ConcurrentMarkSweepGeneration* cmsGen,...): ...
{
  _cmsGen->cmsSpace()->set_collector(this);
  _markBitMap.allocate(_span)//位图
  _modUnionTable.allocate(_span);
  _markStack.allocate(MarkStackSize)//标记栈
  //多线程收集创建YieldingFlexibleWorkGang，管理CMS GC Thread
  //为每个线程创建一个任务队列
   if (ConcGCThreads > 1) {
      _conc_workers = new YieldingFlexibleWorkGang("CMS Thread",ConcGCThreads, true);
      _conc_workers->initialize_workers();
   	  _task_queues = new OopTaskQueueSet(num_queues);
      for (i = 0; i < num_queues; i++) {
        PaddedOopTaskQueue *q = new PaddedOopTaskQueue();
        _task_queues->register_queue(i, q);
      }
      for (i = 0; i < num_queues; i++) {
        _task_queues->queue(i)->initialize();
        _hash_seed[i] = 17;  // copied from ParNew
      }
    }
  }
  // 后台长期运行的CMS线程，用于CMS后台垃圾收集
  _cmsThread = ConcurrentMarkSweepThread::start(this);

}

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


#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/cms/parNewGeneration.cpp
继承自串行收集器的年轻代DefNewGeneration

ParNewGeneration::ParNewGeneration(ReservedSpace rs, size_t initial_byte_size)
  : DefNewGeneration(rs, initial_byte_size, "PCopy"),
{
  //创建任务队列集合
  _task_queues = new ObjToScanQueueSet(ParallelGCThreads);
  //每一个收集线程对应一个队列
  for (uint i = 0; i < ParallelGCThreads; i++) {
    ObjToScanQueue *q = new ObjToScanQueue();
    guarantee(q != NULL, "work_queue Allocation failure.");
    _task_queues->register_queue(i, q);
  }
  //初始化任务队列
  for (uint i = 0; i < ParallelGCThreads; i++) {
    _task_queues->queue(i)->initialize();
  }
}

hotspot/src/share/vm/gc/cms/concurrentMarkSweepGeneration.cpp
同串行收集器一样继承自CardGeneration

ConcurrentMarkSweepGeneration::ConcurrentMarkSweepGeneration(
     ReservedSpace rs, size_t initial_byte_size, CardTableRS* ct) :
  CardGeneration(rs, initial_byte_size, ct),
  _dilatation_factor(((double)MinChunkSize)/((double)(CollectedHeap::min_fill_size()))),
  _did_compact(false)
{
  HeapWord* bottom = (HeapWord*) _virtual_space.low();
  HeapWord* end    = (HeapWord*) _virtual_space.high();
  //映射一块空间
  _cmsSpace = new CompactibleFreeListSpace(_bts, MemRegion(bottom, end));
  _cmsSpace->_old_gen = this;
  _gc_stats = new CMSGCStats();
  //为每一个线程创建一个CMSParGCThreadState
  _par_gc_thread_states = NEW_C_HEAP_ARRAY(CMSParGCThreadState*, ParallelGCThreads, mtGC);
  for (uint i = 0; i < ParallelGCThreads; i++) {
    _par_gc_thread_states[i] = new CMSParGCThreadState(cmsSpace());
  }

}

二.垃圾收集

CMS的年轻代，老年代的分代，堆空间，收集策略和Serial收集器类似，不再赘述。参考Serial收集器一篇。

1.年轻代GC

hotspot/src/share/vm/gc/cms/parNewGeneration.cpp
CMS的年轻代GC总是由收集策略决定，从模板策略函数collect进入。同Serial收集器一样，使用复制算法，将Eden空间的对象拷贝提升到to空间。各Closure分别对应各种对象遍历操作。主要流程：

  1. 遍历堆空间，线程栈等root引用链，将对象提升。
  2. 遍历所有promote到老年代的对象，恢复其对象头。
  3. Survivor的form和to空间交换。
void ParNewGeneration::collect(bool   full,
                               bool   clear_all_soft_refs,
                               size_t size,
                               bool   is_tlab) {
  //年轻代堆
  GenCollectedHeap* gch = GenCollectedHeap::heap();
  //自适应收集策略
  AdaptiveSizePolicy* size_policy = gch->gen_policy()->size_policy();
  //多GC线程管理
  WorkGang* workers = gch->workers();
  //计算活跃的GC工作线程
  uint active_workers =
       AdaptiveSizePolicy::calc_active_workers(workers->total_workers(),
                                               workers->active_workers(),
                                               Threads::number_of_non_daemon_threads());
  active_workers = workers->update_active_workers(active_workers);
  //获取老年代
  _old_gen = gch->old_gen();
  //是否使用自适应策略
  if (UseAdaptiveSizePolicy) {
    set_survivor_overflow(false);
    size_policy->minor_collection_begin();
  }
  age_table()->clear();
  to()->clear(SpaceDecorator::Mangle);
  gch->save_marks();
  // Set the correct parallelism (number of queues) in the reference processor
  ref_processor()->set_active_mt_degree(active_workers);
  _preserved_marks_set.init(active_workers);
  //并发任务终结者
  ParallelTaskTerminator _term(active_workers, task_queues());
  //线程任务状态集合
  ParScanThreadStateSet thread_state_set(active_workers,
                                         *to(), *this, *_old_gen, *task_queues(),
                                         _overflow_stacks, _preserved_marks_set,
                                         desired_plab_sz(), _term);
  thread_state_set.reset(active_workers, promotion_failed());

  {
    StrongRootsScope srs(active_workers);
    //创建任务
    ParNewGenTask tsk(this, _old_gen, reserved().end(), &thread_state_set, &srs);
    gch->rem_set()->prepare_for_younger_refs_iterate(true);
    //派发任务
    if (workers->total_workers() > 1) {
      workers->run_task(&tsk);
    } else {
      tsk.work(0);
    }
  }
  ReferenceProcessor* rp = ref_processor();
  IsAliveClosure is_alive(this);
  ScanWeakRefClosure scan_weak_ref(this);
  KeepAliveClosure keep_alive(&scan_weak_ref);
  ScanClosure               scan_without_gc_barrier(this, false);
  ScanClosureWithParBarrier scan_with_gc_barrier(this, true);
  set_promo_failure_scan_stack_closure(&scan_without_gc_barrier);
  EvacuateFollowersClosureGeneral evacuate_followers(gch,
    &scan_without_gc_barrier, &scan_with_gc_barrier);
  rp->setup_policy(clear_all_soft_refs);
  // Can  the mt_degree be set later (at run_task() time would be best)?
  rp->set_active_mt_degree(active_workers);
  ReferenceProcessorStats stats;
  if (rp->processing_is_mt()) { //多线程
    ParNewRefProcTaskExecutor task_executor(*this, *_old_gen, thread_state_set);
    stats = rp->process_discovered_references(&is_alive, &keep_alive,
                                              &evacuate_followers, &task_executor,
                                              _gc_timer);
  } else {
    thread_state_set.flush();
    gch->save_marks();
    stats = rp->process_discovered_references(&is_alive, &keep_alive,
                                              &evacuate_followers, NULL,
                                              _gc_timer);
  }
  if (!promotion_failed()) { //提升失败
    // Swap the survivor spaces.
    eden()->clear(SpaceDecorator::Mangle);
    from()->clear(SpaceDecorator::Mangle);
    swap_spaces();
    size_policy->reset_gc_overhead_limit_count();
    adjust_desired_tenuring_threshold();
  } else {
    handle_promotion_failed(gch, thread_state_set);
  }
}

2.老年代前台GC

老年代GC主要使用CMS算法。分为前后台收集方式。前台收集由用户触发。后台GC由常驻线程ConcurrentMarkSweepThread 定时等待触发。

jdk/src/java.base/share/native/libjava/Runtime.c
上一篇在触发GC的代码中我们循环创建大对象来触发GC，使用System.gc()来触发CMS的FullGC。

JNIEXPORT void JNICALL
Java_java_lang_Runtime_gc(JNIEnv *env, jobject this)
{
    JVM_GC();
}

hotspot/src/share/vm/prims/jvm.cpp
可以使用DisableExplicitGC来禁止触发FullGC

JVM_ENTRY_NO_ENV(void, JVM_GC(void))
  JVMWrapper("JVM_GC");
  if (!DisableExplicitGC) {
    Universe::heap()->collect(GCCause::_java_lang_system_gc);
  }
JVM_END

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

void GenCollectedHeap::collect(GCCause::Cause cause) {
 // Stop-the-world full collection.
    collect(cause, OldGen);
    ......
}

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

void GenCollectedHeap::collect(GCCause::Cause cause, GenerationType max_generation) {
  collect_locked(cause, max_generation);
}

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

void GenCollectedHeap::collect_locked(GCCause::Cause cause, GenerationType max_generation) {
  {
    MutexUnlocker mu(Heap_lock);  // give up heap lock, execute gets it back
    VM_GenCollectFull op(gc_count_before, full_gc_count_before,
                         cause, max_generation);
    VMThread::execute(&op); //触发FullGc
  }
}

hotspot/src/share/vm/gc/cms/concurrentMarkSweepGeneration.cpp
GC触发后将由收集策略转发到这里执行

void ConcurrentMarkSweepGeneration::collect(bool   full,...)
{
  collector()->collect(full, clear_all_soft_refs, size, tlab);
}

hotspot/src/share/vm/gc/cms/concurrentMarkSweepGeneration.cpp

void CMSCollector::collect(bool   full,...)
{
  acquire_control_and_collect(full, clear_all_soft_refs);
}

hotspot/src/share/vm/gc/cms/concurrentMarkSweepGeneration.cpp
使用同串行收集器老年代一样的收集算法

  1. 使用标记栈标记存活对象
  2. 为标记栈中的对象计算一个新地址
  3. 将新地址更新到对象指针
  4. 移动对象到新地址处
void CMSCollector::do_compaction_work(bool clear_all_soft_refs) {
  GenCollectedHeap* gch = GenCollectedHeap::heap();
  ....
  GenMarkSweep::invoke_at_safepoint(ref_processor(), clear_all_soft_refs);
  ....
}

3.老年代后台GC

后台常驻线程ConcurrentMarkSweepThread启动后会一直循环检测GC条件，触发后台GC

void ConcurrentMarkSweepThread::run_service() {

  while (!should_terminate()) {
    sleepBeforeNextCycle();
    if (should_terminate()) break;
    GCIdMark gc_id_mark;
    GCCause::Cause cause = _collector->_full_gc_requested ?
      _collector->_full_gc_cause : GCCause::_cms_concurrent_mark;
    _collector->collect_in_background(cause);
  }
}

hotspot/src/share/vm/gc/cms/concurrentMarkSweepGeneration.cpp
后台GC采用并发标记清除算法，流程如下：

  1. 初始标记(CMS-initial-mark) ,会导致stw，标记老年代中所有的GC Roots对象，标记年轻代中活着的对象引用到的老年代的对象
  2. 并发标记(CMS-concurrent-mark)，与用户线程同时运行，并发标记阶段只负责将引用发生改变的Card标记为Dirty状态，不负责处理
  3. 预清理（CMS-concurrent-preclean），与用户线程同时运行，这个阶段就是用来处理前一个阶段因为引用关系改变导致没有标记到的存活对象的，它会扫描所有标记为Dirty的Card
  4. 可被终止的预清理（CMS-concurrent-abortable-preclean） 与用户线程同时运行，试着去承担下一个阶段Final Remark阶段足够多的工作
  5. 重新标记(CMS-remark) ，会导致swt，该阶段的任务是完成标记整个年老代的所有的存活对象。
  6. 并发清除(CMS-concurrent-sweep)，与用户线程同时运行，这个阶段主要是清除那些没有标记的对象并且回收空间，伴随程序运行自然就还会有新的垃圾不断产生，这一部分垃圾出现在标记过程之后，CMS无法在当次收集中处理掉它们
  7. 并发重置状态等待下次CMS的触发(CMS-concurrent-reset)，与用户线程同时运行；
void CMSCollector::collect_in_background(GCCause::Cause cause) {
  GenCollectedHeap* gch = GenCollectedHeap::heap();
  size_t prev_used = _cmsGen->used();
    switch (_collectorState) { //初始标记触发VM_CMS_Initial_Mark
      case InitialMarking:
        {
          ReleaseForegroundGC x(this); //加锁
          stats().record_cms_begin();
          VM_CMS_Initial_Mark initial_mark_op(this);
          VMThread::execute(&initial_mark_op);
        }
        break;
      case Marking: // 并发标记
        // initial marking in checkpointRootsInitialWork has been completed
        markFromRoots()
        break;
      case Precleaning: //预清理
        // marking from roots in markFromRoots has been completed
        preclean();
        break;
      case AbortablePreclean: //可被终止的预清理
        abortable_preclean();
        break;
      case FinalMarking: //重新标记
        {
          ReleaseForegroundGC x(this);
          VM_CMS_Final_Remark final_remark_op(this);
          VMThread::execute(&final_remark_op);
        }
        break;
      case Sweeping:  //并发清除
        // final marking in checkpointRootsFinal has been completed
        sweep();
      case Resizing: {
        {
          ReleaseForegroundGC x(this);   // 解锁
          MutexLockerEx       y(Heap_lock, Mutex::_no_safepoint_check_flag);
          CMSTokenSync        z(true);   // not strictly needed.
          if (_collectorState == Resizing) {
            compute_new_size();
            save_heap_summary();
            _collectorState = Resetting;
          } 
        }
        break;
      }
      case Resetting:  //并发重置状态等待下次CMS的触发
        // CMS heap resizing has been completed
        reset_concurrent();
        MetaspaceGC::set_should_concurrent_collect(false);
        stats().record_cms_end();
        break;
      case Idling:
      default:
        ShouldNotReachHere();
        break;
    }
  }
}

CMS收集器将标记清除切分为数个阶段，其中一些阶段可与应用程序一起运行，这会占用一部分系统资源，导致系统吞吐量降低，需要STW的回收阶段用时变小了，这部分耗时相对减少了，所以系统的响应速度提升了。

SherlockCharlie
关注
专栏目录
Hotspot CMS算法实现总结 (一)
菜鸟进阶之路
03-01 1823
目录 一、数据结构 1、Java堆 2、CodeCache 3、MetaSpace 二、关键类/方法 1、oop/Klass 2、oop_iterate / adjust_pointers /follow_contents 3、ReferenceProcessor 4、markOop / promote / forward 5、GC_locker 和JNI关键区 ...
JVM中的CMS收集器
JYYabc的博客
12-13 192
​ CMS收集器 CMS（Concurrent Mark Sweep）收集器是一种以获取最短回收停顿时间为目标的收集器；这款收集器是HotSpot虚拟机中第一款真正意义上支持并发的垃圾收集器，首次实现了让垃圾收集线程与用户线程（基本上）同时工作。 适用于：互联网网站或者基于浏览器的B/S系统的服务端 基于标记-清除算法实现的，具体步骤分为4步： 1.初始标记：Stop The World -> 标记一下GC Roots能直接关联到的对象，速度很快 2.并发标记:从GC Roots的直接关联对象开始遍
Hotspot CMS 垃圾收集器要退休了？
yiyeguhu的博客
08-22 579
日前，Hotspot JVM开发者小组召开了一次视频会议来讨论CMS 垃圾收集器的“退休”事宜（ http://openjdk.java.net/jeps/291）。此次会议是Hotspot开发者小组在邮件列表里线上讨论的延伸，主要的参与方是来自甲骨文、谷歌、RedHat、SAP、推特等公司的工程师们。
GC问题排查实战五-G1日志分析以及动态年龄调整机制
王伟王胖胖的博客
03-19 1425
GC问题排查实战五-G1日志分析以及动态年龄调整机制G1分析参数跑完后数据gc日志数据safepoint相关数据动态年龄调整机制(ParNew做例子)hotspot相关源码jdk1.8-b26哪些收集器会用到这个机制这个机制在哪个阶段被使用年龄阈值在哪个阶段被使用总结 G1分析 这次我们用G1试试。 参数 -Xms8192M -Xmx8192M -Xmn4096M -Xss1M -XX:+UseG1GC -XX:+PrintTenuringDistribution -XX:+PrintHeapAtGC -
面试必备：CMS垃圾收集器与G1收集器
大数据星球-浪尖
03-27 1万+
1、CMS收集器  CMS收集器是一种以获取最短回收停顿时间为目标的收集器。基于“标记-清除”算法实现，它的运作过程如下：1）初始标记2）并发标记3）重新标记4）并发清除  初始标记、从新标记这两个步骤仍然需要“stop the world”，初始标记仅仅只是标记一下GC Roots能直接关联到的对象，熟读很快，并发标记阶段就是进行GC Roots Tracing，而重新标记阶段则是为了修正并发标
JVM崩溃日志分析1
坐忘峰
03-14 2万+
最先线上的一个tomcat总是无缘无故崩溃，tomcat日志里又没有报任何错误，于是调出JVM的崩溃日志查看，一般崩溃日志在启动目录下，比如tomcat的bin目录下，但是如果你用自己写的脚本启动的tomcat，则这个日志可能就在你放脚本的目录下。 # # A fatal error has been detected by the Java Runtime Environment: #
性能工程师指南：玩转OpenJDK HotSpot垃圾收集器
05-14
### 性能工程师指南：玩转OpenJDK HotSpot垃圾收集器 #### 一、性能工程概述 在软件开发过程中，性能工程是一个重要的环节，它不仅涵盖了对软件性能的需求定义与测试计划制定，还包括了软件的开发、实施及后续的...
JVM实用参数-CMS收集器
dcm19920115的博客
05-30 865
HotSpot JVM的并发标记清理收集器(CMS收集器)的主要目标就是：低应用停顿时间。该目标对于大多数交互式应用很重要，比如web应用。在我们看一下有关JVM的参数之前,让我们简要回顾CMS收集器的操作和使用它时可能出现的主要挑战。 就像吞吐量收集器,CMS收集器处理老年代的对象,然而其操作要复杂得多。吞吐量收集器总是暂停应用程序线程，并且可能是相当长的一段时间，然而这能够使该算法安全地忽略...
CMS垃圾收集器
最新发布
weixin_43860222的博客
06-03 714
CMS收集器时一种以获取为目标的收集器采用的是“标记-清除算法”整个过程分为4步（1）初始标记 CMS initial mark 标记GC Roots直接关联对象，不用关联整个GC Roots链，速度很快（2）并发标记 CMS concurtrent mark 进行GC Roots 整个链路的关联，因为速度很慢，所以采用并发的方式，不影响用户线程（3）重新标记 CMS remark 修改并发标记因为用户程序变动的内容。
CMS垃圾收集器详解
weixin_48377011的博客
12-13 6180
CMS垃圾回收器详解 垃圾回收器组合 young Tenured JVM options Serial SerialOld -XX:+UseSerialGC Parallel Scavenge SerialOld -XX:+UseParallelGC -XX:-UseParallelOldGC Parallel Scavenge Parallel Old -XX:+UseParallelGC -XX:+UseParallelOldGC Pa
JVM crash 错误日志分析
04-02
NULL 博文链接：https://myspace1916.iteye.com/blog/1441465
G1 与 CMS 两个垃圾收集器的对比
阿凡提煮鸡蛋
02-22 346
细节方面不同 G1 在压缩空间方面有优势。 G1 通过将内存空间分成区域（Region）的方式避免内存碎片问题。 Eden, Survivor, Old 区不再固定、在内存使用效率上来说更灵活。 G1 可以通过设置预期停顿时间（Pause Time）来控制垃圾收集时间避免应用雪崩现象。 G1 在回收内存后会马上同时做合并空闲内存的工作、而 CMS 默认是在 STW（stop the world）的时候做。 G1 会在 Young GC 中使用、而 CMS 只能在 O 区使用。 整体内容不同 吞吐量优先：G1
《hotspot实战》重点笔记
YajisamA的学习之路
05-09 867
常量池中持有Class文件中引用的虽有字符串常量、类名、接口名、字段名等所有符号信息。 类的加载过程从class文件中读取字节流，并按照虚拟机对class文件的规范解析出类或者接口，并创建相应的类或者接口。 链接是让虚拟机运行时识别有效的类或者接口类型的过程，分为验证，准备和解析三个阶段；验证是确保class文件是按照规范的格式的。准备环节为类或者接口的静态字段分配空间并默认值初始化。解析环节是将符
JVM相关面试题及答案
热门推荐
Molly
03-20 11万+
1. 类的实例化顺序，比如父类静态数据，构造函数，字段，子类静态数据，构造函数，字段，他们的执行顺序 答：先静态、先父后子。 先静态：父静态 > 子静态 优先级：父类 > 子类 静态代码块 > 非静态代码块 > 构造函数 一个类的实例化过程： 1，父类中的static代码块，当前类的static 2，顺序执行父类的普通代码块 3，父类的构造函数 4，子类普通代码块 5，子
JAVA JNI Failed to write core dump
王文萱的博客
08-15 1087
使用jni的时候，运行程序，报如下错误： 导致这种报错的直接原因就是在C++里用了空指针 这种情况其实在java会直接报空指针异常，但是C++就是比较玄学，好好排查一下有没有使用空指针，把他解决掉，就好啦 ...
内存代管理器DefNewGeneration对垃圾对象的回收(Minor Gc)
xhh198781的专栏
12-14 2946
内存堆管理器GenCollectedHeap在执行Gc回收垃圾对象的时候,无论是它自己还是垃圾回收策略MarkSweepPolicy都没有具体去规定一个垃圾对象应该如何被回收,而只是在整体上决策这次的Gc应该回收那些内存代中的垃圾对象,至于这些内存代管理器是如何做的,GenCollectedHeap并不关心. 从前文分析内存堆管理器GenCollectedHeap执行Gc策略调度内存代管理器去回收
深入解析java虚拟机：垃圾回收，最大并发标记清除垃圾回收器
m0_63213253的博客
10-26 278
CMS GC 回收策略 CMS GC的全称是最大并发标记清除垃圾回收器（Mostly Mark andSweep Garbage Collector），可以使用-XX:+UseConcMarkSweepGC开启。CMS GC的新生代清理仍然使用与Parallel GC类似的方式，即开启多个线程一起清理，且在这个过程中，Mutator线程不能工作。从算法上来说，该过程与Serial GC、Parallel GC的YGC完全一致；从逻辑上来说，该过程与Parallel GC的Young GC几乎一致，所以这
HotSpot的经典垃圾收集器
Stay Hungry,Stay Foolish
11-20 1605
HotSpot的经典垃圾收集器。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值