Parralel Scavenge 收集器工作流程

jvm初始化的时候，有个重要的步骤是全局堆的初始化,根据vm参数的不同，又会选择不同的堆实现(堆的实现在share/vm/memory中，策略选择位于share/vm/gc_implementation, 详情见Universe::initialize_heap())。server模式下启动的jvm,默认采用的全局堆实现是ParallelScavengeHeap,本文记录了jdk1.8版本的Parralel Scavenge实现,很多细节还不清楚。

一、PS收集器概览及初始化

ParallelScavengeHeap由两个区域组成，_old_gen和_young_gen,其中_young_gen又由eden，from，to三个MutableSpace组成。大致如下:

image.png

我们可以用:

-xmn500m 来指定新时代的大小为500m

-XX:SurvivorRatio=8 来指定eden区和(from+to)区占比8:1.

-XX:MaxTenuringThreshold=18 来指定晋升年龄

新生代的3个区域是连续的空间，做法是开辟一个虚拟内存,根据起始大小计算分配出eden，两个survivor区域。虚拟内存不会立马占用物理内存，每次分配对象时载入物理内存。在首次将新生代数据晋升到年老代时物理内存会急剧升高,(测试:在指定xmn大小为500m的情况下，每次new 4m大小空间，约400m时触发一次 minor gc，内存突然增长到750m)。

java的new关键字实际会作用到jvm的申请内存操作(声明的对象名称会在栈内分配)，调用到interpreterRuntime.cpp中的InterpreterRuntime::_new方法，为了方便触发gc，我用了new大数组的方式来调试。

创建数组的入口函数有两个，一个是用于基本类型的内存申请， 另一个是对象数组的。

IRT_ENTRY(void, InterpreterRuntime::newarray(JavaThread* thread, BasicType type, jint size))

oop obj = oopFactory::new_typeArray(type, size, CHECK);

thread->set_vm_result(obj);

IRT_END

IRT_ENTRY(void, InterpreterRuntime::anewarray(JavaThread* thread, ConstantPool* pool, int index, jint size))

// Note: no oopHandle for pool & klass needed since they are not used

// anymore after new_objArray() and no GC can happen before.

// (This may have to change if this code changes!)

Klass* klass = pool->klass_at(index, CHECK);

objArrayOop obj = oopFactory::new_objArray(klass, size, CHECK);

thread->set_vm_result(obj);

IRT_END

申请内存需要经过以下几个步骤。

1.尝试从tlab中分配内存，分配成功直接返回；不成功进入下一步。

2.从垃圾收集器中分配内存，如果没有相关指定收集器的配置，Server模式默认的是parralel Scavenge的方式分配。

3.从新生代中分配，关键代码HeapWord* result = young_gen()->allocate(size);，我们知道新生代实际直接存放新建对象的区域是eden区，关键代码HeapWord* result = eden_space()->cas_allocate(word_size);

4.内存的实际分配是MutableSpace类实现的，判断当前剩余空闲内存是否足够放下申请的对象，如果可以，那么成功返回。如果不行，进入步骤5。

5.如果对象的大小大于eden区的一半，那么直接分配到老年代中去，否则进入下一步。

HeapWord* ParallelScavengeHeap::mem_allocate_old_gen(size_t size) {

if (!should_alloc_in_eden(size) || GC_locker::is_active_and_needs_gc()) {

// Size is too big for eden, or gc is locked out.

return old_gen()->allocate(size);

}

// If a "death march" is in progress, allocate from the old gen a limited

// number of times before doing a GC.

if (_death_march_count > 0) {

if (_death_march_count < 64) {

++_death_march_count;

return old_gen()->allocate(size);

} else {

_death_march_count = 0;

}

}

return NULL;

}

inline bool ParallelScavengeHeap::should_alloc_in_eden(const size_t size) const

{

const size_t eden_size = young_gen()->eden_space()->capacity_in_words();

return size < eden_size / 2;

}

6.触发一个VM_ParallelGCFailedAllocation任务抛给vm线程,这里注意下VMThread的execute方法是阻塞的，需要等到vm线程的gc任务完成当前线程才会返回。默认的任务是VM_ParallelGCFailedAllocation。查看其doit方法

void VM_ParallelGCFailedAllocation::doit() {

SvcGCMarker sgcm(SvcGCMarker::MINOR);

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

assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "must be a ParallelScavengeHeap");

GCCauseSetter gccs(heap, _gc_cause);

_result = heap->failed_mem_allocate(_word_size);

if (_result == NULL && GC_locker::is_active_and_needs_gc()) {

set_gc_locked();

}

}

HeapWord* ParallelScavengeHeap::failed_mem_allocate(size_t size) {

assert(SafepointSynchronize::is_at_safepoint(), "should be at safepoint");

assert(Thread::current() == (Thread*)VMThread::vm_thread(), "should be in vm thread");

assert(!Universe::heap()->is_gc_active(), "not reentrant");

assert(!Heap_lock->owned_by_self(), "this thread should not own the Heap_lock");

// We assume that allocation in eden will fail unless we collect.

// First level allocation failure, scavenge and allocate in young gen.

GCCauseSetter gccs(this, GCCause::_allocation_failure);

const bool invoked_full_gc = PSScavenge::invoke();

HeapWord* result = young_gen()->allocate(size);

// Second level allocation failure.

// Mark sweep and allocate in young generation.

if (result == NULL && !invoked_full_gc) {

do_full_collection(false);

result = young_gen()->allocate(size);

}

death_march_check(result, size);

// Third level allocation failure.

// After mark sweep and young generation allocation failure,

// allocate in old generation.

if (result == NULL) {

result = old_gen()->allocate(size);

}

// Fourth level allocation failure. We're running out of memory.

// More complete mark sweep and allocate in young generation.

if (result == NULL) {

do_full_collection(true);

result = young_gen()->allocate(size);

}

// Fifth level allocation failure.

// After more complete mark sweep, allocate in old generation.

if (result == NULL) {

result = old_gen()->allocate(size);

}

return result;

}

7.可以看到，先执行一次minor gc，然后尝试在新生代分配。如果不成功且minor gc执行过程中没有去full gc，那么要来一次fullgc,尝试从新生代中分配。 还不成功，再来一次fullgc(带清楚软引用的),从新生代中分配。依然不成功，从老年代分配。还不成功？OOM吧。。

重点是const bool invoked_full_gc = PSScavenge::invoke();贴一下实现,先执行一次minor gc。不成功的话，触发fullgc。fullgc根据配置有两种选择，PSMarkSweep和PSParallel。没有CMS，因为Parraler Scavenge收集器和他无法同时使用。

bool PSScavenge::invoke() {

assert(SafepointSynchronize::is_at_safepoint(), "should be at safepoint");

assert(Thread::current() == (Thread*)VMThread::vm_thread(), "should be in vm thread");

assert(!Universe::heap()->is_gc_active(), "not reentrant");

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

assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Sanity");

PSAdaptiveSizePolicy* policy = heap->size_policy();

IsGCActiveMark mark;

const bool scavenge_done = PSScavenge::invoke_no_policy();

const bool need_full_gc = !scavenge_done ||

policy->should_full_GC(heap->old_gen()->free_in_bytes());

bool full_gc_done = false;

if (UsePerfData) {

PSGCAdaptivePolicyCounters* const counters = heap->gc_policy_counters();

const int ffs_val = need_full_gc ? full_follows_scavenge : not_skipped;

counters->update_full_follows_scavenge(ffs_val);

}

if (need_full_gc) {

GCCauseSetter gccs(heap, GCCause::_adaptive_size_policy);

CollectorPolicy* cp = heap->collector_policy();

const bool clear_all_softrefs = cp->should_clear_all_soft_refs();

if (UseParallelOldGC) {

full_gc_done = PSParallelCompact::invoke_no_policy(clear_all_softrefs);

} else {

full_gc_done = PSMarkSweep::invoke_no_policy(clear_all_softrefs);

}

}

return full_gc_done;

}

接下来进入重点了，minor gc的具体实现在PSScavenge::invoke_no_policy，代码太长不贴了。简单说下流程。

1.sanity check，记录gc前的内存信息。

2.向gc worker线程池投递gc任务，根据根节点搜索法保存有效的对象。根节点有很多种,如下。注意这些gc任务是并发执行的。

q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::universe));

q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::jni_handles));

// We scan the thread roots in parallel

Threads::create_thread_roots_tasks(q);

q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::object_synchronizer));

q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::flat_profiler));

q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::management));

q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::system_dictionary));

q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::class_loader_data));

q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::jvmti));

q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::code_cache));

可达性分析算法实现都差不多，步骤是遍历根节点的所有可达对象，判断对象是不是在新生代(根据内存地址判断)，是的话调用PSPromotionManager::copy_to_survivor_space转移存活对象，如果指定了需要晋升或者对象的年龄(新生代对象每经过一次minor gc加1岁)达到阙值，则拷贝到old区，否则拷贝到to区。

3.清空eden区和from区，再将有存活的对象的to区和from区做交换(保证存活对象放在from区，这样下次gc的时候就可以再次执行复制算法将对象拷贝到to区了)。

调用resize_young_gen方法重新分配新时代大小(疑问:看注释是minor gc会引起新生代大小的变化，具体什么情况？)

4.如果有对象晋升失败了，那么可能是old区空间不足了，此时需要触发一次full gc,如果老年代的策略是ps old,那么处理老年代的gc由类PSParallelCompact,这一段后续分析。