Lines Matching defs:thread
102 //oop _pending_exception; // pending exception for current thread
106 // Support for forcing alignment of thread objects for biased locking
137 // flag is checked by has_special_runtime_exit_condition() and java thread
143 // + mutex granting (do not enter monitors when thread is suspended)
152 // followed by some other interface call that requires the thread to
187 _external_suspend = 0x20000000U, // thread is asked to self suspend
188 _ext_suspended = 0x40000000U, // thread has self-suspended
189 _deopt_suspend = 0x10000000U, // thread needs to self suspend for deopt
209 static void trace(const char* msg, const Thread* const thread) PRODUCT_RETURN;
214 // One-element thread local free list
220 // The parity of the last strong_roots iteration in which this thread was
238 NOT_PRODUCT(int _allow_safepoint_count;) // If 0, thread allow a safepoint to happen
239 debug_only (int _allow_allocation_count;) // If 0, the thread is allowed to allocate oops.
262 ObjectMonitor* _current_pending_monitor; // ObjectMonitor this thread
266 // ObjectMonitor on which this thread called Object.wait()
269 // Private thread-local objectmonitor list - a simple cache organized as a SLL.
298 // thread entry point
307 // True iff the thread can perform GC operations at a safepoint.
308 // Generally will be true only of VM thread and parallel GC WorkGang
319 virtual char* name() const { return (char*)"Unknown thread"; }
321 // Returns the current thread
324 // Common thread operations
325 static void set_priority(Thread* thread, ThreadPriority priority);
326 static ThreadPriority get_priority(const Thread* const thread);
327 static void start(Thread* thread);
332 assert(Thread::current() == this, "set_native_thread_name can only be called on the current thread");
409 void set_osthread(OSThread* thread) { _osthread = thread; }
452 // For tracking the heavyweight monitor the thread is pending on.
466 // For tracking the ObjectMonitor on which this thread called Object.wait()
488 // calling thread does the update, this indicates that the calling thread
489 // has claimed the thread's stack as a root groop in the current
506 // Check if address is in the stack of the thread (not just for locks).
507 // Warning: the method can only be used on the running thread
510 // Sets this thread as starting thread. Returns failure if thread
515 // OS data associated with the thread
516 OSThread* _osthread; // Platform-specific thread information
558 // Deadlock detection support for Mutex locks. List of locks own by thread.
621 jint _hashStateW ; // Marsaglia Shift-XOR thread-local RNG
622 jint _hashStateX ; // thread-specific hashCode generator state
646 // ThreadLocalStorage::thread is warm -- it's called > 16K times in the same
660 Thread* thread = ThreadLocalStorage::thread();
661 assert(thread != NULL, "just checking");
662 return thread;
680 // May only be called once per thread.
685 void set_processed_thread(JavaThread *thread) { _processed_thread = thread; }
755 JavaThread* _next; // The next thread in the Threads list
756 oop _threadObj; // The Java level thread object
836 ThreadSafepointState *_safepoint_state; // Holds information about a thread during a safepoint
842 _thread_exiting, // JavaThread::exit() has been called for this thread
843 _thread_terminated, // JavaThread is removed from thread list
858 // handlers thread is in
865 _not_attaching_via_jni = 1, // thread is not attaching via JNI
866 _attaching_via_jni, // thread is attaching via JNI
867 _attached_via_jni // thread has attached via JNI
871 // A native thread that is attaching via JNI starts with a value
876 // State of the stack guard pages for this thread.
896 bool _is_compiling; // is true if a compilation is active inthis thread (one compilation per thread possible)
941 JavaThread(bool is_attaching_via_jni = false); // for main thread and JNI attached threads
958 // This function is called at thread creation to allow
959 // platform specific thread variables to be initialized.
965 // Cleanup on thread exit
992 // Prepare thread and add to priority queue. If a priority is
993 // not specified, use the priority of the thread object. Threads_lock
1003 // Allocates a new Java level thread object for this thread. thread_name may be NULL.
1025 // thread has called JavaThread::exit() or is terminated
1027 // thread is terminated (no longer on the threads list); we compare
1047 // per-thread memory recorder
1068 // don't surprise the thread that suspended us by returning
1074 static void check_safepoint_and_suspend_for_native_trans(JavaThread *thread);
1076 static void check_special_condition_for_native_trans(JavaThread *thread);
1081 static void check_special_condition_for_native_trans_and_transition(JavaThread *thread);
1087 // SR_lock to allow the thread to reach a stable thread state if
1088 // it is currently in a transient thread state.
1111 // Whenever a thread transitions from native to vm/java it must suspend
1281 // Returns true if (a) guard pages are not needed on this thread, (b) the
1339 // Returns the jni environment for this thread
1344 // Only return NULL if thread is off the thread list; starting to
1359 "this must be current thread or synchronizing");
1362 "this must be current thread");
1478 // JavaThread is only safepoint visible when it is in Threads' thread list,
1489 // Returns the running thread as a JavaThread
1492 // Returns the active Java thread. Do not use this if you know you are calling
1593 // support for cached flag that indicates whether exceptions need to be posted for this thread
1609 // Return a blocker object for which this thread is blocked parking.
1638 // JavaThread is added to the Java thread list. Right now, we don't
1640 // activated when the thread was created), but we have to activate
1641 // the SATB queue if the thread is created while a marking cycle is
1646 // now, it is called just before the thread is added to the Java
1647 // thread list in the Threads::add() method. That method is holding
1650 // when the thread is created given that, in some cases, safepoints
1652 // thread being added to the Java thread list (an example of this is
1653 // when the structure for the DestroyJavaVM thread is created).
1705 // JSR166 per-thread parker
1723 // This field is used to determine if a thread has claimed
1724 // a par_id: it is -1 if the thread has not claimed a par_id;
1734 Thread* thread = ThreadLocalStorage::thread();
1735 assert(thread != NULL && thread->is_Java_thread(), "just checking");
1736 return (JavaThread*)thread;
1772 // A thread used for Compilation.
1793 // Hide this compiler thread from external view.
1799 // Get/set the thread's compilation environment.
1806 // Get/set the thread's logging information
1827 // Get/set the thread's current task
1843 // The active thread queue. It also keeps track of the current used
1844 // thread priorities.
1856 // thread to the thread list before allocating its thread object
1863 // Initializes the vm and creates the vm thread
1884 // This creates a list of GCTasks, one per thread.
1886 // This creates a list of GCTasks, one per thread, for marking objects.
1917 // Get owning Java thread from the monitor's owner field. If doLock
1937 virtual void do_thread(Thread* thread) = 0;