• file
• revisions
• annotate
• diff
• comparison
• raw

src/share/vm/services/threadService.hpp@7bb995fbd3c0 (annotated)

src/share/vm/services/threadService.hpp

Thu, 12 Mar 2009 18:16:36 -0700

author

trims

date

Thu, 12 Mar 2009 18:16:36 -0700

changeset 1063

7bb995fbd3c0

parent 905

ad8c8ca4ab0f

child 1310

6a93908f268f

permissions

-rw-r--r--

Merge

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