java虚拟机class存在哪_hotpot java虚拟机Class对象是放在 方法区 还是堆中 ？

java虚拟机class存在哪_hotpot java虚拟机Class对象是放在 方法区 还是堆中 ？_施翀的博客-CSDN博客

先说结论，参照OpenJDK1.8的源码，Class对象应该存在于Heap中。

1. Class对象何时创建——类加载器加载过程中创建，具体参见源码：

instanceKlassHandle ClassFileParser::parseClassFile(Symbol* name,

ClassLoaderData* loader_data,

Handle protection_domain,

KlassHandle host_klass,

GrowableArray* cp_patches,

TempNewSymbol& parsed_name,

bool verify,

TRAPS){

/***ignore***/

// LINE: 4077

// Allocate mirror and initialize static fields

java_lang_Class::create_mirror(this_klass, protection_domain, CHECK_(nullHandle));

/***ignore***/}

2. java_lang_Class::create_mirror函数的具体实现(针对Klass是InstanceKlass和ArrayKlass)：

oop java_lang_Class::create_mirror(KlassHandle k, Handle protection_domain, TRAPS) {

assert(k->java_mirror() == NULL, "should only assign mirror once");

// Use this moment of initialization to cache modifier_flags also, // to support Class.getModifiers(). Instance classes recalculate // the cached flags after the class file is parsed, but before the // class is put into the system dictionary. int computed_modifiers = k->compute_modifier_flags(CHECK_0);

k->set_modifier_flags(computed_modifiers);

// Class_klass has to be loaded because it is used to allocate // the mirror. if (SystemDictionary::Class_klass_loaded()) {

// Allocate mirror (java.lang.Class instance) Handle mirror = InstanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_instance(k, CHECK_0);

InstanceMirrorKlass* mk = InstanceMirrorKlass::cast(mirror->klass());

java_lang_Class::set_static_oop_field_count(mirror(), mk->compute_static_oop_field_count(mirror()));

// It might also have a component mirror. This mirror must already exist. if (k->oop_is_array()) {

Handle comp_mirror;

if (k->oop_is_typeArray()) {

BasicType type = TypeArrayKlass::cast(k())->element_type();

comp_mirror = Universe::java_mirror(type);

} else {

assert(k->oop_is_objArray(), "Must be");

Klass* element_klass = ObjArrayKlass::cast(k())->element_klass();

assert(element_klass != NULL, "Must have an element klass");

comp_mirror = element_klass->java_mirror();

}

assert(comp_mirror.not_null(), "must have a mirror");

// Two-way link between the array klass and its component mirror: ArrayKlass::cast(k())->set_component_mirror(comp_mirror());

set_array_klass(comp_mirror(), k());

} else {

assert(k->oop_is_instance(), "Must be");

// Allocate a simple java object for a lock. // This needs to be a java object because during class initialization // it can be held across a java call. typeArrayOop r = oopFactory::new_typeArray(T_INT, 0, CHECK_NULL);

set_init_lock(mirror(), r);

// Set protection domain also set_protection_domain(mirror(), protection_domain());

// Initialize static fields InstanceKlass::cast(k())->do_local_static_fields(&initialize_static_field, CHECK_NULL);

}

return mirror();

} else {

if (fixup_mirror_list() == NULL) {

GrowableArray* list =

new (ResourceObj::C_HEAP, mtClass) GrowableArray(40, true);

set_fixup_mirror_list(list);

}

fixup_mirror_list()->push(k());

return NULL;

}

}

3. 基本类型的Class对象的创建：

void Universe::initialize_basic_type_mirrors(TRAPS) {

assert(_int_mirror==NULL, "basic type mirrors already initialized");

_int_mirror =

java_lang_Class::create_basic_type_mirror("int", T_INT, CHECK);

_float_mirror =

java_lang_Class::create_basic_type_mirror("float", T_FLOAT, CHECK);

_double_mirror =

java_lang_Class::create_basic_type_mirror("double", T_DOUBLE, CHECK);

_byte_mirror =

java_lang_Class::create_basic_type_mirror("byte", T_BYTE, CHECK);

_bool_mirror =

java_lang_Class::create_basic_type_mirror("boolean",T_BOOLEAN, CHECK);

_char_mirror =

java_lang_Class::create_basic_type_mirror("char", T_CHAR, CHECK);

_long_mirror =

java_lang_Class::create_basic_type_mirror("long", T_LONG, CHECK);

_short_mirror =

java_lang_Class::create_basic_type_mirror("short", T_SHORT, CHECK);

_void_mirror =

java_lang_Class::create_basic_type_mirror("void", T_VOID, CHECK);

_mirrors[T_INT] = _int_mirror;

_mirrors[T_FLOAT] = _float_mirror;

_mirrors[T_DOUBLE] = _double_mirror;

_mirrors[T_BYTE] = _byte_mirror;

_mirrors[T_BOOLEAN] = _bool_mirror;

_mirrors[T_CHAR] = _char_mirror;

_mirrors[T_LONG] = _long_mirror;

_mirrors[T_SHORT] = _short_mirror;

_mirrors[T_VOID] = _void_mirror;

//_mirrors[T_OBJECT] = InstanceKlass::cast(_object_klass)->java_mirror();

//_mirrors[T_ARRAY] = InstanceKlass::cast(_object_klass)->java_mirror();

}

oop java_lang_Class::create_basic_type_mirror(const char* basic_type_name, BasicType type, TRAPS) {

// This should be improved by adding a field at the Java level or by

// introducing a new VM klass (see comment in ClassFileParser)

oop java_class = InstanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_instance(NULL, CHECK_0);

if (type != T_VOID) {

Klass* aklass = Universe::typeArrayKlassObj(type);

assert(aklass != NULL, "correct bootstrap");

set_array_klass(java_class, aklass);

}

#ifdef ASSERT

InstanceMirrorKlass* mk = InstanceMirrorKlass::cast(SystemDictionary::Class_klass());

assert(java_lang_Class::static_oop_field_count(java_class) == 0, "should have been zeroed by allocation");

#endif

return java_class;

}

4. InstanceMirrorKlass::allocate_instance函数：

instanceOop InstanceMirrorKlass::allocate_instance(KlassHandle k, TRAPS) {

// Query before forming handle.

int size = instance_size(k);

KlassHandle h_k(THREAD, this);

instanceOop i = (instanceOop) CollectedHeap::Class_obj_allocate(h_k, size, k, CHECK_NULL);

return i;

}

5. Class对象堆上分配实现：

oop CollectedHeap::Class_obj_allocate(KlassHandle klass, int size, KlassHandle real_klass, TRAPS) {

debug_only(check_for_valid_allocation_state());

assert(!Universe::heap()->is_gc_active(), "Allocation during gc not allowed");

assert(size >= 0, "int won't convert to size_t");

HeapWord* obj;

assert(ScavengeRootsInCode > 0, "must be");

obj = common_mem_allocate_init(real_klass, size, CHECK_NULL);

post_allocation_setup_common(klass, obj);

assert(Universe::is_bootstrapping() ||

!((oop)obj)->is_array(), "must not be an array");

NOT_PRODUCT(Universe::heap()->check_for_bad_heap_word_value(obj, size));

oop mirror = (oop)obj;

java_lang_Class::set_oop_size(mirror, size);

// Setup indirections

if (!real_klass.is_null()) {

java_lang_Class::set_klass(mirror, real_klass());

real_klass->set_java_mirror(mirror);

}

InstanceMirrorKlass* mk = InstanceMirrorKlass::cast(mirror->klass());

assert(size == mk->instance_size(real_klass), "should have been set");

// notify jvmti and dtrace

post_allocation_notify(klass, (oop)obj);

return mirror;

}