在initialize_heap_sizes中初始化了gc的线程，后续的gc以任务的形式提交
主要有三种：
1.触发gc操作一般在分配内存时，空间不足可能要oom时才寻找合适的stw时机
（某面试官说道：有人的地方就有江湖，有分配内存的地方都可能oom）
2.system.gc()
3.定时任务G1PeriodicGCTask
想看gc方法找gcRoots什么的需要一个切入点，定时任务作为一个保底的触发机制，可以不断尝试触发gc
先看简单的定时任务
void G1PeriodicGCTask::execute() {
check_for_periodic_gc();
// G1PeriodicGCInterval is a manageable flag and can be updated
// during runtime. If no value is set, wait a second and run it
// again to see if the value has been updated. Otherwise use the
// real value provided.
//这个意思就是如果后续运行过程中进行了参数调整，可以实时调整
schedule(G1PeriodicGCInterval == 0 ? 1000 : G1PeriodicGCInterval);
}
void ConcurrentGCThread::run() {
// Setup handle area
set_active_handles(JNIHandleBlock::allocate_block());
// Wait for initialization to complete
wait_init_completed();
run_service();
// Signal thread has terminated
MonitorLocker ml(Terminator_lock);
Atomic::release_store(&_has_terminated, true);
ml.notify_all();
}
定时任务提交给了G1ServiceThread，这个类继承到最上面是一个javaThread,和java一样看run方法就行,最后调用到了task中的execute，
在执行check_for_periodic_gc()完成后设置下一次的定时任务
void G1PeriodicGCTask::check_for_periodic_gc() {
// If disabled, just return.
// 间隔设置成0后将不会执行gc，直接开启下一秒的gc任务
if (G1PeriodicGCInterval == 0) {
return;
}
//try_collect就是检查过程，真的要gc的话看里面
log_debug(gc, periodic)("Checking for periodic GC.");
if (should_start_periodic_gc()) {
if (!G1CollectedHeap::heap()->try_collect(GCCause::_g1_periodic_collection)) {
log_debug(gc, periodic)("GC request denied. Skipping.");
}
}
}
这里的GCCause::_g1_periodic_collection为25
bool G1CollectedHeap::try_collect(GCCause::Cause cause) {
//堆锁判断是否是当前线程的锁
assert_heap_not_locked();
// Lock to get consistent set of values.
uint gc_count_before;
uint full_gc_count_before;
uint old_marking_started_before;
{
MutexLocker ml(Heap_lock);
gc_count_before = total_collections();
full_gc_count_before = total_full_collections();
old_marking_started_before = _old_marking_cycles_started;
}
//判断是否触发并发的full gc
if (should_do_concurrent_full_gc(cause)) {
return try_collect_concurrently(cause,
gc_count_before,
old_marking_started_before);
} else if (GCLocker::should_discard(cause, gc_count_before)) {
//判断是否是初始化gc并且获取的gc次数被修改过
// Indicate failure to be consistent with VMOp failure due to
// another collection slipping in after our gc_count but before
// our request is processed.
return false;
} else if (cause == GCCause::_gc_locker || cause == GCCause::_wb_young_gc
DEBUG_ONLY(|| cause == GCCause::_scavenge_alot)) {
//白盒子测试或者初始化
// Schedule a standard evacuation pause. We're setting word_size
// to 0 which means that we are not requesting a post-GC allocation.
VM_G1CollectForAllocation op(0, /* word_size */
gc_count_before,
cause,
policy()->max_pause_time_ms());
VMThread::execute(&op);
return op.gc_succeeded();
} else {
// Schedule a Full GC.
//简单的full gc
VM_G1CollectFull op(gc_count_before, full_gc_count_before, cause);
VMThread::execute(&op);
return op.gc_succeeded();
}
}
gc有多少种cause可以查看GCCause.cpp
case _java_lang_system_gc:
return "System.gc()";
case _full_gc_alot:
return "FullGCAlot";
case _scavenge_alot:
return "ScavengeAlot";
case _allocation_profiler:
return "Allocation Profiler";
case _jvmti_force_gc:
return "JvmtiEnv ForceGarbageCollection";
case _gc_locker:
return "GCLocker Initiated GC";
case _heap_inspection:
return "Heap Inspection Initiated GC";
case _heap_dump:
return "Heap Dump Initiated GC";
//...省略
case _g1_inc_collection_pause:
return "G1 Evacuation Pause";
通过这个参数可以统计出整个jvm已经进行的gc类型,比如jstat -gccause <pid> 100 （意思是每秒打印gc信息）
其中有一个字段LGCC对应这个原因
C:\Users\tango>jstat -gccause 21136 1000
S0 S1 E O M CCS YGC YGCT FGC FGCT CGC CGCT GCT LGCC GCC
0.00 97.40 10.99 64.32 99.07 95.76 54 0.921 0 0.000 6 0.013 0.934 G1 Evacuation Pause No GC
0.00 97.40 10.99 64.32 99.07 95.76 54 0.921 0 0.000 6 0.013 0.934 G1 Evacuation Pause No GC
0.00 97.40 10.99 64.32 99.07 95.76 54 0.921 0 0.000 6 0.013 0.934 G1 Evacuation Pause No GC
0.00 97.40 10.99 64.32 99.07 95.76 54 0.921 0 0.000 6 0.013 0.934 G1 Evacuation Pause No GC
jvm内存触发
结合前面内存分配的过程就能快速找到
tlab触发##
开启tlab后，如果内存不够走tlab_slow分配会调用这里,注意这里需要分配的东西是tlab的空间，与后续heap直接分配的方法一样但是对象不一样
HeapWord* G1CollectedHeap::allocate_new_tlab(size_t min_size,
size_t requested_size,
size_t* actual_size) {
//safepoint就是安全点，jvm线程执行字节码自己能够知道
assert_heap_not_locked_and_not_at_safepoint();
//大对象直接走的heap，tlab不走
assert(!is_humongous(requested_size), "we do not allow humongous TLABs");
return attempt_allocation(min_size, requested_size, actual_size);
}
attempt_allocation和heap触发的一样
heap触发##
HeapWord* MemAllocator::allocate_outside_tlab(Allocation& allocation) const {
allocation._allocated_outside_tlab = true;
HeapWord* mem = Universe::heap()->mem_allocate(_word_size, &allocation._overhead_limit_exceeded);
if (mem == NULL) {
return mem;
}
NOT_PRODUCT(Universe::heap()->check_for_non_bad_heap_word_value(mem, _word_size));
size_t size_in_bytes = _word_size * HeapWordSize;
_thread->incr_allocated_bytes(size_in_bytes);
return mem;
}
mem_allocate
HeapWord*
G1CollectedHeap::mem_allocate(size_t word_size,
bool* gc_overhead_limit_was_exceeded) {
assert_heap_not_locked_and_not_at_safepoint();
if (is_humongous(word_size)) {
return attempt_allocation_humongous(word_size);
}
size_t dummy = 0;
//和tlab_slow一个方法
return attempt_allocation(word_size, word_size, &dummy);
}
attempt_allocation_humongous
里面可以触发gc原因的有
_g1_humongous_allocation
_g1_preventive_collection
特别注意大对象触发时,由于大对象消耗内存很快，所以会触发检查是否要进行并发标记
// Humongous objects can exhaust the heap quickly, so we should check if we
// need to start a marking cycle at each humongous object allocation. We do
// the check before we do the actual allocation. The reason for doing it
// before the allocation is that we avoid having to keep track of the newly
// allocated memory while we do a GC.
if (policy()->need_to_start_conc_mark("concurrent humongous allocation",
word_size)) {
collect(GCCause::_g1_humongous_allocation);
}
attempt_allocation
inline HeapWord* G1CollectedHeap::attempt_allocation(size_t min_word_size,
size_t desired_word_size,
size_t* actual_word_size) {
assert_heap_not_locked_and_not_at_safepoint();
assert(!is_humongous(desired_word_size), "attempt_allocation() should not "
"be called for humongous allocation requests");
//numa从系统的多线程空间获取内存
HeapWord* result = _allocator->attempt_allocation(min_word_size, desired_word_size, actual_word_size);
//numa分配失败
if (result == NULL) {
*actual_word_size = desired_word_size;
//内部可能触发gc再进行内存分配
result = attempt_allocation_slow(desired_word_size);
}
assert_heap_not_locked();
if (result != NULL) {
assert(*actual_word_size != 0, "Actual size must have been set here");
dirty_young_block(result, *actual_word_size);
} else {
*actual_word_size = 0;
}
return result;
}
system.gc()
JVM_ENTRY_NO_ENV(void, JVM_GC(void))
if (!DisableExplicitGC) {
EventSystemGC event;
event.set_invokedConcurrent(ExplicitGCInvokesConcurrent);
Universe::heap()->collect(GCCause::_java_lang_system_gc);
event.commit();
}
JVM_END
//collect
void G1CollectedHeap::collect(GCCause::Cause cause) {
try_collect(cause);
}
回到了开始的定时任务，而且人家还是一秒一次的
如果版本支持G1PeriodicGCTask这个system.gc()就不要写了吧
