1. Class的属性
在JVM中，通常一个class会初始化成Klass（接口）, InstanceKlass（实例）, Method（方法）， ConstantsPool（常量区）
在上图我们可以看到一个大概的Method,ConstantsPool,InstanceKlass之间的关系
InstanceKlass 里面保存着ConstantPool指针,Method指针的数组
Method对象里保存着ConstMethod指针
ConstMethod里保存着ConstantsPool的指针
ConstantsPool里保存着InstanceKlass的指针
我们可以通过Method -> ConstMethod -> ConstantsPool ->InstanceKlass构建Method 和InstanceKlass关系
2. Method
Method结构体如下，我们可以看到在Method的只是一个载体，保存着和方法区相关的指针
// |------------------------------------------------------| // | header | // | klass | // |------------------------------------------------------| // | ConstMethod* (oop) | // |------------------------------------------------------| // | methodData (oop) | // | methodCounters | // |------------------------------------------------------| // | access_flags | // | vtable_index | // |------------------------------------------------------| // | result_index (C++ interpreter only) | // |------------------------------------------------------| // | method_size | intrinsic_id| flags | // |------------------------------------------------------| // | code (pointer) | // | i2i (pointer) | // | adapter (pointer) | // | from_compiled_entry (pointer) | // | from_interpreted_entry (pointer) | // |------------------------------------------------------| // | native_function (present only if native) | // | signature_handler (present only if native) | // |------------------------------------------------------| class Method : public Metadata { friend class VMStructs; private: ConstMethod* _constMethod; // Method read-only data. MethodData* _method_data; MethodCounters* _method_counters; AccessFlags _access_flags; // Access flags int _vtable_index; // vtable index of this method (see VtableIndexFlag) ... nmethod* volatile _code; // Points to the corresponding piece of native code }
我们主要介绍Method结构体中的MethodData、ConstMethod、nmethod
2.1 MethodData
MethodData结构基础是ProfileData，记录函数运行状态下的数据，通常JIT编译的时候有多个Level，C2级别编译下需要进行编译优化的统计分析的数据，下表是几种JIT的编译级别
* The system supports 5 execution levels: * * level 0 - interpreter * * level 1 - C1 with full optimization (no profiling) * * level 2 - C1 with invocation and backedge counters * * level 3 - C1 with full profiling (level 2 + MDO) * * level 4 - C2
MethodData里面分为3个部分，一个是函数类型等运行相关统计数据，一个是参数类型运行相关统计数据，还有一个是extra扩展区保存着deoptimization的相关信息，整个内存情况请参考下图
我们介绍一种extra扩展区的SpeculativeTrapData类型，这是在JVM在进行的deoptimization method A过程中会反向的将method A指针保存到method A调用的Method的Extra data中
2.2 ConstMethod
ConstMethod是Method的相关统计信息，如代码大小，代码名字的索引，方法的序列号，本地参数的数量等
1 enum { 2 _has_linenumber_table = 0x0001, 3 _has_checked_exceptions = 0x0002, 4 _has_localvariable_table = 0x0004, 5 _has_exception_table = 0x0008, 6 _has_generic_signature = 0x0010, 7 _has_method_parameters = 0x0020, 8 _is_overpass = 0x0040, 9 _has_method_annotations = 0x0080, 10 _has_parameter_annotations = 0x0100, 11 _has_type_annotations = 0x0200, 12 _has_default_annotations = 0x0400 13 }; 14 15 // Bit vector of signature 16 // Callers interpret 0=not initialized yet and 17 // -1=too many args to fix, must parse the slow way. 18 // The real initial value is special to account for nonatomicity of 64 bit 19 // loads and stores. This value may updated and read without a lock by 20 // multiple threads, so is volatile. 21 volatile uint64_t _fingerprint; 22 23 ConstantPool* _constants; // Constant pool 24 25 // Raw stackmap data for the method 26 Array<u1>* _stackmap_data; 27 28 int _constMethod_size; 29 u2 _flags; 30 u1 _result_type; // BasicType of result 31 32 // Size of Java bytecodes allocated immediately after Method*. 33 u2 _code_size; 34 u2 _name_index; // Method name (index in constant pool) 35 u2 _signature_index; // Method signature (index in constant pool) 36 u2 _method_idnum; // unique identification number for the method within the class 37 // initially corresponds to the index into the methods array. 38 // but this may change with redefinition 39 u2 _max_stack; // Maximum number of entries on the expression stack 40 u2 _max_locals; // Number of local variables used by this method 41 u2 _size_of_parameters; // size of the parameter block (receiver + arguments) in words 42 u2 _orig_method_idnum; // Original unique identification number for the method
其中_constants，_method_idnum这两个是链接method的参数，因为method有constMethod指针，但constMethod没有method的指针，如何通过constMethod来获取Method，需要通过ConstantPool -> InstanceKlass -> Method数组->第_method_idnum个来获取Method指针
2.3 nmethod
nmethod全名native method，指向的是Java method编译的一个版本。当一个方法被JNI编译后会生成一个nmethod，指向的是编译的代码，整个 nmethod结构包含如下：
1 // - header (the nmethod structure) 2 // [Relocation] 3 // - relocation information 4 // - constant part (doubles, longs and floats used in nmethod) 5 // - oop table 6 // [Code] 7 // - code body 8 // - exception handler 9 // - stub code 10 // [Debugging information] 11 // - oop array 12 // - data array 13 // - pcs 14 // [Exception handler table] 15 // - handler entry point array 16 // [Implicit Null Pointer exception table] 17 // - implicit null table array
里面包含的代码段，异常处理等，有一个指向method的指针，和指向method*的指针jmethodID
nmethod本质是一个codeblob，被保存在codecache中的CodeHeap堆区的HeapBlock块中。Method保存着最新的nmethod的指针，同时nmethod也有指向被编译的Method的指针。在上图的表示中，我们可以通过轮训整个codecache的codeheap区获取到所有已经编译的nmethod
2.3.1 nmethod的状态
1 enum { in_use = 0, // executable nmethod 2 not_entrant = 1, // marked for deoptimization but activations may still exist, 3 // will be transformed to zombie when all activations are gone 4 zombie = 2, // no activations exist, nmethod is ready for purge 5 unloaded = 3 }; // there should be no activations, should not be called, 6 // will be transformed to zombie immediately
nmethod有4种状态：
0代表这还在使用
1表示可以被转化成zombie的状态，但依然存活
2是zombie状态代表nmethod可被回收
3是not_entrant和zombie的中间状态，表示可以立刻转化成zombie状态
nmethod的状态的改变是通过sweeper来改变，比如在deoptimization场景下原来已经编译的nmethod设置成not_entrant的状态，通过sweeper最后转化成了zombie的状态后被回收，而当nmethod在0，1的状态下还是代表存活的状态
2.3.2 nmethod编译
nmethod是通过CompilerThread线程(JavaThread)进行独立编译的，对不同的C1,C2 级别会构建不同数量的线程，默认是C1是1个线程，C2是2个线程，该线程数量无法通过参数设置改变线程数量
线程会去轮训CompileQueue的队列，CompileQueue里会保存着每个要执行的CompileTask，当CompileQueue的任务执行完后线程会堵塞
1 void CompileBroker::compiler_thread_loop() { 2 CompilerThread* thread = CompilerThread::current(); 3 CompileQueue* queue = thread->queue(); 4 ... 5 // Poll for new compilation tasks as long as the JVM runs. Compilation 6 // should only be disabled if something went wrong while initializing the 7 // compiler runtimes. This, in turn, should not happen. The only known case 8 // when compiler runtime initialization fails is if there is not enough free 9 // space in the code cache to generate the necessary stubs, etc. 10 while (!is_compilation_disabled_forever()) { 11 // We need this HandleMark to avoid leaking VM handles. 12 HandleMark hm(thread); 13 14 if (CodeCache::unallocated_capacity() < CodeCacheMinimumFreeSpace) { 15 // the code cache is really full 16 handle_full_code_cache(); 17 } 18 19 CompileTask* task = queue->get(); 20 if (task == NULL) { 21 continue; 22 } 23 24 // Give compiler threads an extra quanta. They tend to be bursty and 25 // this helps the compiler to finish up the job. 26 if( CompilerThreadHintNoPreempt ) 27 os::hint_no_preempt(); 28 29 // trace per thread time and compile statistics 30 CompilerCounters* counters = ((CompilerThread*)thread)->counters(); 31 PerfTraceTimedEvent(counters->time_counter(), counters->compile_counter()); 32 33 // Assign the task to the current thread. Mark this compilation 34 // thread as active for the profiler. 35 CompileTaskWrapper ctw(task); 36 nmethodLocker result_handle; // (handle for the nmethod produced by this task) 37 task->set_code_handle(&result_handle); 38 methodHandle method(thread, task->method()); 39 40 // Never compile a method if breakpoints are present in it 41 if (method()->number_of_breakpoints() == 0) { 42 // Compile the method. 43 if ((UseCompiler || AlwaysCompileLoopMethods) && CompileBroker::should_compile_new_jobs()) { 44 invoke_compiler_on_method(task); 45 } else { 46 // After compilation is disabled, remove remaining methods from queue 47 method->clear_queued_for_compilation(); 48 task->set_failure_reason("compilation is disabled"); 49 } 50 } 51 } 52 53 // Shut down compiler runtime 54 shutdown_compiler_runtime(thread->compiler(), thread); 55 }
当该方法有断点的时候并不进行编译，当参数-XX:-BackgroundCompilation设置成不是后台编译的时候，并不代表是在用户线程编译，而是提交任务CompileTask到CompileQueue，唯一的区别是堵塞当前线程等待CompileThread直到Task编译成功
1 void CompileBroker::compile_method_base(methodHandle method, 2 int osr_bci, 3 int comp_level, 4 methodHandle hot_method, 5 int hot_count, 6 const char* comment, 7 Thread* thread) { 8 ...... 9 10 if (blocking) { 11 wait_for_completion(task); 12 } 13 }
2.3.3 nmethod的回收(sweep)
在2.3.2中描述过，nmethod进入zombie状态，代表着该nmethod会回收，nmethod是在GC的时候被回收的么？并不是而是在接收CompileTask的时候由CompileThread来触发，但是并不代表着GC无关，这里有个比较复杂的算法，在GC的时候会更改一些统计数据。
CompileThread 满足下列条件会触发nmethod 进行sweep函数NMethodSweeper::possibly_sweep();
一轮sweep :代表从nmethod从头到尾一次回收
当从CompileQueue里获取到ComileTask的时候触发
当从CompileQueue里没有获取到ComileTask的时候，在等待一定的时间NmethodSweepCheckInterval（default=5） * 1000后触发
当从CodeCache已经满的情况下（-XX:ReservedCodeCacheSize=100M）
当然触发possibly_sweep并不代表一定会触发一定去回收nmethod 
在上图我们可以看到整一个nmethod的回收是个复杂的算法
首先取决于你的-XX:ReservedCodeCacheSize参数，JVM会以16M为一次，所允许的最大次数为ReservedCodeCacheSize/16M
_time_counter代表已经进入Softpoint的次数（也就是前面提到的GC）
_last_sweep代表着已经sweep完成的次数
CodeCache::reverse_free_ratio()=最大的容量/空闲的内存
_sweep_fractions_left 默认值ReservedCodeCacheSize/16M当调用possibly_sweep的时候会减去1，当等于0的时候代表sweep 结束（设置_should_sweep =false），需要等到进入softpoint才能重置会ReservedCodeCacheSize/16M
我们可以看到当进入Softpoint次数越多，空闲的内存越少越会促发sweep code cache, 而调用函数NMethodSweeper::sweep_code_cache并不代表一定会回收所有的nmethod，在函数里还有一个 int todo = (CodeCache::nof_nmethods() - _seen) / _sweep_fractions_left;来控制这次轮训多少个nmethod，_seen代表这一轮sweep 已经轮训的个数，CodeCache::nof_nmethods()代表nmethods的总数，_sweep_fractions_left就是前面定义的，我们可以看到在sweep_code_cache并不是一次全部轮询所有的nmethods，而是将剩余的总数/_sweep_fractions_left的数量，越到一轮的sweep后期清除的数量越多，是一个渐进式的回收方式。
函数NMethodSweeper::mark_active_nmethods()会被进入softpoint的时候触发
1 void NMethodSweeper::mark_active_nmethods() { 2 assert(SafepointSynchronize::is_at_safepoint(), "must be executed at a safepoint"); 3 // If we do not want to reclaim not-entrant or zombie methods there is no need 4 // to scan stacks 5 if (!MethodFlushing) { 6 return; 7 } 8 9 // Increase time so that we can estimate when to invoke the sweeper again. 10 _time_counter++; 11 12 // Check for restart 13 assert(CodeCache::find_blob_unsafe(_current) == _current, "Sweeper nmethod cached state invalid"); 14 if (!sweep_in_progress()) { 15 _seen = 0; 16 _sweep_fractions_left = NmethodSweepFraction; 17 _current = CodeCache::first_nmethod(); 18 _traversals += 1; 19 _total_time_this_sweep = Tickspan(); 20 Threads::nmethods_do(&mark_activation_closure); 21 22 } else { 23 // Only set hotness counter 24 tty->print_cr("### Sweep mark_active_nmethods not in progress %d /" PTR_FORMAT " ", _traversals, _current); 25 Threads::nmethods_do(&set_hotness_closure); 26 } 27 28 OrderAccess::storestore(); 29 }
在函数里我们看到重置了_seen 和 _sweep_fractions_left，而并不是每个nmethod进入not_entrant都能进入zombie状态，同时要不能被VM调用或者ServiceThread
1 bool nmethod::can_convert_to_zombie() { 2 assert(is_not_entrant(), "must be a non-entrant method"); 3 4 // Since the nmethod sweeper only does partial sweep the sweeper's traversal 5 // count can be greater than the stack traversal count before it hits the 6 // nmethod for the second time. 7 tty->print_cr("### nmethod stack_traversal_mark %d %d",stack_traversal_mark(),NMethodSweeper::traversal_count()); 8 return stack_traversal_mark()+1 < NMethodSweeper::traversal_count() && 9 !is_locked_by_vm(); 10 }