Lines Matching defs:Thread
166 // - Thread
173 // ======= Thread ========
175 void* Thread::allocate(size_t size, bool throw_excpt, MEMFLAGS flags) {
190 ((Thread*) aligned_addr)->_real_malloc_address = real_malloc_addr;
198 void Thread::operator delete(void* p) {
200 void* real_malloc_addr = ((Thread*) p)->_real_malloc_address;
212 Thread::Thread() {
298 void Thread::initialize_thread_local_storage() {
311 void Thread::record_stack_base_and_size() {
331 Thread::~Thread() {
369 // clear thread local storage if the Thread is deleting itself
370 if (this == Thread::current()) {
382 void Thread::run() {
388 void check_for_dangling_thread_pointer(Thread *thread) {
389 assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(),
390 "possibility of dangling Thread pointer");
397 void Thread::trace(const char* msg, const Thread* const thread) {
423 tty->print_cr("Thread::%s " INTPTR_FORMAT " [%lx] %s (prio: %d)", msg, thread, thread->osthread()->thread_id(), name, prio);
428 ThreadPriority Thread::get_priority(const Thread* const thread) {
437 void Thread::set_priority(Thread* thread, ThreadPriority priority) {
445 void Thread::start(Thread* thread) {
448 // being called from a Java method synchronized on the Thread object.
463 void Thread::send_async_exception(oop java_thread, oop java_throwable) {
564 // Thread is in the process of exiting. This is always checked
654 SR_lock()->wait(!Thread::current()->is_Java_thread(), i * delay);
730 SR_lock()->wait(!Thread::current()->is_Java_thread(), i * delay);
789 void Thread::interrupt(Thread* thread) {
795 bool Thread::is_interrupted(Thread* thread, bool clear_interrupted) {
805 bool Thread::claim_oops_do_par_case(int strong_roots_parity) {
823 void Thread::oops_do(OopClosure* f, CodeBlobClosure* cf) {
830 void Thread::nmethods_do(CodeBlobClosure* cf) {
834 void Thread::print_on(outputStream* st) const {
843 // Thread::print_on_error() is called by fatal error handler. Don't use
845 void Thread::print_on_error(outputStream* st, char* buf, int buflen) const {
852 else st->print("Thread");
863 void Thread::print_owned_locks_on(outputStream* st) const {
878 bool Thread::owns_locks_but_compiled_lock() const {
893 void Thread::check_for_valid_safepoint_state(bool potential_vm_operation) {
917 warning("Thread holding lock at safepoint that vm can block on: %s", cur->name());
930 bool Thread::is_in_stack(address adr) const {
931 assert(Thread::current() == this, "is_in_stack can only be called from current thread");
944 bool Thread::is_lock_owned(address adr) const {
948 bool Thread::set_as_starting_thread() {
992 // Creates the initial Thread
1124 // Thread gets assigned specified name and null target
1134 // Thread gets assigned name "Thread-nnn" and null target
1135 // (java.lang.Thread doesn't have a constructor taking only a ThreadGroup argument)
1171 NamedThread::NamedThread() : Thread() {
1203 WatcherThread::WatcherThread() : Thread() {
1209 // used, unless a Java thread with priority java.lang.Thread.MAX_PRIORITY
1277 assert(watcher_thread() == Thread::current(), "thread consistency check");
1322 // Thread destructor usually does this..
1378 Thread::print_on(st);
1472 Thread()
1530 Thread()
1555 // The thread is still suspended when we reach here. Thread must be explicit started
1625 // Thread is now sufficient initialized to be handled by the safepoint code as being
1630 assert(!Thread::current()->owns_locks(), "sanity check");
1687 // Thread is exiting. So set thread_status field in java.lang.Thread class to TERMINATED.
1727 // java.lang.Thread.dispatchUncaughtException
1732 // Check if the method Thread.dispatchUncaughtException() exists. If so
1786 // Call Thread.exit(). We try 3 times in case we got another Thread.stop during
1787 // the execution of the method. If that is not enough, then we don't really care. Thread.stop
1858 // These things needs to be done while we are still a Java Thread. Make sure that thread
1974 Thread* thread = ThreadLocalStorage::thread();
1988 if (Thread::is_lock_owned(adr)) return true;
2163 assert(Thread::current()->is_VM_thread(), "should be in the vm thread");
2172 // Actually throw the Throwable against the target Thread - however
2205 Thread::interrupt(this);
2483 assert(Thread::current() == this, "from different thread");
2681 Thread* thread = Thread::current();
2705 Thread::oops_do(f, cf);
2766 Thread::nmethods_do(cf); // (super method is a no-op)
2811 Thread::print_on(st);
2815 st->print_cr(" java.lang.Thread.State: %s", java_lang_Thread::thread_status_name(thread_oop));
2865 Thread *cur = Thread::current();
2895 name_str = Thread::name();
2899 name_str = Thread::name();
2953 assert(Threads_lock->owner() == Thread::current(), "must have threads lock");
2954 // Link Java Thread object <-> C++ Thread
2967 Handle thread_oop(Thread::current(),
2980 Thread::set_priority(this, prio);
3392 Thread* vmthread = VMThread::vm_thread();
4052 Events::log(p, "Thread added: " INTPTR_FORMAT, p);
4104 Events::log(p, "Thread exited: " INTPTR_FORMAT, p);
4316 void Threads::print_on_error(outputStream* st, Thread* current, char* buf, int buflen) {
4388 void Thread::SpinAcquire (volatile int * adr, const char * LockName) {
4404 Thread::current()->_ParkEvent->park(1) ;
4417 void Thread::SpinRelease (volatile int * adr) {
4435 // dedicated Thread._MuxEvent instance. If we're interested in
4462 // the stranding window. Thread/Node structures must be aligned on 256-byte
4480 void Thread::muxAcquire (volatile intptr_t * Lock, const char * LockName) {
4488 ParkEvent * const Self = Thread::current()->_MuxEvent ;
4526 void Thread::muxAcquireW (volatile intptr_t * Lock, ParkEvent * ev) {
4606 void Thread::muxRelease (volatile intptr_t * Lock) {