1 /*
  2  * Copyright (c) 2003, 2021, Oracle and/or its affiliates. All rights reserved.
  3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  4  *
  5  * This code is free software; you can redistribute it and/or modify it
  6  * under the terms of the GNU General Public License version 2 only, as
  7  * published by the Free Software Foundation.
  8  *
  9  * This code is distributed in the hope that it will be useful, but WITHOUT
 10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 12  * version 2 for more details (a copy is included in the LICENSE file that
 13  * accompanied this code).
 14  *
 15  * You should have received a copy of the GNU General Public License version
 16  * 2 along with this work; if not, write to the Free Software Foundation,
 17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 18  *
 19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 20  * or visit www.oracle.com if you need additional information or have any
 21  * questions.
 22  *
 23  */
 24 
 25 #ifndef SHARE_SERVICES_THREADSERVICE_HPP
 26 #define SHARE_SERVICES_THREADSERVICE_HPP
 27 
 28 #include "classfile/classLoader.hpp"
 29 #include "classfile/javaClasses.hpp"
 30 #include "classfile/javaThreadStatus.hpp"
 31 #include "runtime/handles.hpp"
 32 #include "runtime/init.hpp"
 33 #include "runtime/objectMonitor.hpp"
 34 #include "runtime/perfData.hpp"
 35 #include "runtime/safepoint.hpp"
 36 #include "runtime/thread.hpp"
 37 #include "runtime/threadSMR.hpp"
 38 #include "services/management.hpp"
 39 
 40 class OopClosure;
 41 class ThreadDumpResult;
 42 class ThreadStackTrace;
 43 class ThreadSnapshot;
 44 class StackFrameInfo;
 45 class ThreadConcurrentLocks;
 46 class DeadlockCycle;
 47 
 48 // VM monitoring and management support for the thread and
 49 // synchronization subsystem
 50 //
 51 // Thread contention monitoring is disabled by default.
 52 // When enabled, the VM will begin measuring the accumulated
 53 // elapsed time a thread blocked on synchronization.
 54 //
 55 class ThreadService : public AllStatic {
 56 private:
 57   // These counters could be moved to Threads class
 58   static PerfCounter*  _total_threads_count;
 59   static PerfVariable* _live_threads_count;
 60   static PerfVariable* _peak_threads_count;
 61   static PerfVariable* _daemon_threads_count;
 62 
 63   // These 2 counters are like the above thread counts, but are
 64   // atomically decremented in ThreadService::current_thread_exiting instead of
 65   // ThreadService::remove_thread, so that the thread count is updated before
 66   // Thread.join() returns.
 67   static volatile int  _atomic_threads_count;
 68   static volatile int  _atomic_daemon_threads_count;
 69 
 70   static bool          _thread_monitoring_contention_enabled;
 71   static bool          _thread_cpu_time_enabled;
 72   static bool          _thread_allocated_memory_enabled;
 73 
 74   // Need to keep the list of thread dump result that
 75   // keep references to Method* since thread dump can be
 76   // requested by multiple threads concurrently.
 77   static ThreadDumpResult* _threaddump_list;
 78 
 79   static void decrement_thread_counts(JavaThread* jt, bool daemon);
 80 
 81 public:
 82   static void init();
 83   static void add_thread(JavaThread* thread, bool daemon);
 84   static void remove_thread(JavaThread* thread, bool daemon);
 85   static void current_thread_exiting(JavaThread* jt, bool daemon);
 86 
 87   static bool set_thread_monitoring_contention(bool flag);
 88   static bool is_thread_monitoring_contention() { return _thread_monitoring_contention_enabled; }
 89 
 90   static bool set_thread_cpu_time_enabled(bool flag);
 91   static bool is_thread_cpu_time_enabled()    { return _thread_cpu_time_enabled; }
 92 
 93   static bool set_thread_allocated_memory_enabled(bool flag);
 94   static bool is_thread_allocated_memory_enabled() { return _thread_allocated_memory_enabled; }
 95 
 96   static jlong get_total_thread_count()       { return _total_threads_count->get_value(); }
 97   static jlong get_peak_thread_count()        { return _peak_threads_count->get_value(); }
 98   static jlong get_live_thread_count()        { return _atomic_threads_count; }
 99   static jlong get_daemon_thread_count()      { return _atomic_daemon_threads_count; }
100 
101   // Support for thread dump
102   static void   add_thread_dump(ThreadDumpResult* dump);
103   static void   remove_thread_dump(ThreadDumpResult* dump);
104 
105   static Handle get_current_contended_monitor(JavaThread* thread);
106 
107   // This function is called by JVM_DumpThreads.
108   static Handle dump_stack_traces(GrowableArray<instanceHandle>* threads,
109                                   int num_threads, TRAPS);
110 
111   static void   reset_peak_thread_count();
112   static void   reset_contention_count_stat(JavaThread* thread);
113   static void   reset_contention_time_stat(JavaThread* thread);
114 
115   static DeadlockCycle*       find_deadlocks_at_safepoint(ThreadsList * t_list, bool object_monitors_only);
116 
117   static void   metadata_do(void f(Metadata*));
118 };
119 
120 // Per-thread Statistics for synchronization
121 class ThreadStatistics : public CHeapObj<mtInternal> {
122 private:
123   // The following contention statistics are only updated by
124   // the thread owning these statistics when contention occurs.
125 
126   jlong        _contended_enter_count;
127   elapsedTimer _contended_enter_timer;
128   jlong        _monitor_wait_count;
129   elapsedTimer _monitor_wait_timer;
130   jlong        _sleep_count;
131   elapsedTimer _sleep_timer;
132 
133 
134   // These two reset flags are set to true when another thread
135   // requests to reset the statistics.  The actual statistics
136   // are reset when the thread contention occurs and attempts
137   // to update the statistics.
138   bool         _count_pending_reset;
139   bool         _timer_pending_reset;
140 
141   // Keep accurate times for potentially recursive class operations
142   int           _perf_recursion_counts[PerfClassTraceTime::EVENT_TYPE_COUNT];
143   elapsedTimer  _perf_timers[PerfClassTraceTime::EVENT_TYPE_COUNT];
144 
145   // utility functions
146   void  check_and_reset_count()            {
147                                              if (!_count_pending_reset) return;
148                                              _contended_enter_count = 0;
149                                              _monitor_wait_count = 0;
150                                              _sleep_count = 0;
151                                              _count_pending_reset = 0;
152                                            }
153   void  check_and_reset_timer()            {
154                                              if (!_timer_pending_reset) return;
155                                              _contended_enter_timer.reset();
156                                              _monitor_wait_timer.reset();
157                                              _sleep_timer.reset();
158                                              _timer_pending_reset = 0;
159                                            }
160 
161 public:
162   ThreadStatistics();
163 
164   jlong contended_enter_count()            { return (_count_pending_reset ? 0 : _contended_enter_count); }
165   jlong contended_enter_ticks()            { return (_timer_pending_reset ? 0 : _contended_enter_timer.active_ticks()); }
166   jlong monitor_wait_count()               { return (_count_pending_reset ? 0 : _monitor_wait_count); }
167   jlong monitor_wait_ticks()               { return (_timer_pending_reset ? 0 : _monitor_wait_timer.active_ticks()); }
168   jlong sleep_count()                      { return (_count_pending_reset ? 0 : _sleep_count); }
169   jlong sleep_ticks()                      { return (_timer_pending_reset ? 0 : _sleep_timer.active_ticks()); }
170 
171   void monitor_wait()                      { check_and_reset_count(); _monitor_wait_count++; }
172   void monitor_wait_begin()                { check_and_reset_timer(); _monitor_wait_timer.start(); }
173   void monitor_wait_end()                  { _monitor_wait_timer.stop(); check_and_reset_timer(); }
174 
175   void thread_sleep()                      { check_and_reset_count(); _sleep_count++; }
176   void thread_sleep_begin()                { check_and_reset_timer(); _sleep_timer.start(); }
177   void thread_sleep_end()                  { _sleep_timer.stop(); check_and_reset_timer(); }
178 
179   void contended_enter()                   { check_and_reset_count(); _contended_enter_count++; }
180   void contended_enter_begin()             { check_and_reset_timer(); _contended_enter_timer.start(); }
181   void contended_enter_end()               { _contended_enter_timer.stop(); check_and_reset_timer(); }
182 
183   void reset_count_stat()                  { _count_pending_reset = true; }
184   void reset_time_stat()                   { _timer_pending_reset = true; }
185 
186   int* perf_recursion_counts_addr()        { return _perf_recursion_counts; }
187   elapsedTimer* perf_timers_addr()         { return _perf_timers; }
188 };
189 
190 // Thread snapshot to represent the thread state and statistics
191 class ThreadSnapshot : public CHeapObj<mtInternal> {
192 private:
193   // This JavaThread* is protected by being stored in objects that are
194   // protected by a ThreadsListSetter (ThreadDumpResult).
195   JavaThread* _thread;
196   OopHandle   _threadObj;
197   JavaThreadStatus _thread_status;
198 
199   bool    _is_suspended;
200   bool    _is_in_native;
201 
202   jlong   _contended_enter_ticks;
203   jlong   _contended_enter_count;
204   jlong   _monitor_wait_ticks;
205   jlong   _monitor_wait_count;
206   jlong   _sleep_ticks;
207   jlong   _sleep_count;
208 
209   OopHandle     _blocker_object;
210   OopHandle     _blocker_object_owner;
211 
212   ThreadStackTrace*      _stack_trace;
213   ThreadConcurrentLocks* _concurrent_locks;
214   ThreadSnapshot*        _next;
215 
216   // ThreadSnapshot instances should only be created via
217   // ThreadDumpResult::add_thread_snapshot.
218   friend class ThreadDumpResult;
219   ThreadSnapshot() : _thread(NULL),
220                      _stack_trace(NULL), _concurrent_locks(NULL), _next(NULL) {};
221   void        initialize(ThreadsList * t_list, JavaThread* thread);
222 
223 public:
224   ~ThreadSnapshot();
225 
226   JavaThreadStatus thread_status() { return _thread_status; }
227 
228   oop         threadObj() const;
229 
230   void        set_next(ThreadSnapshot* n) { _next = n; }
231 
232   bool        is_suspended()              { return _is_suspended; }
233   bool        is_in_native()              { return _is_in_native; }
234 
235   jlong       contended_enter_count()     { return _contended_enter_count; }
236   jlong       contended_enter_ticks()     { return _contended_enter_ticks; }
237   jlong       monitor_wait_count()        { return _monitor_wait_count; }
238   jlong       monitor_wait_ticks()        { return _monitor_wait_ticks; }
239   jlong       sleep_count()               { return _sleep_count; }
240   jlong       sleep_ticks()               { return _sleep_ticks; }
241 
242 
243   oop         blocker_object() const;
244   oop         blocker_object_owner() const;
245 
246   ThreadSnapshot*   next() const          { return _next; }
247   ThreadStackTrace* get_stack_trace()     { return _stack_trace; }
248   ThreadConcurrentLocks* get_concurrent_locks()     { return _concurrent_locks; }
249 
250   void        dump_stack_at_safepoint(int max_depth, bool with_locked_monitors,
251                                       ObjectMonitorsHashtable* table);
252   void        set_concurrent_locks(ThreadConcurrentLocks* l) { _concurrent_locks = l; }
253   void        metadata_do(void f(Metadata*));
254 };
255 
256 class ThreadStackTrace : public CHeapObj<mtInternal> {
257  private:
258   JavaThread*                     _thread;
259   int                             _depth;  // number of stack frames added
260   bool                            _with_locked_monitors;
261   GrowableArray<StackFrameInfo*>* _frames;
262   GrowableArray<OopHandle>*       _jni_locked_monitors;
263 
264  public:
265 
266   ThreadStackTrace(JavaThread* thread, bool with_locked_monitors);
267   ~ThreadStackTrace();
268 
269   JavaThread*     thread()              { return _thread; }
270   StackFrameInfo* stack_frame_at(int i) { return _frames->at(i); }
271   int             get_stack_depth()     { return _depth; }
272 
273   void            add_stack_frame(javaVFrame* jvf);
274   void            dump_stack_at_safepoint(int max_depth, ObjectMonitorsHashtable* table);
275   Handle          allocate_fill_stack_trace_element_array(TRAPS);
276   void            metadata_do(void f(Metadata*));
277   GrowableArray<OopHandle>* jni_locked_monitors() { return _jni_locked_monitors; }
278   int             num_jni_locked_monitors() { return (_jni_locked_monitors != NULL ? _jni_locked_monitors->length() : 0); }
279 
280   bool            is_owned_monitor_on_stack(oop object);
281   void            add_jni_locked_monitor(oop object);
282 };
283 
284 // StackFrameInfo for keeping Method* and bci during
285 // stack walking for later construction of StackTraceElement[]
286 // Java instances
287 class StackFrameInfo : public CHeapObj<mtInternal> {
288  private:
289   Method*             _method;
290   int                 _bci;
291   GrowableArray<OopHandle>* _locked_monitors; // list of object monitors locked by this frame
292   // We need to save the mirrors in the backtrace to keep the class
293   // from being unloaded while we still have this stack trace.
294   OopHandle           _class_holder;
295 
296  public:
297 
298   StackFrameInfo(javaVFrame* jvf, bool with_locked_monitors);
299   ~StackFrameInfo();
300   Method*   method() const       { return _method; }
301   int       bci()    const       { return _bci; }
302   void      metadata_do(void f(Metadata*));
303 
304   int       num_locked_monitors()       { return (_locked_monitors != NULL ? _locked_monitors->length() : 0); }
305   GrowableArray<OopHandle>* locked_monitors() { return _locked_monitors; }
306 
307   void      print_on(outputStream* st) const;
308 };
309 
310 class ThreadConcurrentLocks : public CHeapObj<mtInternal> {
311 private:
312   GrowableArray<OopHandle>*   _owned_locks;
313   ThreadConcurrentLocks*      _next;
314   // This JavaThread* is protected in one of two different ways
315   // depending on the usage of the ThreadConcurrentLocks object:
316   // 1) by being stored in objects that are only allocated and used at a
317   // safepoint (ConcurrentLocksDump), or 2) by being stored in objects
318   // that are protected by a ThreadsListSetter (ThreadSnapshot inside
319   // ThreadDumpResult).
320   JavaThread*                 _thread;
321  public:
322   ThreadConcurrentLocks(JavaThread* thread);
323   ~ThreadConcurrentLocks();
324 
325   void                        add_lock(instanceOop o);
326   void                        set_next(ThreadConcurrentLocks* n) { _next = n; }
327   ThreadConcurrentLocks*      next() { return _next; }
328   JavaThread*                 java_thread()                      { return _thread; }
329   GrowableArray<OopHandle>*   owned_locks()                      { return _owned_locks; }
330 };
331 
332 class ConcurrentLocksDump : public StackObj {
333  private:
334   ThreadConcurrentLocks* _map;
335   ThreadConcurrentLocks* _last;   // Last ThreadConcurrentLocks in the map
336   bool                   _retain_map_on_free;
337 
338   void build_map(GrowableArray<oop>* aos_objects);
339   void add_lock(JavaThread* thread, instanceOop o);
340 
341  public:
342   ConcurrentLocksDump(bool retain_map_on_free) : _map(NULL), _last(NULL), _retain_map_on_free(retain_map_on_free) {
343     assert(SafepointSynchronize::is_at_safepoint(), "Must be constructed at a safepoint.");
344   };
345   ConcurrentLocksDump() : _map(NULL), _last(NULL), _retain_map_on_free(false) {
346     assert(SafepointSynchronize::is_at_safepoint(), "Must be constructed at a safepoint.");
347   };
348   ~ConcurrentLocksDump();
349 
350   void                        dump_at_safepoint();
351   ThreadConcurrentLocks*      thread_concurrent_locks(JavaThread* thread);
352   void                        print_locks_on(JavaThread* t, outputStream* st);
353 };
354 
355 class ThreadDumpResult : public StackObj {
356  private:
357   int                  _num_threads;
358   int                  _num_snapshots;
359   ThreadSnapshot*      _snapshots;
360   ThreadSnapshot*      _last;
361   ThreadDumpResult*    _next;
362   ThreadsListSetter    _setter;  // Helper to set hazard ptr in the originating thread
363                                  // which protects the JavaThreads in _snapshots.
364 
365   void                 link_thread_snapshot(ThreadSnapshot* ts);
366 
367  public:
368   ThreadDumpResult();
369   ThreadDumpResult(int num_threads);
370   ~ThreadDumpResult();
371 
372   ThreadSnapshot*      add_thread_snapshot();
373   ThreadSnapshot*      add_thread_snapshot(JavaThread* thread);
374 
375   void                 set_next(ThreadDumpResult* next) { _next = next; }
376   ThreadDumpResult*    next()                           { return _next; }
377   int                  num_threads()                    { return _num_threads; }
378   int                  num_snapshots()                  { return _num_snapshots; }
379   ThreadSnapshot*      snapshots()                      { return _snapshots; }
380   void                 set_t_list()                     { _setter.set(); }
381   ThreadsList*         t_list();
382   bool                 t_list_has_been_set()            { return _setter.is_set(); }
383   void                 metadata_do(void f(Metadata*));
384 };
385 
386 class DeadlockCycle : public CHeapObj<mtInternal> {
387  private:
388   GrowableArray<JavaThread*>* _threads;
389   DeadlockCycle*              _next;
390  public:
391   DeadlockCycle();
392   ~DeadlockCycle();
393 
394   DeadlockCycle* next()                     { return _next; }
395   void           set_next(DeadlockCycle* d) { _next = d; }
396   void           add_thread(JavaThread* t)  { _threads->append(t); }
397   void           reset()                    { _threads->clear(); }
398   int            num_threads()              { return _threads->length(); }
399   GrowableArray<JavaThread*>* threads()     { return _threads; }
400   void           print_on_with(ThreadsList * t_list, outputStream* st) const;
401 };
402 
403 // Utility class to get list of java threads.
404 class ThreadsListEnumerator : public StackObj {
405 private:
406   GrowableArray<instanceHandle>* _threads_array;
407 public:
408   ThreadsListEnumerator(Thread* cur_thread,
409                         bool include_jvmti_agent_threads = false,
410                         bool include_jni_attaching_threads = true);
411   int            num_threads()            { return _threads_array->length(); }
412   instanceHandle get_threadObj(int index) { return _threads_array->at(index); }
413 };
414 
415 
416 // abstract utility class to set new thread states, and restore previous after the block exits
417 class JavaThreadStatusChanger : public StackObj {
418  private:
419   JavaThreadStatus _old_state;
420   JavaThread*  _java_thread;
421   bool _is_alive;
422 
423   void save_old_state(JavaThread* java_thread) {
424     _java_thread  = java_thread;
425     _is_alive = is_alive(java_thread);
426     if (is_alive()) {
427       _old_state = java_lang_Thread::get_thread_status(_java_thread->threadObj());
428     }
429   }
430 
431  public:
432   static void set_thread_status(JavaThread* java_thread,
433                                 JavaThreadStatus state) {
434     java_lang_Thread::set_thread_status(java_thread->threadObj(), state);
435   }
436 
437   void set_thread_status(JavaThreadStatus state) {
438     if (is_alive()) {
439       set_thread_status(_java_thread, state);
440     }
441   }
442 
443   JavaThreadStatusChanger(JavaThread* java_thread,
444                           JavaThreadStatus state) : _old_state(JavaThreadStatus::NEW) {
445     save_old_state(java_thread);
446     set_thread_status(state);
447   }
448 
449   JavaThreadStatusChanger(JavaThread* java_thread) : _old_state(JavaThreadStatus::NEW) {
450     save_old_state(java_thread);
451   }
452 
453   ~JavaThreadStatusChanger() {
454     set_thread_status(_old_state);
455   }
456 
457   static bool is_alive(JavaThread* java_thread) {
458     return java_thread != NULL && java_thread->threadObj() != NULL;
459   }
460 
461   bool is_alive() {
462     return _is_alive;
463   }
464 };
465 
466 // Change status to waiting on an object  (timed or indefinite)
467 class JavaThreadInObjectWaitState : public JavaThreadStatusChanger {
468  private:
469   ThreadStatistics* _stat;
470   bool _active;
471 
472  public:
473   JavaThreadInObjectWaitState(JavaThread *java_thread, bool timed) :
474     JavaThreadStatusChanger(java_thread,
475                             timed ? JavaThreadStatus::IN_OBJECT_WAIT_TIMED : JavaThreadStatus::IN_OBJECT_WAIT) {
476     if (is_alive()) {
477       _stat = java_thread->get_thread_stat();
478       _active = ThreadService::is_thread_monitoring_contention();
479       _stat->monitor_wait();
480       if (_active) {
481         _stat->monitor_wait_begin();
482       }
483     } else {
484       _active = false;
485     }
486   }
487 
488   ~JavaThreadInObjectWaitState() {
489     if (_active) {
490       _stat->monitor_wait_end();
491     }
492   }
493 };
494 
495 // Change status to parked (timed or indefinite)
496 class JavaThreadParkedState : public JavaThreadStatusChanger {
497  private:
498   ThreadStatistics* _stat;
499   bool _active;
500 
501  public:
502   JavaThreadParkedState(JavaThread *java_thread, bool timed) :
503     JavaThreadStatusChanger(java_thread,
504                             timed ? JavaThreadStatus::PARKED_TIMED : JavaThreadStatus::PARKED) {
505     if (is_alive()) {
506       _stat = java_thread->get_thread_stat();
507       _active = ThreadService::is_thread_monitoring_contention();
508       _stat->monitor_wait();
509       if (_active) {
510         _stat->monitor_wait_begin();
511       }
512     } else {
513       _active = false;
514     }
515   }
516 
517   ~JavaThreadParkedState() {
518     if (_active) {
519       _stat->monitor_wait_end();
520     }
521   }
522 };
523 
524 // Change status to blocked on (re-)entering a synchronization block
525 class JavaThreadBlockedOnMonitorEnterState : public JavaThreadStatusChanger {
526  private:
527   ThreadStatistics* _stat;
528   bool _active;
529 
530   static bool contended_enter_begin(JavaThread *java_thread) {
531     set_thread_status(java_thread, JavaThreadStatus::BLOCKED_ON_MONITOR_ENTER);
532     ThreadStatistics* stat = java_thread->get_thread_stat();
533     stat->contended_enter();
534     bool active = ThreadService::is_thread_monitoring_contention();
535     if (active) {
536       stat->contended_enter_begin();
537     }
538     return active;
539   }
540 
541  public:
542   // java_thread is waiting thread being blocked on monitor reenter.
543   // Current thread is the notifying thread which holds the monitor.
544   static bool wait_reenter_begin(JavaThread *java_thread, ObjectMonitor *obj_m) {
545     assert((java_thread != NULL), "Java thread should not be null here");
546     bool active = false;
547     if (is_alive(java_thread)) {
548       active = contended_enter_begin(java_thread);
549     }
550     return active;
551   }
552 
553   static void wait_reenter_end(JavaThread *java_thread, bool active) {
554     if (active) {
555       java_thread->get_thread_stat()->contended_enter_end();
556     }
557     set_thread_status(java_thread, JavaThreadStatus::RUNNABLE);
558   }
559 
560   JavaThreadBlockedOnMonitorEnterState(JavaThread *java_thread, ObjectMonitor *obj_m) :
561     JavaThreadStatusChanger(java_thread), _stat(NULL), _active(false) {
562     assert((java_thread != NULL), "Java thread should not be null here");
563     // Change thread status and collect contended enter stats for monitor contended
564     // enter done for external java world objects and it is contended. All other cases
565     // like for vm internal objects and for external objects which are not contended
566     // thread status is not changed and contended enter stat is not collected.
567     _active = false;
568     if (is_alive() && obj_m->contentions() > 0) {
569       _stat = java_thread->get_thread_stat();
570       _active = contended_enter_begin(java_thread);
571     }
572   }
573 
574   ~JavaThreadBlockedOnMonitorEnterState() {
575     if (_active) {
576       _stat->contended_enter_end();
577     }
578   }
579 };
580 
581 // Change status to sleeping
582 class JavaThreadSleepState : public JavaThreadStatusChanger {
583  private:
584   ThreadStatistics* _stat;
585   bool _active;
586  public:
587   JavaThreadSleepState(JavaThread *java_thread) :
588     JavaThreadStatusChanger(java_thread, JavaThreadStatus::SLEEPING) {
589     if (is_alive()) {
590       _stat = java_thread->get_thread_stat();
591       _active = ThreadService::is_thread_monitoring_contention();
592       _stat->thread_sleep();
593       if (_active) {
594         _stat->thread_sleep_begin();
595       }
596     } else {
597       _active = false;
598     }
599   }
600 
601   ~JavaThreadSleepState() {
602     if (_active) {
603       _stat->thread_sleep_end();
604     }
605   }
606 };
607 
608 #endif // SHARE_SERVICES_THREADSERVICE_HPP