深入理解JVM内存管理与垃圾回收

class JavaThread: public Thread {
  private:
    address _last_Java_pc;  // 上一个Java栈帧的PC
    // ...
};

class frame {
  private:
    intptr_t* _sp;  // 栈指针
    address   _pc;  // 程序计数器
    intptr_t* _fp;  // 帧指针

    // 局部变量表访问
    oop obj_at(int offset) const {
        return *oop_addr_at(offset);
    }

    // 操作数栈访问
    intptr_t* interpreter_frame_expression_stack() const;
};

class CollectedHeap : public CHeapObj<mtInternal> {
  protected:
    MemRegion _reserved;  // 保留的内存区域

  public:
    virtual HeapWord* mem_allocate(size_t size,
                                   bool* gc_overhead_limit_was_exceeded) = 0;

    // 对象分配的快速路径（内联在生成的代码中）
    virtual HeapWord* allocate_new_tlab(size_t size);

    // 执行垃圾回收
    virtual void collect(GCCause::Cause cause) = 0;
};

// instanceKlass.hpp - 类的元数据表示
class InstanceKlass: public Klass {
  private:
    // 类的结构信息
    int _vtable_len;              // 虚方法表长度
    int _itable_len;              // 接口方法表长度
    Array<Method*>* _methods;     // 方法列表
    Array<u2>* _fields;           // 字段列表
    ConstantPool* _constants;     // 常量池
    // ...
};

class markOopDesc: public oopDesc {
  private:
    uintptr_t _value;

  public:
    // 位操作获取不同字段
    uintptr_t hash() const {
        return mask_bits(value() >> hash_shift, hash_mask);
    }

    uint age() const {
        return mask_bits(value() >> age_shift, age_mask);
    }

    JavaThread* locker() const {
        return (JavaThread*)((value() & ~lock_mask_in_place));
    }
};

class OopMap {
  private:
    OopMapValue* _omv_data;  // 记录栈上哪些位置是对象引用

  public:
    // 遍历所有引用
    void iterate_oop(OopClosure* blk);
};

void ReferenceProcessor::process_discovered_references(
    ReferencePolicy* policy,
    BoolObjectClosure* is_alive,
    OopClosure* keep_alive,
    VoidClosure* complete_gc) {

    // 1. 处理软引用
    process_soft_references(policy, is_alive, keep_alive, complete_gc);

    // 2. 处理弱引用
    process_weak_references(is_alive, keep_alive, complete_gc);

    // 3. 处理虚引用和Finalizer
    process_final_references(is_alive, keep_alive, complete_gc);
    process_phantom_references(is_alive, keep_alive, complete_gc);
}

void DefNewGeneration::collect(bool full, bool clear_all_soft_refs,
                                size_t size, bool is_tlab) {
    // 保存old gen的对象指针（用于处理跨代引用）
    save_marks();

    // 清空To区
    to()->clear(SpaceDecorator::Mangle);

    // 复制Eden和From区的存活对象到To区
    FastScanClosure fsc(this, true);
    evacuate_followers(&fsc);

    // 交换From和To
    swap_spaces();
}

// parallelCompact.cpp - Parallel Old GC的实现
void PSParallelCompact::invoke(bool maximum_heap_compaction) {
    // 阶段1: 标记存活对象
    marking_phase();

    // 阶段2: 计算对象新地址
    summary_phase();

    // 阶段3: 移动对象
    compact_perm();
    compact();
}

// psScavenge.cpp - 新生代并行收集
void PSScavenge::invoke() {
    ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();

    // 创建多个GC线程
    PSPromotionManager::pre_scavenge();

    // 并行处理GC Roots
    ParallelScavengeHeap::StrongRootsScope srs;
    scavenge_roots_tasks.enqueue(...);

    // 工作线程池执行任务
    workers->run_task(&scavenge_roots_tasks);
}

// concurrentMarkSweepGeneration.cpp
void CMSCollector::checkpointRootsInitial() {
    // 记录并发标记期间的引用变化
    _mark_word_saved = java_lang_Class::klass_oop(k)->mark();

    // 使用写屏障（Write Barrier）追踪引用变化
    BarrierSet* bs = Universe::heap()->barrier_set();
    bs->write_ref_field(...);
}

// g1RemSet.hpp
class G1RemSet: public CHeapObj<mtGC> {
  private:
    G1CollectedHeap* _g1;
    CardTableModRefBS* _ct_bs;

  public:
    // 更新RSet（通过写屏障触发）
    void refine_card(jbyte* card_ptr, uint worker_i);

    // GC时扫描RSet
    void oops_into_collection_set_do(...);
};

// g1CollectedHeap.cpp
void G1CollectedHeap::do_collection_pause_at_safepoint(double target_pause_time_ms) {
    // 1. 选择回收集合（Collection Set）
    _collection_set->finalize_young_part(target_pause_time_ms);
    _collection_set->finalize_old_part();

    // 2. 并行回收
    evacuate_collection_set();

    // 3. 更新引用
    reference_processor()->process_discovered_references();
}

double G1Analytics::predict_region_elapsed_time_ms(HeapRegion* hr, bool for_young_gc) {
    double prediction = get_new_prediction(_rs_length_diff_seq);
    prediction += get_new_prediction(_cost_per_byte_ms_seq) * hr->used();
    return prediction;
}