jdk-sandbox: comparison src/hotspot/share/runtime/thread.cpp

equal deleted inserted replaced

-:35530ca3e0b2
+:67e3a8b3449c
 }
 // Base class for all threads: VMThread, WatcherThread, ConcurrentMarkSweepThread,
 // JavaThread
+DEBUG_ONLY(Thread* Thread::_starting_thread = NULL;)
 Thread::Thread() {
+DEBUG_ONLY(_run_state = PRE_CALL_RUN;)
 // stack and get_thread
 set_stack_base(NULL);
 set_stack_size(0);
 set_self_raw_id(0);
 set_lgrp_id(-1);
 // to BarrierSet::set_barrier_set().
 BarrierSet* const barrier_set = BarrierSet::barrier_set();
 if (barrier_set != NULL) {
 barrier_set->on_thread_create(this);
 } else {
-#ifdef ASSERT
+// Only the main thread should be created before the barrier set
-static bool initial_thread_created = false;
+// and that happens just before Thread::current is set. No other thread
-assert(!initial_thread_created, "creating thread before barrier set");
+// can attach as the VM is not created yet, so they can't execute this code.
-initial_thread_created = true;
+// If the main thread creates other threads before the barrier set that is an error.
-#endif // ASSERT
+assert(Thread::current_or_null() == NULL, "creating thread before barrier set");
 }
 }
 void Thread::initialize_thread_current() {
 #ifndef USE_LIBRARY_BASED_TLS_ONLY
 MemTracker::record_thread_stack(stack_end(), stack_size());
 }
 #endif // INCLUDE_NMT
 void Thread::call_run() {
+DEBUG_ONLY(_run_state = CALL_RUN;)
 // At this point, Thread object should be fully initialized and
 // Thread::current() should be set.
+assert(Thread::current_or_null() != NULL, "current thread is unset");
+assert(Thread::current_or_null() == this, "current thread is wrong");
+// Perform common initialization actions
 register_thread_stack_with_NMT();
 JFR_ONLY(Jfr::on_thread_start(this);)
 log_debug(os, thread)("Thread " UINTX_FORMAT " stack dimensions: "
 PTR_FORMAT "-" PTR_FORMAT " (" SIZE_FORMAT "k).",
 os::current_thread_id(), p2i(stack_base() - stack_size()),
 p2i(stack_base()), stack_size()/1024);
+// Perform <ChildClass> initialization actions
+DEBUG_ONLY(_run_state = PRE_RUN;)
+this->pre_run();
 // Invoke <ChildClass>::run()
+DEBUG_ONLY(_run_state = RUN;)
 this->run();
 // Returned from <ChildClass>::run(). Thread finished.
-// Note: at this point the thread object may already have deleted itself.
+// Perform common tear-down actions
-// So from here on do not dereference *this*.
+assert(Thread::current_or_null() != NULL, "current thread is unset");
-// If a thread has not deleted itself ("delete this") as part of its
+assert(Thread::current_or_null() == this, "current thread is wrong");
-// termination sequence, we have to ensure thread-local-storage is
-// cleared before we actually terminate. No threads should ever be
+// Perform <ChildClass> tear-down actions
-// deleted asynchronously with respect to their termination.
+DEBUG_ONLY(_run_state = POST_RUN;)
-if (Thread::current_or_null_safe() != NULL) {
+this->post_run();
-assert(Thread::current_or_null_safe() == this, "current thread is wrong");
-Thread::clear_thread_current();
+// Note: at this point the thread object may already have deleted itself,
-}
+// so from here on do not dereference *this*. Not all thread types currently
+// delete themselves when they terminate. But no thread should ever be deleted
+// asynchronously with respect to its termination - that is what _run_state can
+// be used to check.
+assert(Thread::current_or_null() == NULL, "current thread still present");
 }
 Thread::~Thread() {
+// Attached threads will remain in PRE_CALL_RUN, as will threads that don't actually
+// get started due to errors etc. Any active thread should at least reach post_run
+// before it is deleted (usually in post_run()).
+assert(_run_state == PRE_CALL_RUN ||
+_run_state == POST_RUN, "Active Thread deleted before post_run(): "
+"_run_state=%d", (int)_run_state);
 // Notify the barrier set that a thread is being destroyed. Note that a barrier
 // set might not be available if we encountered errors during bootstrapping.
 BarrierSet* const barrier_set = BarrierSet::barrier_set();
 if (barrier_set != NULL) {
 barrier_set->on_thread_destroy(this);
 _SR_lock = NULL;
 // osthread() can be NULL, if creation of thread failed.
 if (osthread() != NULL) os::free_thread(osthread());
-// clear Thread::current if thread is deleting itself.
+// Clear Thread::current if thread is deleting itself and it has not
+// already been done. This must be done before the memory is deallocated.
 // Needed to ensure JNI correctly detects non-attached threads.
-if (this == Thread::current()) {
+if (this == Thread::current_or_null()) {
 Thread::clear_thread_current();
 }
 CHECK_UNHANDLED_OOPS_ONLY(if (CheckUnhandledOops) delete unhandled_oops();)
 }
 bool Thread::is_lock_owned(address adr) const {
 return on_local_stack(adr);
 }
 bool Thread::set_as_starting_thread() {
+assert(_starting_thread == NULL, "already initialized: "
+"_starting_thread=" INTPTR_FORMAT, p2i(_starting_thread));
 // NOTE: this must be called inside the main thread.
+DEBUG_ONLY(_starting_thread = this;)
 return os::create_main_thread((JavaThread*)this);
 }
 static void initialize_class(Symbol* class_name, TRAPS) {
 Klass* klass = SystemDictionary::resolve_or_fail(class_name, true, CHECK);
 assert(!end(), "precondition");
 _current = OrderAccess::load_acquire(&_current->_next);
 }
 NonJavaThread::NonJavaThread() : Thread(), _next(NULL) {
-// Add this thread to _the_list.
+assert(BarrierSet::barrier_set() != NULL, "NonJavaThread created too soon!");
+}
+NonJavaThread::~NonJavaThread() { }
+void NonJavaThread::add_to_the_list() {
 MutexLockerEx lock(NonJavaThreadsList_lock, Mutex::_no_safepoint_check_flag);
 _next = _the_list._head;
 OrderAccess::release_store(&_the_list._head, this);
 }
-NonJavaThread::~NonJavaThread() {
+void NonJavaThread::remove_from_the_list() {
-JFR_ONLY(Jfr::on_thread_exit(this);)
-// Remove this thread from _the_list.
 MutexLockerEx lock(NonJavaThreadsList_lock, Mutex::_no_safepoint_check_flag);
 NonJavaThread* volatile* p = &_the_list._head;
 for (NonJavaThread* t = *p; t != NULL; p = &t->_next, t = *p) {
 if (t == this) {
 *p = this->_next;
-// Wait for any in-progress iterators.
+// Wait for any in-progress iterators.  Concurrent synchronize is
+// not allowed, so do it while holding the list lock.
 _the_list._protect.synchronize();
 break;
 }
 }
+}
+void NonJavaThread::pre_run() {
+assert(BarrierSet::barrier_set() != NULL, "invariant");
+add_to_the_list();
+// This is slightly odd in that NamedThread is a subclass, but
+// in fact name() is defined in Thread
+assert(this->name() != NULL, "thread name was not set before it was started");
+this->set_native_thread_name(this->name());
+}
+void NonJavaThread::post_run() {
+JFR_ONLY(Jfr::on_thread_exit(this);)
+remove_from_the_list();
+// Ensure thread-local-storage is cleared before termination.
+Thread::clear_thread_current();
 }
 // NamedThread --  non-JavaThread subclasses with multiple
 // uniquely named instances should derive from this.
 NamedThread::NamedThread() :
 guarantee(_name != NULL, "alloc failure");
 va_list ap;
 va_start(ap, format);
 jio_vsnprintf(_name, max_name_len, format, ap);
 va_end(ap);
-}
-void NamedThread::initialize_named_thread() {
-set_native_thread_name(name());
 }
 void NamedThread::print_on(outputStream* st) const {
 st->print("\"%s\" ", name());
 Thread::print_on(st);
 }
 void WatcherThread::run() {
 assert(this == watcher_thread(), "just checking");
-this->set_native_thread_name(this->name());
 this->set_active_handles(JNIHandleBlock::allocate_block());
 while (true) {
 assert(watcher_thread() == Thread::current(), "thread consistency check");
 assert(watcher_thread() == this, "thread consistency check");
 }
 #endif // INCLUDE_JVMCI
 }
-// The first routine called by a new Java thread
+// First JavaThread specific code executed by a new Java thread.
+void JavaThread::pre_run() {
+// empty - see comments in run()
+}
+// The main routine called by a new Java thread. This isn't overridden
+// by subclasses, instead different subclasses define a different "entry_point"
+// which defines the actual logic for that kind of thread.
 void JavaThread::run() {
 // initialize thread-local alloc buffer related fields
 this->initialize_tlab();
-// used to test validity of stack trace backs
+// Used to test validity of stack trace backs.
+// This can't be moved into pre_run() else we invalidate
+// the requirement that thread_main_inner is lower on
+// the stack. Consequently all the initialization logic
+// stays here in run() rather than pre_run().
 this->record_base_of_stack_pointer();
 this->create_stack_guard_pages();
 this->cache_global_variables();
-// Thread is now sufficient initialized to be handled by the safepoint code as being
+// Thread is now sufficiently initialized to be handled by the safepoint code as being
 // in the VM. Change thread state from _thread_new to _thread_in_vm
 ThreadStateTransition::transition_and_fence(this, _thread_new, _thread_in_vm);
 assert(JavaThread::current() == this, "sanity check");
 assert(!Thread::current()->owns_locks(), "sanity check");
 JvmtiExport::post_thread_start(this);
 }
 // We call another function to do the rest so we are sure that the stack addresses used
-// from there will be lower than the stack base just computed
+// from there will be lower than the stack base just computed.
 thread_main_inner();
+}
-// Note, thread is no longer valid at this point!
-}
 void JavaThread::thread_main_inner() {
 assert(JavaThread::current() == this, "sanity check");
 assert(this->threadObj() != NULL, "just checking");
 this->entry_point()(this, this);
 }
 DTRACE_THREAD_PROBE(stop, this);
+// Cleanup is handled in post_run()
+}
+// Shared teardown for all JavaThreads
+void JavaThread::post_run() {
 this->exit(false);
+// Defer deletion to here to ensure 'this' is still referenceable in call_run
+// for any shared tear-down.
 this->smr_delete();
 }
 static void ensure_join(JavaThread* thread) {
 // We do not need to grab the Threads_lock, since we are operating on ourself.
 Handle threadObj(thread, thread->threadObj());
 assert(threadObj.not_null(), "java thread object must exist");

changeset 53103	67e3a8b3449c
parent 53084	293cec2f7670
child 53121	4c4651aba203