Hotspot源码解析-第十二章-JavaThread的创建
在本章中会大量用到Handle，也就是句柄的概念，那么首先先把指针、引用、句柄的概念搞清楚
1、指针：在C/C++中大量使用指针，表示某个对象/内存的地址，不受 指向的类型限制，只是表示地址，这个概念好理解
2、引用：引用在面向对象语言（C++、Java）中大量存在，可以把引用等价于指针，区别在于，引用限定了类型，声明时是什么类型，就是什么类型，这样的好处就是不至于在运行时产生类型转换的错误
3、句柄：句柄其实就是对指针的一层包装，想像成家里电视机的遥控器，可以遥控很多电视机，句柄就是通过间接访问内存的方式，应对指针在运行过程中发生的变化，比如电视机换了一台，但是遥控还可以控制，就是这个道理
12.1 JavaThread的创建
12.1.1 thread.cpp
12.1.1.1 create_vm
create_vm函数内容太多，这里只截取了与本章相关的内容
// 绑定主线程到os级线程，在`第十一章`中讲过，JavaThread是继承自Thread，注意，这里的JavaThread只是虚拟机层面的Java级线程，并不是我们Java编码层面的线程，这个概念要区分来，但是Java编码层面的线程Thread，最终在虚拟机底层就是用JavaThread来表示的，从这点看，两者又是一样，抛开编码层面，就可以总结为：JavaThread就是一个Java线程的表示，后续章节也会细讲。new JavaThread()的实现细节看`章节12.1.2.1`
JavaThread* main_thread = new JavaThread();
// 设置线程状态，thread_state状态跟Java层面线程的状态（new、running等）不是一个概念，这个值主要标注线程当前运行状况，或者说在哪个层面运行，比如Java层面、虚拟机层面、native层面
main_thread->set_thread_state(_thread_in_vm);
// 设置线程栈基址和栈占用空间大小（可以得出栈顶最大值）
main_thread->record_stack_base_and_size();
main_thread->initialize_thread_local_storage(); // 初始化线程本地存储
// 分配JNI句柄存储块，并设置关联到当前线程
main_thread->set_active_handles(JNIHandleBlock::allocate_block());
// 将当前线程绑定到OS线程，细节看`章节12.2`
if (!main_thread->set_as_starting_thread()) {
// 主线程绑定失败，虚拟机退出
vm_shutdown_during_initialization(
"Failed necessary internal allocation. Out of swap space");
delete main_thread;
*canTryAgain = false; // don't let caller call JNI_CreateJavaVM again
return JNI_ENOMEM;
}
// 创建线程栈保护区，细节看`章节12.3`
main_thread->create_stack_guard_pages();
12.1.1.2 Thread::allocate
这个函数就是给线程分配内存的，分为两部分，一个是支持偏向锁；一个是不支持偏向锁
void* Thread::allocate(size_t size, bool throw_excpt, MEMFLAGS flags) {
if (UseBiasedLocking) { // 支持偏向锁
const int alignment = markOopDesc::biased_lock_alignment; // 偏向锁对齐大小
size_t aligned_size = size + (alignment - sizeof(intptr_t)); // 要分配的内存大小
// 实际分配内存操作，并返回分配的内存首地址
void* real_malloc_addr = throw_excpt? AllocateHeap(aligned_size, flags, CURRENT_PC)
: AllocateHeap(aligned_size, flags, CURRENT_PC,
AllocFailStrategy::RETURN_NULL);
// 处理对齐操作
void* aligned_addr = (void*) align_size_up((intptr_t) real_malloc_addr, alignment);
assert(((uintptr_t) aligned_addr + (uintptr_t) size) <=
((uintptr_t) real_malloc_addr + (uintptr_t) aligned_size),
"JavaThread alignment code overflowed allocated storage");
if (TraceBiasedLocking) { // 打印日志
if (aligned_addr != real_malloc_addr)
tty->print_cr("Aligned thread " INTPTR_FORMAT " to " INTPTR_FORMAT,
real_malloc_addr, aligned_addr);
}
// 给Thread对象中属性 _real_malloc_address 赋值为分配的内存首地址
((Thread*) aligned_addr)->_real_malloc_address = real_malloc_addr;
return aligned_addr;
} else { // 不支持偏向锁，直接分配
// 用AllocateHeap来在C堆（注意，这里不是Java堆，这个C堆就是所谓的进程运行时堆，参见`章节11.1.1`）中分配内存，AllocateHeap的细节看后面描述
return throw_excpt? AllocateHeap(size, flags, CURRENT_PC)
: AllocateHeap(size, flags, CURRENT_PC, AllocFailStrategy::RETURN_NULL);
}
}
AllocateHeap函数
inline char* AllocateHeap(size_t size, MEMFLAGS flags,
AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM) {
return AllocateHeap(size, flags, CURRENT_PC, alloc_failmode);
}
inline char* AllocateHeap(size_t size, MEMFLAGS flags,
const NativeCallStack& stack,
AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM) {
// 最终分配是通过系统调用malloc来完成的
char* p = (char*) os::malloc(size, flags, stack);
#ifdef ASSERT
if (PrintMallocFree) trace_heap_malloc(size, "AllocateHeap", p);
#endif
if (p == NULL && alloc_failmode == AllocFailStrategy::EXIT_OOM) {
vm_exit_out_of_memory(size, OOM_MALLOC_ERROR, "AllocateHeap");
}
return p;
}
12.1.1.3 JavaThread::JavaThread()构造函数
JavaThread::JavaThread(bool is_attaching_via_jni) :
Thread() // 先调用父类Thread的构造函数，看`章节12.1.1.4`
#if INCLUDE_ALL_GCS
, _satb_mark_queue(&_satb_mark_queue_set),
_dirty_card_queue(&_dirty_card_queue_set)
#endif // INCLUDE_ALL_GCS
{
// 进一步从Java线程角度初始化，看`章节12.1.1.5`
initialize();
if (is_attaching_via_jni) {
_jni_attach_state = _attaching_via_jni;
} else {
_jni_attach_state = _not_attaching_via_jni;
}
assert(deferred_card_mark().is_empty(), "Default MemRegion ctor");
}
12.1.1.4 Thread()构造函数
Thread::Thread() {
// 栈设置
set_stack_base(NULL); // 设置栈基址为Null
set_stack_size(0); // 初始化栈大小为0
set_self_raw_id(0); // 初始化线程原生id
set_lgrp_id(-1);
// 数据结构分配
set_osthread(NULL); // 对应的os线程，初始化时，还没有绑定，所以先设置null
// 设置资源分配区域，ResourceArea就是管理当前线程分配的内存区域，比如在哪个Chunk块
set_resource_area(new (mtThread)ResourceArea());
DEBUG_ONLY(_current_resource_mark = NULL;) // 赋值
// 设置句柄分配区域，HandleArea就是管理当前线程分配的句柄内存区域，比如在哪个Chunk块、句柄区域链表
set_handle_area(new (mtThread) HandleArea(NULL));
// 在C堆中分配最大元素Metadata个数为30的可增长的数组内存，用于存放元数据，并用元数组句柄指向
set_metadata_handles(new (ResourceObj::C_HEAP, mtClass) GrowableArray(30, true));
// 下面这些属性的含义可以看`章节111.1.4`
set_active_handles(NULL); // 设置指向当前线程持有的JNI句柄链表头指针，默认为Null
set_free_handle_block(NULL); // 设置空闲JNI句柄块的链表头指针，默认为Null
set_last_handle_mark(NULL); // 设置HandleMark的指针，默认为Null
// This initial value ==> never claimed.
_oops_do_parity = 0;
_metadata_on_stack_buffer = NULL;
// 将当前对象用HandleMark句柄来管理，在句柄链中，初始化时this即是链表头也是链表尾（last_handle_mark）
new HandleMark(this);
// 下面就是常规的初始化
debug_only(_owned_locks = NULL;)
debug_only(_allow_allocation_count = 0;)
NOT_PRODUCT(_allow_safepoint_count = 0;)
NOT_PRODUCT(_skip_gcalot = false;)
_jvmti_env_iteration_count = 0;
set_allocated_bytes(0);
_vm_operation_started_count = 0;
_vm_operation_completed_count = 0;
_current_pending_monitor = NULL;
_current_pending_monitor_is_from_java = true;
_current_waiting_monitor = NULL;
_num_nested_signal = 0;
omFreeList = NULL ;
omFreeCount = 0 ;
omFreeProvision = 32 ;
omInUseList = NULL ;
omInUseCount = 0 ;
#ifdef ASSERT
_visited_for_critical_count = false;
#endif
_SR_lock = new Monitor(Mutex::suspend_resume, "SR_lock", true);
_suspend_flags = 0;
// thread-specific hashCode stream generator state - Marsaglia shift-xor form
_hashStateX = os::random() ;
_hashStateY = 842502087 ;
_hashStateZ = 0x8767 ; // (int)(3579807591LL & 0xffff) ;
_hashStateW = 273326509 ;
_OnTrap = 0 ;
_schedctl = NULL ;
_Stalled = 0 ;
_TypeTag = 0x2BAD ;
// 为各事件分配内存
_ParkEvent = ParkEvent::Allocate (this) ;
_SleepEvent = ParkEvent::Allocate (this) ;
_MutexEvent = ParkEvent::Allocate (this) ;
_MuxEvent = ParkEvent::Allocate (this) ;
#ifdef CHECK_UNHANDLED_OOPS
if (CheckUnhandledOops) {
_unhandled_oops = new UnhandledOops(this);
}
#endif // CHECK_UNHANDLED_OOPS
#ifdef ASSERT
if (UseBiasedLocking) {
assert((((uintptr_t) this) & (markOopDesc::biased_lock_alignment - 1)) == 0, "forced alignment of thread object failed");
assert(this == _real_malloc_address ||
this == (void*) align_size_up((intptr_t) _real_malloc_address, markOopDesc::biased_lock_alignment),
"bug in forced alignment of thread objects");
}
#endif /* ASSERT */
}
12.1.1.5 JavaThread::initialize
// A JavaThread is a normal Java thread
void JavaThread::initialize() {
// Initialize fields
// Set the claimed par_id to UINT_MAX (ie not claiming any par_ids)
// 将par_id设置为uint(无符号Int)表示的最大值
set_claimed_par_id(UINT_MAX);
set_saved_exception_pc(NULL);
set_threadObj(NULL);
_anchor.clear();
set_entry_point(NULL);
// 设置jni要用的函数数组jni_NativeInterface，这个数组在jni.cpp文件中定义
set_jni_functions(jni_functions());
set_callee_target(NULL);
set_vm_result(NULL);
set_vm_result_2(NULL);
set_vframe_array_head(NULL);
set_vframe_array_last(NULL);
set_deferred_locals(NULL);
set_deopt_mark(NULL);
set_deopt_nmethod(NULL);
clear_must_deopt_id();
set_monitor_chunks(NULL);
set_next(NULL);
// 设置线程的状态为new，也就是刚创建
set_thread_state(_thread_new);
_terminated = _not_terminated;
_privileged_stack_top = NULL;
_array_for_gc = NULL;
_suspend_equivalent = false;
_in_deopt_handler = 0;
_doing_unsafe_access = false;
_stack_guard_state = stack_guard_unused;
(void)const_cast(_exception_oop = oop(NULL));
_exception_pc = 0;
_exception_handler_pc = 0;
_is_method_handle_return = 0;
_jvmti_thread_state= NULL;
_should_post_on_exceptions_flag = JNI_FALSE;
_jvmti_get_loaded_classes_closure = NULL;
_interp_only_mode = 0;
_special_runtime_exit_condition = _no_async_condition;
_pending_async_exception = NULL;
_thread_stat = NULL;
_thread_stat = new ThreadStatistics();
_blocked_on_compilation = false;
_jni_active_critical = 0;
_pending_jni_exception_check_fn = NULL;
_do_not_unlock_if_synchronized = false;
_cached_monitor_info = NULL;
_parker = Parker::Allocate(this) ;
#ifndef PRODUCT
_jmp_ring_index = 0;
for (int ji = 0 ; ji < jump_ring_buffer_size ; ji++ ) {
record_jump(NULL, NULL, NULL, 0);
}
#endif /* PRODUCT */
set_thread_profiler(NULL);
if (FlatProfiler::is_active()) {
// This is where we would decide to either give each thread it's own profiler
// or use one global one from FlatProfiler,
// or up to some count of the number of profiled threads, etc.
ThreadProfiler* pp = new ThreadProfiler();
pp->engage();
set_thread_profiler(pp);
}
// 设置线程安全点状态信息，底层线程的很多操作都要检查安全点，后面讲GC的时候会讲到
ThreadSafepointState::create(this);
debug_only(_java_call_counter = 0);
// JVMTI PopFrame support
_popframe_condition = popframe_inactive;
_popframe_preserved_args = NULL;
_popframe_preserved_args_size = 0;
_frames_to_pop_failed_realloc = 0;
pd_initialize();
}
12.1.2 thread.hpp
12.1.2.1 new JavaThread()
之前在线程描述的第十一章讲过，JavaThread是继承自Thread的，在JavaThread类中没有找到new运算符的实现函数，这种情况一般就要往上找，找它的父类，直到找到为此，很幸运在Thread类中有对new运算符的实现函数
void* operator new(size_t size) throw() { return allocate(size, true); }
在new函数中，实际调用的是allocate函数，该函数在thread.cpp源文件中实现，作用就是在进程的运行时堆中分配一块内存来存放JavaThread对象，分配细节看章节12.1.1.2，内存分配完后，要对JavaThread对象做一些赋值和初始化的工作，初始化细节看章节12.1.1.3