This thread information class is designed for use in monitoring of * the system, not for synchronization control. * *
The Java virtual machine may measure the time with a high * resolution timer. This statistic is reset when * the thread contention monitoring is reenabled. * * @return the approximate accumulated elapsed time in milliseconds * that a thread entered the BLOCKED state; * -1 if thread contention monitoring is disabled. * * @throws java.lang.UnsupportedOperationException if the Java * virtual machine does not support this operation. * * @see ThreadMXBean#isThreadContentionMonitoringSupported * @see ThreadMXBean#setThreadContentionMonitoringEnabled */ public long getBlockedTime() { return blockedTime; } /** * Returns the total number of times that * the thread associated with this ThreadInfo * blocked to enter or reenter a monitor. * I.e. the number of times a thread has been in the * {@link java.lang.Thread.State#BLOCKED BLOCKED} state. * * @return the total number of times that the thread * entered the BLOCKED state. */ public long getBlockedCount() { return blockedCount; } /** * Returns the approximate accumulated elapsed time (in milliseconds) * that the thread associated with this ThreadInfo * has waited for notification * since thread contention monitoring is enabled. * I.e. the total accumulated time the thread has been in the * {@link java.lang.Thread.State#WAITING WAITING} * or {@link java.lang.Thread.State#TIMED_WAITING TIMED_WAITING} state * since thread contention monitoring is enabled. * This method returns -1 if thread contention monitoring * is disabled. * *
The Java virtual machine may measure the time with a high * resolution timer. This statistic is reset when * the thread contention monitoring is reenabled. * * @return the approximate accumulated elapsed time in milliseconds * that a thread has been in the WAITING or * TIMED_WAITING state; * -1 if thread contention monitoring is disabled. * * @throws java.lang.UnsupportedOperationException if the Java * virtual machine does not support this operation. * * @see ThreadMXBean#isThreadContentionMonitoringSupported * @see ThreadMXBean#setThreadContentionMonitoringEnabled */ public long getWaitedTime() { return waitedTime; } /** * Returns the total number of times that * the thread associated with this ThreadInfo * waited for notification. * I.e. the number of times that a thread has been * in the {@link java.lang.Thread.State#WAITING WAITING} * or {@link java.lang.Thread.State#TIMED_WAITING TIMED_WAITING} state. * * @return the total number of times that the thread * was in the WAITING or TIMED_WAITING state. */ public long getWaitedCount() { return waitedCount; } /** * Returns the LockInfo of an object for which * the thread associated with this ThreadInfo * is blocked waiting. * A thread can be blocked waiting for one of the following: *
This method returns null if the thread is not in any of * the above conditions. * * @return LockInfo of an object for which the thread * is blocked waiting if any; null otherwise. * @since 1.6 */ public LockInfo getLockInfo() { return lock; } /** * Returns the {@link LockInfo#toString string representation} * of an object for which the thread associated with this * ThreadInfo is blocked waiting. * This method is equivalent to calling: *
*
* getLockInfo().toString()
*
*
* This method will return null if this thread is not blocked * waiting for any object or if the object is not owned by any thread. * * @return the string representation of the object on which * the thread is blocked if any; * null otherwise. * * @see #getLockInfo */ public String getLockName() { return lockName; } /** * Returns the ID of the thread which owns the object * for which the thread associated with this ThreadInfo * is blocked waiting. * This method will return -1 if this thread is not blocked * waiting for any object or if the object is not owned by any thread. * * @return the thread ID of the owner thread of the object * this thread is blocked on; * -1 if this thread is not blocked * or if the object lis not owned by any thread. * * @see #getLockInfo */ public long getLockOwnerId() { return lockOwnerId; } /** * Returns the name of the thread which owns the object * for which the thread associated with this ThreadInfo * is blocked waiting. * This method will return null if this thread is not blocked * waiting for any object or if the object is not owned by any thread. * * @return the name of the thread that owns the object * this thread is blocked on; * null if this thread is not blocked * or if the object is not owned by any thread. * * @see #getLockInfo */ public String getLockOwnerName() { return lockOwnerName; } /** * Returns the stack trace of the thread * associated with this ThreadInfo. * If no stack trace was requested for this thread info, this method * will return a zero-length array. * If the returned array is of non-zero length then the first element of * the array represents the top of the stack, which is the most recent * method invocation in the sequence. The last element of the array * represents the bottom of the stack, which is the least recent method * invocation in the sequence. * *
Some Java virtual machines may, under some circumstances, omit one * or more stack frames from the stack trace. In the extreme case, * a virtual machine that has no stack trace information concerning * the thread associated with this ThreadInfo * is permitted to return a zero-length array from this method. * * @return an array of StackTraceElement objects of the thread. */ public StackTraceElement[] getStackTrace() { return stackTrace; } /** * Tests if the thread associated with this ThreadInfo * is suspended. This method returns true if * {@link Thread#suspend} has been called. * * @return true if the thread is suspended; * false otherwise. */ public boolean isSuspended() { return suspended; } /** * Tests if the thread associated with this ThreadInfo * is executing native code via the Java Native Interface (JNI). * The JNI native code does not include * the virtual machine support code or the compiled native * code generated by the virtual machine. * * @return true if the thread is executing native code; * false otherwise. */ public boolean isInNative() { return inNative; } /** * Returns a string representation of this thread info. * The format of this string depends on the implementation. * The returned string will typically include * the {@linkplain #getThreadName thread name}, * the {@linkplain #getThreadId thread ID}, * its {@linkplain #getThreadState state}, * and a {@linkplain #getStackTrace stack trace} if any. * * @return a string representation of this thread info. */ public String toString() { StringBuilder sb = new StringBuilder("\"" + getThreadName() + "\"" + " Id=" + getThreadId() + " " + getThreadState()); if (getLockName() != null) { sb.append(" on " + getLockName()); } if (getLockOwnerName() != null) { sb.append(" owned by \"" + getLockOwnerName() + "\" Id=" + getLockOwnerId()); } if (isSuspended()) { sb.append(" (suspended)"); } if (isInNative()) { sb.append(" (in native)"); } sb.append('\n'); int i = 0; for (; i < stackTrace.length && i < MAX_FRAMES; i++) { StackTraceElement ste = stackTrace[i]; sb.append("\tat " + ste.toString()); sb.append('\n'); if (i == 0 && getLockInfo() != null) { Thread.State ts = getThreadState(); switch (ts) { case BLOCKED: sb.append("\t- blocked on " + getLockInfo()); sb.append('\n'); break; case WAITING: sb.append("\t- waiting on " + getLockInfo()); sb.append('\n'); break; case TIMED_WAITING: sb.append("\t- waiting on " + getLockInfo()); sb.append('\n'); break; default: } } for (MonitorInfo mi : lockedMonitors) { if (mi.getLockedStackDepth() == i) { sb.append("\t- locked " + mi); sb.append('\n'); } } } if (i < stackTrace.length) { sb.append("\t..."); sb.append('\n'); } LockInfo[] locks = getLockedSynchronizers(); if (locks.length > 0) { sb.append("\n\tNumber of locked synchronizers = " + locks.length); sb.append('\n'); for (LockInfo li : locks) { sb.append("\t- " + li); sb.append('\n'); } } sb.append('\n'); return sb.toString(); } private static final int MAX_FRAMES = 8; /** * Returns a ThreadInfo object represented by the * given CompositeData. * The given CompositeData must contain the following attributes * unless otherwise specified below: *
** * @param cd CompositeData representing a ThreadInfo * * @throws IllegalArgumentException if cd does not * represent a ThreadInfo with the attributes described * above. * * @return a ThreadInfo object represented * by cd if cd is not null; * null otherwise. */ public static ThreadInfo from(CompositeData cd) { if (cd == null) { return null; } if (cd instanceof ThreadInfoCompositeData) { return ((ThreadInfoCompositeData) cd).getThreadInfo(); } else { return new ThreadInfo(cd); } } /** * Returns an array of {@link MonitorInfo} objects, each of which * represents an object monitor currently locked by the thread * associated with this ThreadInfo. * If no locked monitor was requested for this thread info or * no monitor is locked by the thread, this method * will return a zero-length array. * * @return an array of MonitorInfo objects representing * the object monitors locked by the thread. * * @since 1.6 */ public MonitorInfo[] getLockedMonitors() { return lockedMonitors; } /** * Returns an array of {@link LockInfo} objects, each of which * represents an ownable * synchronizer currently locked by the thread associated with * this ThreadInfo. If no locked synchronizer was * requested for this thread info or no synchronizer is locked by * the thread, this method will return a zero-length array. * * @return an array of LockInfo objects representing * the ownable synchronizers locked by the thread. * * @since 1.6 */ public LockInfo[] getLockedSynchronizers() { // represents an return lockedSynchronizers; } private static final StackTraceElement[] NO_STACK_TRACE = new StackTraceElement[0]; }*
** *Attribute Name *Type ** *threadId *java.lang.Long ** *threadName *java.lang.String ** *threadState *java.lang.String ** *suspended *java.lang.Boolean ** *inNative *java.lang.Boolean ** *blockedCount *java.lang.Long ** *blockedTime *java.lang.Long ** *waitedCount *java.lang.Long ** *waitedTime *java.lang.Long ** *lockInfo *javax.management.openmbean.CompositeData * - the mapped type for {@link LockInfo} as specified in the * * type mapping rules of * {@linkplain javax.management.MXBean MXBeans}. * ** If cd does not contain this attribute, * the LockInfo object will be constructed from * the value of the lockName attribute.
* *lockName *java.lang.String ** *lockOwnerId *java.lang.Long ** *lockOwnerName *java.lang.String ** *stackTrace *javax.management.openmbean.CompositeData[] * ** Each element is a CompositeData representing * StackTraceElement containing the following attributes: *
***
** *Attribute Name *Type ** *className *java.lang.String ** *methodName *java.lang.String ** *fileName *java.lang.String ** *lineNumber *java.lang.Integer ** *nativeMethod *java.lang.Boolean ** *lockedMonitors *javax.management.openmbean.CompositeData[] * whose element type is the mapped type for * {@link MonitorInfo} as specified in the * {@link MonitorInfo#from Monitor.from} method. * ** If cd does not contain this attribute, * this attribute will be set to an empty array.
* *lockedSynchronizers *javax.management.openmbean.CompositeData[] * whose element type is the mapped type for * {@link LockInfo} as specified in the * * type mapping rules of * {@linkplain javax.management.MXBean MXBeans}. * ** If cd does not contain this attribute, * this attribute will be set to an empty array.