在内存分配的时候，如果剩余空间不能满足分配的对象就会触发YGC。G1每次都会收集所有的新生代的分区，但新生代分区的数目每次可能是不一样的，这是因为G1会根据时间预测模型来调整新生代分区数目。

YGC算法步骤

YGC算法主要分并行和其他部分，主要步骤如下：

1. 收集之前STW；
2. 选择要收集的Cset，即整个新生代分区
3. 进入并行处理：
   3.1 根扫描并处理：根直接引用的对象放到s区，然后把对象的field入栈等待后续复制处理；
   3.2 处理老年代到新生代的引用：更新RSet，从RSet出发，把RSet所在卡表对应的分区内存块所有对象认为是根，并将根引用的对象复制到s区，其field入栈等待后续复制处理；
   3.3 JIT代码扫描
   3.4 递归处理栈中的对象
4. 其他处理：
   4.1 JIT代码位置更新
   4.2 引用处理
   4.3 字符串去重优化回收
   4.4 清除卡表
   4.5 JIT代码回收
   4.6 Redirty、释放CSet、尝试大对象回收等
   4.7 可能启动并发标记:内存超过阈值，则启动

并行任务处理

image.png

并行任务是图中的第二步

1. GC worker start （g1CollectedHeap）

void work(uint worker_id) {
    if (worker_id >= _n_workers) return;  // no work needed this round

    double start_time_ms = os::elapsedTime() * 1000.0;
    _g1h->g1_policy()->phase_times()->record_gc_worker_start_time(worker_id, start_time_ms);
   ...
}

2. Ext Root Scanning(g1CollectedHeap)

void
G1CollectedHeap::
g1_process_roots(OopClosure* scan_non_heap_roots,
                 OopClosure* scan_non_heap_weak_roots,
                 OopsInHeapRegionClosure* scan_rs,
                 CLDClosure* scan_strong_clds,
                 CLDClosure* scan_weak_clds,
                 CodeBlobClosure* scan_strong_code,
                 uint worker_i) {

  // First scan the shared roots.
  double ext_roots_start = os::elapsedTime();
  double closure_app_time_sec = 0.0;

  bool during_im = _g1h->g1_policy()->during_initial_mark_pause();
  bool trace_metadata = during_im && ClassUnloadingWithConcurrentMark;

  BufferingOopClosure buf_scan_non_heap_roots(scan_non_heap_roots);
  BufferingOopClosure buf_scan_non_heap_weak_roots(scan_non_heap_weak_roots);

  process_roots(false, // no scoping; this is parallel code
                SharedHeap::SO_None,
                &buf_scan_non_heap_roots,
                &buf_scan_non_heap_weak_roots,
                scan_strong_clds,
                // Unloading Initial Marks handle the weak CLDs separately.
                (trace_metadata ? NULL : scan_weak_clds),
                scan_strong_code);

  // Now the CM ref_processor roots.
  if (!_process_strong_tasks->is_task_claimed(G1H_PS_refProcessor_oops_do)) {
    // We need to treat the discovered reference lists of the
    // concurrent mark ref processor as roots and keep entries
    // (which are added by the marking threads) on them live
    // until they can be processed at the end of marking.
    ref_processor_cm()->weak_oops_do(&buf_scan_non_heap_roots);
  }

  if (trace_metadata) {
    // Barrier to make sure all workers passed
    // the strong CLD and strong nmethods phases.
    active_strong_roots_scope()->wait_until_all_workers_done_with_threads(n_par_threads());

    // Now take the complement of the strong CLDs.
    ClassLoaderDataGraph::roots_cld_do(NULL, scan_weak_clds);
  }

  // Finish up any enqueued closure apps (attributed as object copy time).
  buf_scan_non_heap_roots.done();
  buf_scan_non_heap_weak_roots.done();

  double obj_copy_time_sec = buf_scan_non_heap_roots.closure_app_seconds()
      + buf_scan_non_heap_weak_roots.closure_app_seconds();

  g1_policy()->phase_times()->record_obj_copy_time(worker_i, obj_copy_time_sec * 1000.0);

  double ext_root_time_ms =
    ((os::elapsedTime() - ext_roots_start) - obj_copy_time_sec) * 1000.0;

  g1_policy()->phase_times()->record_ext_root_scan_time(worker_i, ext_root_time_ms);

  // During conc marking we have to filter the per-thread SATB buffers
  // to make sure we remove any oops into the CSet (which will show up
  // as implicitly live).
  double satb_filtering_ms = 0.0;
  if (!_process_strong_tasks->is_task_claimed(G1H_PS_filter_satb_buffers)) {
    if (mark_in_progress()) {
      double satb_filter_start = os::elapsedTime();

      JavaThread::satb_mark_queue_set().filter_thread_buffers();

      satb_filtering_ms = (os::elapsedTime() - satb_filter_start) * 1000.0;
    }
  }
  g1_policy()->phase_times()->record_satb_filtering_time(worker_i, satb_filtering_ms);

  // Now scan the complement of the collection set.
  G1CodeBlobClosure scavenge_cs_nmethods(scan_non_heap_weak_roots);

  g1_rem_set()->oops_into_collection_set_do(scan_rs, &scavenge_cs_nmethods, worker_i);

  _process_strong_tasks->all_tasks_completed();
}

在process_root方法中，会通过Threads::possibly_parallel_oops_do方法遍历所有的java线程和VMThread线程进行栈处理

void JavaThread::oops_do(OopClosure* f, CLDClosure* cld_f, CodeBlobClosure* cf) {
  
  // 处理JNI本地栈、JVM内部本地方法栈
  Thread::oops_do(f, cld_f, cf);

  if (has_last_Java_frame()) {
    // Record JavaThread to GC thread
    RememberProcessedThread rpt(this);

    // 处理用于实现安全功能的类
    if (_privileged_stack_top != NULL) {
      _privileged_stack_top->oops_do(f);
    }

    // traverse the registered growable array
    if (_array_for_gc != NULL) {
      for (int index = 0; index < _array_for_gc->length(); index++) {
        f->do_oop(_array_for_gc->adr_at(index));
      }
    }

    // 处理monitor块
    for (MonitorChunk* chunk = monitor_chunks(); chunk != NULL; chunk = chunk->next()) {
      chunk->oops_do(f);
    }

    // 遍历栈
    for(StackFrameStream fst(this); !fst.is_done(); fst.next()) {
      fst.current()->oops_do(f, cld_f, cf, fst.register_map());
    }
  }

  // callee_target is never live across a gc point so NULL it here should
  // it still contain a methdOop.

  set_callee_target(NULL);

  assert(vframe_array_head() == NULL, "deopt in progress at a safepoint!");
  // If we have deferred set_locals there might be oops waiting to be
  // written
  GrowableArray<jvmtiDeferredLocalVariableSet*>* list = deferred_locals();
  if (list != NULL) {
    for (int i = 0; i < list->length(); i++) {
      list->at(i)->oops_do(f);
    }
  }

  // 遍历这些实例对象，它们可能引用了堆对象
  f->do_oop((oop*) &_threadObj);
  f->do_oop((oop*) &_vm_result);
  f->do_oop((oop*) &_exception_oop);
  f->do_oop((oop*) &_pending_async_exception);

  if (jvmti_thread_state() != NULL) {
    jvmti_thread_state()->oops_do(f);
  }
}

3. update RSet (g1RemSet)

void G1RemSet::updateRS(DirtyCardQueue* into_cset_dcq, uint worker_i) {
  double start = os::elapsedTime();
  // Apply the given closure to all remaining log entries.
  //使用closure处理DCQ队列
  RefineRecordRefsIntoCSCardTableEntryClosure into_cset_update_rs_cl(_g1, into_cset_dcq);
  // 遍历处理dirty_card
  _g1->iterate_dirty_card_closure(&into_cset_update_rs_cl, into_cset_dcq, false, worker_i);

  // Now there should be no dirty cards.
  if (G1RSLogCheckCardTable) {
    CountNonCleanMemRegionClosure cl(_g1);
    _ct_bs->mod_card_iterate(&cl);
    // XXX This isn't true any more: keeping cards of young regions
    // marked dirty broke it.  Need some reasonable fix.
    guarantee(cl.n() == 0, "Card table should be clean.");
  }

  _g1p->phase_times()->record_update_rs_time(worker_i, (os::elapsedTime() - start) * 1000.0);
}

void G1CollectedHeap::iterate_dirty_card_closure(CardTableEntryClosure* cl,
                                                 DirtyCardQueue* into_cset_dcq,
                                                 bool concurrent,
                                                 uint worker_i) {
  // Clean cards in the hot card cache
  //处理热表
  G1HotCardCache* hot_card_cache = _cg1r->hot_card_cache();
  hot_card_cache->drain(worker_i, g1_rem_set(), into_cset_dcq);
  //处理DCQS中剩下的DCQ
  DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set();
  int n_completed_buffers = 0;
  while (dcqs.apply_closure_to_completed_buffer(cl, worker_i, 0, true)) {
    n_completed_buffers++;
  }
  g1_policy()->phase_times()->record_update_rs_processed_buffers(worker_i, n_completed_buffers);
  dcqs.clear_n_completed_buffers();
  assert(!dcqs.completed_buffers_exist_dirty(), "Completed buffers exist!");
}

4. Scan Rs (G1RemSet)

void G1RemSet::scanRS(OopsInHeapRegionClosure* oc,
                      CodeBlobClosure* code_root_cl,
                      uint worker_i) {
  double rs_time_start = os::elapsedTime();
  //每个线程处理部分分区
  HeapRegion *startRegion = _g1->start_cset_region_for_worker(worker_i);

  ScanRSClosure scanRScl(oc, code_root_cl, worker_i);
  //第一次扫描，处理一般对象
  _g1->collection_set_iterate_from(startRegion, &scanRScl);
  scanRScl.set_try_claimed();
  //第二次扫描，处理代码对象
  _g1->collection_set_iterate_from(startRegion, &scanRScl);

  double scan_rs_time_sec = (os::elapsedTime() - rs_time_start)
                            - scanRScl.strong_code_root_scan_time_sec();

  assert(_cards_scanned != NULL, "invariant");
  _cards_scanned[worker_i] = scanRScl.cards_done();

  _g1p->phase_times()->record_scan_rs_time(worker_i, scan_rs_time_sec * 1000.0);
  _g1p->phase_times()->record_strong_code_root_scan_time(worker_i,
                                                         scanRScl.strong_code_root_scan_time_sec() * 1000.0);
}

5. Code Root Scaning

void scan_strong_code_roots(HeapRegion* r) {
    double scan_start = os::elapsedTime();
    r->strong_code_roots_do(_code_root_cl);
    _strong_code_root_scan_time_sec += (os::elapsedTime() - scan_start);
  }

6. Object Copy (g1CollectedHeap)
   在遍历java栈时，会将对象复制到s区

void G1ParCopyClosure<barrier, do_mark_object>::do_oop_work(T* p) {
  T heap_oop = oopDesc::load_heap_oop(p);

  if (oopDesc::is_null(heap_oop)) {
    return;
  }

  oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);

  G1CollectedHeap::in_cset_state_t state = _g1->in_cset_state(obj);

  if (state == G1CollectedHeap::InCSet) {
    oop forwardee;
    //对象是否已复制完成
    if (obj->is_forwarded()) {
      forwardee = obj->forwardee();
    } else {
      //复制对象到s区
      forwardee = _par_scan_state->copy_to_survivor_space(obj);
    }
    assert(forwardee != NULL, "forwardee should not be NULL");
    oopDesc::encode_store_heap_oop(p, forwardee);
    if (do_mark_object != G1MarkNone && forwardee != obj) {
      // 如果对象成功复制，把对象的新地址设置到老对象的对象头.
      mark_forwarded_object(obj, forwardee);
    }

    if (barrier == G1BarrierKlass) {
      do_klass_barrier(p, forwardee);
    }
  } else {
    //对不在CSet中的对象，先标记为活的，到时作为跟对象
    if (state == G1CollectedHeap::IsHumongous) {
      _g1->set_humongous_is_live(obj);
    }
    // The object is not in collection set. If we're a root scanning
    // closure during an initial mark pause then attempt to mark the object.
    if (do_mark_object == G1MarkFromRoot) {
      mark_object(obj);
    }
  }
  //如果是eval失败，则将对象记录在一个队列中
  if (barrier == G1BarrierEvac) {
    _par_scan_state->update_rs(_from, p, _worker_id);
  }
}

copy对象到s区的实现

oop G1ParScanThreadState::copy_to_survivor_space(oop const old) {
  size_t word_sz = old->size();
  HeapRegion* from_region = _g1h->heap_region_containing_raw(old);
  // +1 to make the -1 indexes valid...
  int       young_index = from_region->young_index_in_cset()+1;
  
  G1CollectorPolicy* g1p = _g1h->g1_policy();
  markOop m = old->mark();
  //根据age和s区是否放的下来判断对象是copy到s区还是old区
  int age = m->has_displaced_mark_helper() ? m->displaced_mark_helper()->age()
                                           : m->age();
  GCAllocPurpose alloc_purpose = g1p->evacuation_destination(from_region, age,
                                                             word_sz);
  AllocationContext_t context = from_region->allocation_context();
  //使用plab方法在plab分配（plab和tlab一样是为了避免并发，只是plab是分配在s和old区）
  HeapWord* obj_ptr = _g1_par_allocator->allocate(alloc_purpose, word_sz, context);

  if (_g1h->evacuation_should_fail()) {
    if (obj_ptr != NULL) {
      _g1_par_allocator->undo_allocation(alloc_purpose, obj_ptr, word_sz, context);
      obj_ptr = NULL;
    }
  }

  if (obj_ptr == NULL) {
    // plab分配失败，则判断是否需要再分配plab，大小由youngPLABSzie和OldPLABSize决定，当然还有浪费的比例ParallelGCBufferWasterPct参数
    return _g1h->handle_evacuation_failure_par(this, old);
  }

  oop obj = oop(obj_ptr);

  // We're going to allocate linearly, so might as well prefetch ahead.
  Prefetch::write(obj_ptr, PrefetchCopyIntervalInBytes);

  oop forward_ptr = old->forward_to_atomic(obj);
  if (forward_ptr == NULL) {
    //如果对象头没有指针，说明是第一次复制，增加引用关系
    Copy::aligned_disjoint_words((HeapWord*) old, obj_ptr, word_sz);
    HeapRegion* to_region = _g1h->heap_region_containing_raw(obj_ptr);
    alloc_purpose = to_region->is_young() ? GCAllocForSurvived : GCAllocForTenured;

    if (g1p->track_object_age(alloc_purpose)) {
      if (m->has_displaced_mark_helper()) {
         //更新age信息和对象头
        obj->set_mark(m);
        obj->incr_age();
      } else {
        m = m->incr_age();
        obj->set_mark(m);
      }
      age_table()->add(obj, word_sz);
    } else {
      obj->set_mark(m);
    }
    //字符串去重
    if (G1StringDedup::is_enabled()) {
      G1StringDedup::enqueue_from_evacuation(from_region->is_young(),
                                             to_region->is_young(),
                                             queue_num(),
                                             obj);
    }

    size_t* surv_young_words = surviving_young_words();
    surv_young_words[young_index] += word_sz;
    //处理数组对象，放入队列后续处理，防止数组过大深度遍历时导致处理队列溢出
    if (obj->is_objArray() && arrayOop(obj)->length() >= ParGCArrayScanChunk) {
      arrayOop(obj)->set_length(0);
      oop* old_p = set_partial_array_mask(old);
      push_on_queue(old_p);
    } else {
      //
      obj->oop_iterate_backwards(&_scanner);
    }
  } else {
    _g1_par_allocator->undo_allocation(alloc_purpose, obj_ptr, word_sz, context);
    obj = forward_ptr;
  }
  return obj;
}

处理每个对象的field

inline void G1CMOopClosure::do_oop_nv(T* p) {
  oop obj = oopDesc::load_decode_heap_oop(p);
  if (_cm->verbose_high()) {
    gclog_or_tty->print_cr("[%u] we're looking at location "
                           "*"PTR_FORMAT" = "PTR_FORMAT,
                           _task->worker_id(), p2i(p), p2i((void*) obj));
  }
    //遍历对象的每个field进行处理
  _task->deal_with_reference(obj);
}

主要部分就到这里了，最后再。。