vm/runtime/thread.cpp

154 THREAD_LOCAL_DECL Thread* Thread::_thr_current = NULL;
157 // - Thread
164 // ======= Thread ========
166 void* Thread::allocate(size_t size, bool throw_excpt, MEMFLAGS flags) {
182     ((Thread*) aligned_addr)->_real_malloc_address = real_malloc_addr;
190 void Thread::operator delete(void* p) {
192     void* real_malloc_addr = ((Thread*) p)->_real_malloc_address;
204 Thread::Thread() {
293 void Thread::initialize_thread_current() {
295   assert(_thr_current == NULL, "Thread::current already initialized");
300   assert(Thread::current() == ThreadLocalStorage::thread(), "TLS mismatch!");
303 void Thread::clear_thread_current() {
304   assert(Thread::current() == ThreadLocalStorage::thread(), "TLS mismatch!");
311 void Thread::record_stack_base_and_size() {
331   log_debug(os, thread)("Thread " UINTX_FORMAT " stack dimensions: "
338 Thread::~Thread() {
383   // clear Thread::current if thread is deleting itself.
385   if (this == Thread::current()) {
393 void Thread::run() {
399 void check_for_dangling_thread_pointer(Thread *thread) {
400   assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(),
401          "possibility of dangling Thread pointer");
405 ThreadPriority Thread::get_priority(const Thread* const thread) {
413 void Thread::set_priority(Thread* thread, ThreadPriority priority) {
420 void Thread::start(Thread* thread) {
422   // being called from a Java method synchronized on the Thread object.
437 void Thread::send_async_exception(oop java_thread, oop java_throwable) {
537       // Thread is in the process of exiting. This is always checked
627         SR_lock()->wait(!Thread::current()->is_Java_thread(), i * delay);
702       SR_lock()->wait(!Thread::current()->is_Java_thread(), i * delay);
762 void Thread::interrupt(Thread* thread) {
767 bool Thread::is_interrupted(Thread* thread, bool clear_interrupted) {
776 bool Thread::claim_oops_do_par_case(int strong_roots_parity) {
790 void Thread::oops_do(OopClosure* f, CodeBlobClosure* cf) {
797 void Thread::metadata_handles_do(void f(Metadata*)) {
798   // Only walk the Handles in Thread.
806 void Thread::print_on(outputStream* st) const {
820 // Thread::print_on_error() is called by fatal error handler. Don't use
822 void Thread::print_on_error(outputStream* st, char* buf, int buflen) const {
829   else                                { st->print("Thread"); }
844 void Thread::print_owned_locks_on(outputStream* st) const {
859 bool Thread::owns_locks_but_compiled_lock() const {
874 void Thread::check_for_valid_safepoint_state(bool potential_vm_operation) {
899         fatal("Thread holding lock at safepoint that vm can block on: %s", cur->name());
912 bool Thread::is_in_stack(address adr) const {
913   assert(Thread::current() == this, "is_in_stack can only be called from current thread");
922 bool Thread::is_in_usable_stack(address adr) const {
935 bool Thread::is_lock_owned(address adr) const {
939 bool Thread::set_as_starting_thread() {
983 // Creates the initial Thread
1110     // Thread gets assigned specified name and null target
1120     // Thread gets assigned name "Thread-nnn" and null target
1121     // (java.lang.Thread doesn't have a constructor taking only a ThreadGroup argument)
1155 NamedThread::NamedThread() : Thread() {
1184   Thread::print_on(st);
1199 WatcherThread::WatcherThread() : Thread(), _crash_protection(NULL) {
1205     // used, unless a Java thread with priority java.lang.Thread.MAX_PRIORITY
1282     assert(watcher_thread() == Thread::current(), "thread consistency check");
1387   Thread::print_on(st);
1521                        Thread()
1588                        Thread()
1609   // The thread is still suspended when we reach here. Thread must be explicit started
1677   // Thread is now sufficient initialized to be handled by the safepoint code as being
1682   assert(!Thread::current()->owns_locks(), "sanity check");
1739   // Thread is exiting. So set thread_status field in  java.lang.Thread class to TERMINATED.
1777       // Call method Thread.dispatchUncaughtException().
1808     // Call Thread.exit(). We try 3 times in case we got another Thread.stop during
1809     // the execution of the method. If that is not enough, then we don't really care. Thread.stop
1888   // These things needs to be done while we are still a Java Thread. Make sure that thread
2008   Thread* thread = Thread::current();
2021   if (Thread::is_lock_owned(adr)) return true;
2191   assert(Thread::current()->is_VM_thread(), "should be in the vm thread");
2200     // Actually throw the Throwable against the target Thread - however
2234   Thread::interrupt(this);
2516   log_debug(os, thread)("Thread " UINTX_FORMAT " stack guard pages activated: "
2522   assert(Thread::current() == this, "from different thread");
2546   log_debug(os, thread)("Thread " UINTX_FORMAT " stack guard pages removed: "
2746     Thread* thread = Thread::current();
2770   Thread::oops_do(f, cf);
2899   Thread::print_on(st);
2903     st->print_cr("   java.lang.Thread.State: %s", java_lang_Thread::thread_status_name(thread_oop));
2967     Thread *cur = Thread::current();
2994       name_str = Thread::name();
2997     name_str = Thread::name();
3043   assert(Threads_lock->owner() == Thread::current(), "must have threads lock");
3044   // Link Java Thread object <-> C++ Thread
3057   Handle thread_oop(Thread::current(),
3070   Thread::set_priority(this, prio);
3658     Thread* vmthread = VMThread::vm_thread();
3683   Thread* THREAD = Thread::current();
4248   Events::log(p, "Thread added: " INTPTR_FORMAT, p2i(p));
4294   Events::log(p, "Thread exited: " INTPTR_FORMAT, p2i(p));
4337            "Thread " PTR_FORMAT " has incorrect parity %d != %d", p2i(p), thread_parity, _thread_claim_parity);
4394   virtual void do_thread(Thread* thread) {
4400   // Only walk the Handles in Thread.
4526 void Threads::print_on_error(Thread* this_thread, outputStream* st, Thread* current, char* buf,
4542   Thread* _current;
4547   PrintOnErrorClosure(outputStream* st, Thread* current, char* buf,
4551   virtual void do_thread(Thread* thread) {
4560 void Threads::print_on_error(outputStream* st, Thread* current, char* buf,
4626 void Thread::SpinAcquire(volatile int * adr, const char * LockName) {
4653 void Thread::SpinRelease(volatile int * adr) {
4677 //    dedicated Thread._MuxEvent instance.  If we're interested in
4704 //    the stranding window.  Thread/Node structures must be aligned on 256-byte
4722 void Thread::muxAcquire(volatile intptr_t * Lock, const char * LockName) {
4730   ParkEvent * const Self = Thread::current()->_MuxEvent;
4768 void Thread::muxAcquireW(volatile intptr_t * Lock, ParkEvent * ev) {
4853 void Thread::muxRelease(volatile intptr_t * Lock)  {