创建一个普通对象,类似执行A a=new A()
这条语句,通过反编译javap -c
可以得到对应指令如下
0: new #2 // class main/proxy/A
3: dup
4: invokespecial #3 // Method main/proxy/A."<init>":()V
复制代码
new/dup/invokespecial分别对应虚拟机的指令,后面跟随的#
表示常量池中的索引
对象创建完整过程在hotspot中的源码中可见 bytecodeInterpreter.cpp
当读取到_new
指令时,执行如下
CASE(_new): {
//获取常量池中的位置
u2 index = Bytes::get_Java_u2(pc+1);
//获取常量池
constantPoolOop constants = istate->method()->constants();
if (!constants->tag_at(index).is_unresolved_klass()) {
//常量池中已经加载了要新建的对象
...
UPDATE_PC_AND_TOS_AND_CONTINUE(3, 1);
...
}
//常量池中没有加载要新建的对象,执行加载流程
CALL_VM(InterpreterRuntime::_new(THREAD, METHOD->constants(), index),
handle_exception);
SET_STACK_OBJECT(THREAD->vm_result(), 0);
THREAD->set_vm_result(NULL);
UPDATE_PC_AND_TOS_AND_CONTINUE(3, 1);
}
constantPoolOop
是个存放class常量的数组。class由class file规则定义。constantPoolOop中的大多数实例都是在class解析的时候就放入了
确保对象所属类型已经经过初始化阶段
if ( ik->is_initialized() && ik->can_be_fastpath_allocated() ) {
...
}
开始执行新建。
它是由运行时开始执行新建
IRT_ENTRY(void, InterpreterRuntime::_new(JavaThread* thread, constantPoolOopDesc* pool, int index))
//在常量池中找到对应的klass
klassOop k_oop = pool->klass_at(index, CHECK);
instanceKlassHandle klass (THREAD, k_oop);
// 确保不是抽象函数
klass->check_valid_for_instantiation(true, CHECK);
//执行初始化,在instanceKlass的class中
klass->initialize(CHECK);
// At this point the class may not be fully initialized
// because of recursive initialization. If it is fully
// initialized & has_finalized is not set, we rewrite
// it into its fast version (Note: no locking is needed
// here since this is an atomic byte write and can be
// done more than once).
//
// Note: In case of classes with has_finalized we don't
// rewrite since that saves us an extra check in
// the fast version which then would call the
// slow version anyway (and do a call back into
// Java).
// If we have a breakpoint, then we don't rewrite
// because the _breakpoint bytecode would be lost.
oop obj = klass->allocate_instance(CHECK);
thread->set_vm_result(obj);
IRT_END
DEF_KLASS_HANDLE
定义,它重载了->
实际执行的方法就是 instanceKlass
本身对应的方法initialize的核心实现在initialize_impl
,在初始化之前首先要确保link
完成,如果没有则开始验证
bool instanceKlass::link_class_impl(
instanceKlassHandle this_oop, bool throw_verifyerror, TRAPS) {
...
//1.
instanceKlassHandle super(THREAD, this_oop->super());
if (super.not_null()) {
//执行父类的 link_class_impl
}
//2.
objArrayHandle interfaces (THREAD, this_oop->local_interfaces());
int num_interfaces = interfaces->length();
for (int index = 0; index < num_interfaces; index++) {
//执行每一个接口的link_class_impl
}
...
//3.
bool verify_ok = verify_code(this_oop, throw_verifyerror, THREAD);
...
//重写类的方法的所有字节码。这必须发生在验证之后,而且在类的第一个方法执行之前,同时只能执行一次
this_oop->rewrite_class(CHECK_false);
...
//4.
this_oop->relocate_and_link_methods(CHECK_false);
//5.
this_oop->set_init_state(linked);
...
}
当没有执行link的时候,开始按照如下步骤执行
就是连接过程中的验证、准备、解析
Bytecodes::_invokespecial :
指令。如果发现这个类没有加载过,则会执行加载对应字节码的流程link的所有状态如下 enum ClassState { unparsable_by_gc = 0, // object is not yet parsable by gc. Value of _init_state at object allocation. allocated, // allocated (but not yet linked) loaded, // loaded and inserted in class hierarchy (but not linked yet) linked, // successfully linked/verified (but not initialized yet) being_initialized, // currently running class initializer fully_initialized, // initialized (successfull final state) initialization_error // error happened during initialization }; 复制代码
link完成之后开始执行真正的初始化
initialization_error
,释放锁,并抛出NoClassDefFoundError
being_initialized
,并释放锁。然后按照每个字段在ClassFile中出现的顺序,一个个的按照类的ConstantValue属性中的值初始化 新建类的 final static字段ExceptionInInitializerError
来包装扔出来的异常,如果由于OOM导致无法创建ExceptionInInitializerError,则会抛出OOM。在抛出去之前,获取锁,标记异常,唤醒所有其他的线程,并释放锁自此 klass->initialize(CHECK);
执行完毕。开始在堆上分配内存
instanceOop instanceKlass::allocate_instance(TRAPS) {
assert(!oop_is_instanceMirror(), "wrong allocation path");
bool has_finalizer_flag = has_finalizer(); // Query before possible GC
//获取大小
int size = size_helper(); // Query before forming handle.
KlassHandle h_k(THREAD, as_klassOop());
instanceOop i;
//分配内存
i = (instanceOop)CollectedHeap::obj_allocate(h_k, size, CHECK_NULL);
if (has_finalizer_flag && !RegisterFinalizersAtInit) {
i = register_finalizer(i, CHECK_NULL);
}
return i;
}
自此初始化结束
执行如下
CASE(_dup): /* Duplicate the top item on the stack */
dup(topOfStack);
UPDATE_PC_AND_TOS_AND_CONTINUE(1, 1);
本质上,就是拷贝
tos[Interpreter::expr_index_at(-to_offset)] =
(intptr_t)tos[Interpreter::expr_index_at(-from_offset)];
关键部分如下
CASE(_invokespecial):
CASE(_invokestatic): {
u2 index = Bytes::get_native_u2(pc+1);
ConstantPoolCacheEntry* cache = cp->entry_at(index);
...
if ((Bytecodes::Code)opcode == Bytecodes::_invokespecial) {
CHECK_NULL(STACK_OBJECT(-(cache->parameter_size())));
}
//这里会找到对应的方法执行,f1对于不同的类型有不同的实现,对于 invokespecial指令来说,它就是 <init> 方法
callee = (methodOop) cache->f1();
...
//返回
UPDATE_PC_AND_RETURN(0);
特殊方法:在java虚拟机中,所有的构造函数都拥有一个一样的特殊名字<init>
,它由编译器提供,由于名字本身是非法的,所以无法通过java语言来写,要去执行它只能通过JVM的指令invokespecial
,并且只会在没有初始化的实例上执行。
<cinit>对比<init>,<cinit>不是初始化方法,不会被JVM指令执行。同样的它也并不是一个合法的名字,名字本身由编译器提供,<cinit>的执行是属于初始化流程的一部分。
<cinit>是由编译器自动收集类中的所有变量的赋值动作和静态语句块中的语句合并产生的。
当然这也意味着如果没有这些,在生成字节码的时候也可以不生成这些方法
仅从对应的字节指令解析开始 获取到了指令之后,跳转到run开始执行解析
//883行
run:
...
//892行
while(1){
...
opcode = *pc
...
switch(opcode){
CASE(_new):{
...
UPDATE_PC_AND_TOS_AND_CONTINUE(3, 1);
}
...
}
...
do_continue: ;
}
它本身是个宏定义
#undef CASE
#ifdef USELABELS
#define CASE(opcode) opc ## opcode
#define DEFAULT opc_default
#else
#define CASE(opcode) case Bytecodes:: opcode
#define DEFAULT default
#endif
可以在Bytecodes.hpp中找到对应的指令
enum Code{
...
_new = 187, // 0xbb
_newarray = 188, // 0xbc
_anewarray = 189, // 0xbd
...
}
它是个宏定义,抽取部分如下
UPDATE_PC_AND_TOS_AND_CONTINUE(opsize, stack) { \
pc += opsize; opcode = *pc; MORE_STACK(stack); \
DO_UPDATE_INSTRUCTION_COUNT(opcode); \
DEBUGGER_SINGLE_STEP_NOTIFY(); \
goto do_continue; \
}