Class ExtendedThreadMXBeanImpl

java.lang.Object
com.ibm.lang.management.internal.ExtendedThreadMXBeanImpl
All Implemented Interfaces:
ThreadMXBean, ThreadMXBean, PlatformManagedObject, ThreadMXBean
public final class ExtendedThreadMXBeanImpl extends Object implements ThreadMXBean
Implementation of the extended ThreadMXBean.

  • Method Details

    • getInstance

      public static ThreadMXBean getInstance()
      Singleton accessor method.
      Returns:
      the ExtendedThreadMXBeanImpl singleton.

    • dumpAllExtendedThreads

      public ExtendedThreadInfo[] dumpAllExtendedThreads(boolean lockedMonitors, boolean lockedSynchronizers) throws InternalError, SecurityException, UnsupportedOperationException
      API method that fetches an array of ExtendedThreadInfo objects corresponding to threads in the virtual machine during the time it is invoked. Fetches an array of ExtendedThreadInfo objects that provide native thread identifiers along with java.lang.management.ThreadInfo object representing the thread. Consider using dumpAllExtendedThreads() in place of dumpAllThreads() as it provides additional thread identification information in an efficient manner.
      Specified by:
      dumpAllExtendedThreads in interface ThreadMXBean
      Parameters:
      lockedMonitors - boolean indication of whether or not information on all currently locked object monitors is to be included in the returned array
      lockedSynchronizers - boolean indication of whether or not information on all currently locked ownable synchronizers is to be included in the returned array
      Returns:
      Array of ExtendedThreadInfo objects.
      Throws:
      InternalError - is thrown in case an error occurs while fetching thread information, typically, an internal error resulting from an inconsistency in the class library.
      UnsupportedOperationException - is thrown if the JVM does not support monitoring object monitor usage or ownable synchronizer usage, even as it has been specified.
      SecurityException

    • getThreadAllocatedBytes

      public long getThreadAllocatedBytes(long threadId)
      Returns an approximation of the total amount of memory, in bytes, allocated in heap memory for the thread with the specified ID. The returned value is an approximation because some Java virtual machine implementations may use object allocation mechanisms that result in a delay between the time an object is allocated and the time its size is recorded.

      If the thread with the specified ID is a virtual thread, is not alive, or does not exist, this method returns -1. If thread memory allocation measurement is disabled, this method returns -1. A thread is alive if it has been started and has not yet terminated.

      If thread memory allocation measurement is enabled after the thread has started, the Java virtual machine implementation may choose any time up to and including the time that the capability is enabled as the point where thread memory allocation measurement starts.

      Specified by:
      getThreadAllocatedBytes in interface ThreadMXBean
      Parameters:
      threadId - the thread ID of a thread
      Returns:
      an approximation of the total memory allocated, in bytes, in heap memory for the thread with the specified ID if the thread with the specified ID is a platform thread, the thread is alive, and thread memory allocation measurement is enabled; -1 otherwise.
      See Also:

    • getThreadAllocatedBytes

      public long[] getThreadAllocatedBytes(long[] threadIds)
      Returns an approximation of the total amount of memory, in bytes, allocated in heap memory for each thread whose ID is in the input array ids. The returned values are approximations because some Java virtual machine implementations may use object allocation mechanisms that result in a delay between the time an object is allocated and the time its size is recorded.

      This method is equivalent to calling the ThreadMXBean.getThreadAllocatedBytes(long) method for each thread ID in the input array ids and setting the returned value in the corresponding element of the returned array.

      Specified by:
      getThreadAllocatedBytes in interface ThreadMXBean
      Parameters:
      threadIds - an array of thread IDs.
      Returns:
      an array of long values, each of which is an approximation of the total memory allocated, in bytes, in heap memory for the thread whose ID is in the corresponding element of the input array of IDs.
      See Also:

    • getThreadCpuTime

      public long[] getThreadCpuTime(long[] threadIds)
      Returns the total CPU time for each thread whose ID is in the input array ids in nanoseconds. The returned values are of nanoseconds precision but not necessarily nanoseconds accuracy.

      This method is equivalent to calling the ThreadMXBean.getThreadCpuTime(long) method for each thread ID in the input array ids and setting the returned value in the corresponding element of the returned array.

      Specified by:
      getThreadCpuTime in interface ThreadMXBean
      Parameters:
      threadIds - an array of thread IDs.
      Returns:
      an array of long values, each of which is the amount of CPU time the thread whose ID is in the corresponding element of the input array of IDs has used, if the thread of a specified ID is a platform thread, the thread is alive, and CPU time measurement is enabled; -1 otherwise.
      See Also:

    • getThreadUserTime

      public long[] getThreadUserTime(long[] threadIds)
      Returns the CPU time that each thread whose ID is in the input array ids has executed in user mode in nanoseconds. The returned values are of nanoseconds precision but not necessarily nanoseconds accuracy.

      This method is equivalent to calling the ThreadMXBean.getThreadUserTime(long) method for each thread ID in the input array ids and setting the returned value in the corresponding element of the returned array.

      Specified by:
      getThreadUserTime in interface ThreadMXBean
      Parameters:
      threadIds - an array of thread IDs.
      Returns:
      an array of long values, each of which is the amount of user mode CPU time the thread whose ID is in the corresponding element of the input array of IDs has used, if the thread of a specified ID is a platform thread, the thread is alive, and CPU time measurement is enabled; -1 otherwise.
      See Also:

    • isThreadAllocatedMemorySupported

      public boolean isThreadAllocatedMemorySupported()
      Tests if the Java virtual machine implementation supports thread memory allocation measurement.
      Specified by:
      isThreadAllocatedMemorySupported in interface ThreadMXBean
      Returns:
      true if the Java virtual machine implementation supports thread memory allocation measurement; false otherwise.

    • isThreadAllocatedMemoryEnabled

      public boolean isThreadAllocatedMemoryEnabled()
      Tests if thread memory allocation measurement is enabled.
      Specified by:
      isThreadAllocatedMemoryEnabled in interface ThreadMXBean
      Returns:
      true if thread memory allocation measurement is enabled; false otherwise.
      See Also:

    • setThreadAllocatedMemoryEnabled

      public void setThreadAllocatedMemoryEnabled(boolean value)
      Enables or disables thread memory allocation measurement. The default is platform dependent.
      Specified by:
      setThreadAllocatedMemoryEnabled in interface ThreadMXBean
      Parameters:
      value - true to enable; false to disable.
      See Also:

    • findMonitorDeadlockedThreads

      public long[] findMonitorDeadlockedThreads()
      Returns the thread identifiers of every thread in this virtual machine that is currently blocked in a deadlock situation over a monitor object. A thread is considered to be deadlocked if it is blocked waiting to run and owns an object monitor that is sought by another blocked thread. Two or more threads can be in a deadlock cycle. To determine the threads currently deadlocked by object monitors and ownable synchronizers use the ThreadMXBean.findDeadlockedThreads() method.

      It is recommended that this method be used solely for problem determination analysis and not as a means of managing thread synchronization in a virtual machine. This is because the method may be very expensive to run.

      Specified by:
      findMonitorDeadlockedThreads in interface ThreadMXBean
      Returns:
      an array of the identifiers of every thread in the virtual machine that has been detected as currently being in a deadlock situation over an object monitor. May be null if there are currently no threads in that category.

    • getAllThreadIds

      public long[] getAllThreadIds()
      Returns an array of the identifiers of all of the threads that are alive in the current virtual machine. When processing the return from this method it should not be assumed that each identified thread is still alive.
      Specified by:
      getAllThreadIds in interface ThreadMXBean
      Returns:
      the identifiers of all of the threads currently alive in the virtual machine.

    • getCurrentThreadCpuTime

      public long getCurrentThreadCpuTime()
      If supported by the virtual machine, returns the total CPU usage time for the currently running thread. The returned time will have nanosecond precision but may not have nanosecond accuracy.

      Method ThreadMXBean.isCurrentThreadCpuTimeSupported() may be used to determine if current thread CPU timing is supported on the virtual machine. On virtual machines where current thread CPU timing is supported, the method ThreadMXBean.isThreadCpuTimeEnabled() may be used to determine if thread CPU timing is actually enabled.

      The return value is identical to that which would be obtained by calling ThreadMXBean.getThreadCpuTime(long) with an argument Thread.currentThread().getId()).

      Specified by:
      getCurrentThreadCpuTime in interface ThreadMXBean
      Returns:
      on virtual machines where current thread CPU timing is supported and thread CPU timing is enabled, the number of nanoseconds CPU usage by the current thread. On virtual machines where current thread CPU timing is supported but thread CPU timing is not enabled, -1.

    • getCurrentThreadUserTime

      public long getCurrentThreadUserTime()
      If supported by the virtual machine, returns the total CPU usage time for the current thread running in user mode. The returned time will have nanosecond precision but may not have nanosecond accuracy.

      Method ThreadMXBean.isCurrentThreadCpuTimeSupported() may be used to determine if current thread CPU timing is supported on the virtual machine. On virtual machines where current thread CPU timing is supported, the method ThreadMXBean.isThreadCpuTimeEnabled() may be used to determine if thread CPU timing is actually enabled.

      The return value is identical to that which would be obtained by calling ThreadMXBean.getThreadUserTime(long) with an argument Thread.currentThread().getId()).

      Specified by:
      getCurrentThreadUserTime in interface ThreadMXBean
      Returns:
      on virtual machines where current thread CPU timing is supported and thread CPU timing is enabled, the number of nanoseconds CPU time used by the current thread running in user mode. On virtual machines where current thread CPU timing is supported but thread CPU timing is not enabled, -1.

    • getDaemonThreadCount

      public int getDaemonThreadCount()
      Returns the number of daemon threads currently alive in the virtual machine.
      Specified by:
      getDaemonThreadCount in interface ThreadMXBean
      Returns:
      the number of currently alive daemon threads.

    • getPeakThreadCount

      public int getPeakThreadCount()
      Returns the peak number of threads that have ever been alive in the virtual machine at any one instant since either the virtual machine start-up or the peak was reset.
      Specified by:
      getPeakThreadCount in interface ThreadMXBean
      Returns:
      the peak number of live threads
      See Also:

    • getThreadCount

      public int getThreadCount()
      Returns the number of threads currently alive in the virtual machine. This includes both daemon threads and non-daemon threads.
      Specified by:
      getThreadCount in interface ThreadMXBean
      Returns:
      the number of currently alive threads.

    • getThreadCpuTime

      public long getThreadCpuTime(long id)
      If supported by the virtual machine, returns the total CPU usage time for the thread with the specified identifier. The returned time will have nanosecond precision but may not have nanosecond accuracy.

      Method ThreadMXBean.isThreadCpuTimeSupported() may be used to determine if the CPU timing of threads is supported on the virtual machine. On virtual machines where current thread CPU timing is supported, the method ThreadMXBean.isThreadCpuTimeEnabled() may be used to determine if thread CPU timing is actually enabled.

      Specified by:
      getThreadCpuTime in interface ThreadMXBean
      Parameters:
      id - the identifier for a thread. Must be a positive number greater than zero.
      Returns:
      on virtual machines where thread CPU timing is supported and enabled, and there is a living thread with identifier id, the number of nanoseconds CPU time used by the thread. On virtual machines where thread CPU timing is supported but not enabled, or where there is no living thread with identifier id present in the virtual machine, a value of -1 is returned.
      See Also:

    • getThreadInfo

      public ThreadInfo getThreadInfo(long id)
      Returns a ThreadInfo object for the thread with the specified identifier. The returned object will not have a stack trace so that a call to its getStackTrace() method will result in an empty StackTraceElement array. Similarly, the returned object will hold no details of locked synchronizers or locked object monitors for the specified thread; calls to getLockedMonitors() and getLockedSynchronizers will both return array values.
      Specified by:
      getThreadInfo in interface ThreadMXBean
      Parameters:
      id - the identifier for a thread. Must be a positive number greater than zero.
      Returns:
      if the supplied id maps to a living thread in the virtual machine (i.e. a started thread which has not yet died), this method returns a ThreadInfo object corresponding to that thread. Otherwise, returns null.

    • getThreadInfo

      public ThreadInfo[] getThreadInfo(long[] ids)
      Returns an array of ThreadInfo objects ; one for each of the threads specified in the input array of identifiers. None of the objects in the return array will have a stack trace so that a call to its getStackTrace() method will result in an empty StackTraceElement array. Similarly, the returned object will hold no details of locked synchronizers or locked object monitors for the specified thread; calls to getLockedMonitors() and getLockedSynchronizers will both return array values.
      Specified by:
      getThreadInfo in interface ThreadMXBean
      Parameters:
      ids - an array of thread identifiers. Each one must be a positive number greater than zero.
      Returns:
      an array of ThreadInfo objects with each entry corresponding to one of the threads specified in the input array of identifiers. The return array will therefore have an identical number of elements to the input ids array. If an entry in the ids array is invalid (there is no living thread with the supplied identifier in the virtual machine) then the corresponding entry in the return array will be a null.

    • getThreadInfo

      public ThreadInfo[] getThreadInfo(long[] ids, int maxDepth)
      Returns an array of ThreadInfo objects ; one for each of the threads specified in the ids argument. The stack trace information in the returned objects will depend on the value of the maxDepth argument which specifies the maximum number of StackTraceElement instances to try and include. A subsequent call to any of the returned objects' getStackTrace() method should result in a StackTraceElement array of up to maxDepth elements. A maxDepth value of Integer.MAX_VALUE will attempt to obtain all of the stack trace information for each specified thread while a maxDepth value of zero will yield none.

      The returned object will hold no details of locked synchronizers or locked object monitors for the specified thread; calls to getLockedMonitors() and getLockedSynchronizers will both return array values.

      Specified by:
      getThreadInfo in interface ThreadMXBean
      Parameters:
      ids - an array of thread identifiers. Each must be a positive number greater than zero.
      maxDepth - the maximum number of stack trace entries to be included in each of the returned ThreadInfo objects. Supplying Integer.MAX_VALUE attempts to obtain all of the stack traces. Only a positive value is expected.
      Returns:
      an array of ThreadInfo objects. The size of the array will be identical to that of the ids argument. Null elements will be placed in the array if the corresponding thread identifier in ids does not resolve to a living thread in the virtual machine (i.e. a started thread which has not yet died).

    • getThreadInfo

      public ThreadInfo[] getThreadInfo(long[] ids, boolean lockedMonitors, boolean lockedSynchronizers)
      Get together information for threads and create instances of the ThreadInfo class.

      Assumes that caller has already carried out error checking on the id and maxDepth arguments.

      Specified by:
      getThreadInfo in interface ThreadMXBean
      Parameters:
      ids - thread ids
      lockedMonitors - if true attempt to set the returned ThreadInfo with details of object monitors locked by the specified thread
      lockedSynchronizers - if true attempt to set the returned ThreadInfo with details of ownable synchronizers locked by the specified thread
      Returns:
      information for threads

    • getThreadInfo

      public ThreadInfo[] getThreadInfo(long[] ids, boolean lockedMonitors, boolean lockedSynchronizers, int maxDepth)
      Description copied from interface: java.lang.management.ThreadMXBean
      Returns an array of ThreadInfo objects; one for each of the threads specified in the ids argument. Each ThreadInfo will hold details of all of the stack trace information for each specified thread. The returned ThreadInfo objects will optionally contain details of all monitor objects and synchronizers locked by the corresponding thread. In order to retrieve locked monitor information the lockedMonitors argument should be set to true; in order to retrieve locked synchronizers information lockedSynchronizers should be set to true. For a given ThreadInfo element of the return array the optional information may be inspected by calling ThreadInfo.getLockedMonitors() and ThreadInfo.getLockedSynchronizers() respectively.

      Both lockedMonitors and lockedSynchronizers arguments should only be set to true if the virtual machine supports the requested monitoring.

      Specified by:
      getThreadInfo in interface ThreadMXBean
      Parameters:
      ids - an array of thread identifiers. Each one must be a positive number greater than zero.
      lockedMonitors - boolean indication of whether or not each returned ThreadInfo should hold information on locked object monitors
      lockedSynchronizers - boolean indication of whether or not each returned ThreadInfo should hold information on locked synchronizers
      maxDepth - limits the number of stack frames returned
      Returns:
      an array of ThreadInfo objects with each entry corresponding to one of the threads specified in the input array of identifiers. The return array will therefore have an identical number of elements to the input ids array. If an entry in the ids array is invalid (there is no living thread with the supplied identifier in the virtual machine) then the corresponding entry in the return array will be a null.

    • getThreadInfo

      public ThreadInfo getThreadInfo(long id, int maxDepth)
      Returns a ThreadInfo object for the thread with the specified identifier. The stack trace information in the returned object will depend on the value of the maxDepth argument which specifies the maximum number of StackTraceElement instances to include. A subsequent call to the returned object's getStackTrace() method should then result in a StackTraceElement array of up to maxDepth elements. A maxDepth value of Integer.MAX_VALUE will obtain all of the stack trace information for the thread while a maxDepth value of zero will yield none.

      It is possible that the virtual machine may be unable to supply any stack trace information for the specified thread. In that case the returned ThreadInfo object will have an empty array of StackTraceElements.

      The returned object will hold no details of locked synchronizers or locked object monitors for the specified thread; calls to getLockedMonitors() and getLockedSynchronizers will both return array values.

      Specified by:
      getThreadInfo in interface ThreadMXBean
      Parameters:
      id - the identifier for a thread. Must be a positive number greater than zero.
      maxDepth - the maximum number of stack trace entries to be included in the returned ThreadInfo object. Supplying Integer.MAX_VALUE obtains all of the stack trace. Only a positive value is expected.
      Returns:
      if the supplied id maps to a living thread in the virtual machine (i.e. a started thread which has not yet died), this method returns a ThreadInfo object corresponding to that thread. Otherwise, returns null.

    • getThreadUserTime

      public long getThreadUserTime(long id)
      If supported by the virtual machine, returns the total CPU usage time for the thread with the specified identifier when running in user mode. The returned time will have nanosecond precision but may not have nanosecond accuracy.

      Method ThreadMXBean.isThreadCpuTimeSupported() may be used to determine if the CPU timing of threads is supported on the virtual machine. On virtual machines where current thread CPU timing is supported, the method ThreadMXBean.isThreadCpuTimeEnabled() may be used to determine if thread CPU timing is actually enabled.

      Specified by:
      getThreadUserTime in interface ThreadMXBean
      Parameters:
      id - the identifier for a thread. Must be a positive number greater than zero.
      Returns:
      on virtual machines where thread CPU timing is supported and enabled, and there is a living thread with identifier id, the number of nanoseconds CPU time used by the thread running in user mode. On virtual machines where thread CPU timing is supported but not enabled, or where there is no living thread with identifier id present in the virtual machine, a value of -1 is returned.

      If thread CPU timing was disabled when the thread was started then the virtual machine is free to choose any measurement start time between when the virtual machine started up and when thread CPU timing was enabled with a call to ThreadMXBean.setThreadCpuTimeEnabled(boolean).

      See Also:

    • getTotalStartedThreadCount

      public long getTotalStartedThreadCount()
      Returns the number of threads that have been started in this virtual machine since it came into being.
      Specified by:
      getTotalStartedThreadCount in interface ThreadMXBean
      Returns:
      the total number of started threads.

    • isCurrentThreadCpuTimeSupported

      public boolean isCurrentThreadCpuTimeSupported()
      Returns a boolean indication of whether or not the virtual machine supports the CPU timing of the current thread.

      Note that this method must return true if ThreadMXBean.isThreadCpuTimeSupported() returns true.

      Specified by:
      isCurrentThreadCpuTimeSupported in interface ThreadMXBean
      Returns:
      true if CPU timing of the current thread is supported, otherwise false.

    • isThreadContentionMonitoringEnabled

      public boolean isThreadContentionMonitoringEnabled()
      Returns a boolean indication of whether or not the monitoring of thread contention situations is enabled on this virtual machine.
      Specified by:
      isThreadContentionMonitoringEnabled in interface ThreadMXBean
      Returns:
      true if thread contention monitoring is enabled, false otherwise.

    • isThreadContentionMonitoringSupported

      public boolean isThreadContentionMonitoringSupported()
      Returns a boolean indication of whether or not the monitoring of thread contention situations is supported on this virtual machine.
      Specified by:
      isThreadContentionMonitoringSupported in interface ThreadMXBean
      Returns:
      true if thread contention monitoring is supported, false otherwise.

    • isThreadCpuTimeEnabled

      public boolean isThreadCpuTimeEnabled()
      Returns a boolean indication of whether or not the CPU timing of threads is enabled on this virtual machine.
      Specified by:
      isThreadCpuTimeEnabled in interface ThreadMXBean
      Returns:
      true if thread CPU timing is enabled, false otherwise.
      See Also:

    • isThreadCpuTimeSupported

      public boolean isThreadCpuTimeSupported()
      Returns a boolean indication of whether or not the virtual machine supports the CPU time measurement of any threads (current or otherwise).
      Specified by:
      isThreadCpuTimeSupported in interface ThreadMXBean
      Returns:
      true if the virtual machine supports the CPU timing of threads, false otherwise.

    • resetPeakThreadCount

      public void resetPeakThreadCount()
      Resets the peak thread count to be the current number of threads alive in the virtual machine when the call is made.
      Specified by:
      resetPeakThreadCount in interface ThreadMXBean

    • setThreadContentionMonitoringEnabled

      public void setThreadContentionMonitoringEnabled(boolean enable)
      Updates the virtual machine to either enable or disable the monitoring of thread contention situations.

      If it is supported, the virtual machine will initially not monitor thread contention situations.

      Specified by:
      setThreadContentionMonitoringEnabled in interface ThreadMXBean
      Parameters:
      enable - enable thread contention monitoring if true, otherwise disable thread contention monitoring.
      See Also:

    • setThreadCpuTimeEnabled

      public void setThreadCpuTimeEnabled(boolean enable)
      If supported, updates the virtual machine to either enable or disable the CPU timing of threads.

      The default value of this property depends on the underlying operating system on which the virtual machine is running.

      Specified by:
      setThreadCpuTimeEnabled in interface ThreadMXBean
      Parameters:
      enable - enable thread CPU timing if true, otherwise disable thread CPU timing
      See Also:

    • isObjectMonitorUsageSupported

      public boolean isObjectMonitorUsageSupported()
      Returns a boolean indication of whether or not the virtual machine supports the monitoring of object monitor usage.
      Specified by:
      isObjectMonitorUsageSupported in interface ThreadMXBean
      Returns:
      true if object monitor usage is permitted, otherwise false

    • isSynchronizerUsageSupported

      public boolean isSynchronizerUsageSupported()
      Returns a boolean indication of whether or not the virtual machine supports the monitoring of ownable synchronizers (synchronizers that make use of the AbstractOwnableSynchronizer type and which are completely owned by a single thread).
      Specified by:
      isSynchronizerUsageSupported in interface ThreadMXBean
      Returns:
      true if synchronizer usage monitoring is permitted, otherwise false

    • findDeadlockedThreads

      public long[] findDeadlockedThreads()
      If supported by the virtual machine, this method can be used to retrieve the long id of all threads currently waiting on object monitors or ownable synchronizers (synchronizers that make use of the AbstractOwnableSynchronizer type and which are completely owned by a single thread). To determine the threads currently deadlocked by object monitors only use the ThreadMXBean.findMonitorDeadlockedThreads() method.

      It is recommended that this method be used solely for problem determination analysis and not as a means of managing thread synchronization in a virtual machine. This is because the method may be very expensive to run.

      Specified by:
      findDeadlockedThreads in interface ThreadMXBean
      Returns:
      an array of the identifiers of every thread in the virtual machine that has been detected as currently being in a deadlock situation involving object monitors and ownable synchronizers. If there are no threads in this category a null is returned.
      See Also:

    • dumpAllThreads

      public ThreadInfo[] dumpAllThreads(boolean lockedMonitors, boolean lockedSynchronizers)
      Returns an array of ThreadInfo objects holding information on all threads that were alive when the call was invoked.
      Specified by:
      dumpAllThreads in interface ThreadMXBean
      Parameters:
      lockedMonitors - boolean indication of whether or not information on all currently locked object monitors is to be included in the returned array
      lockedSynchronizers - boolean indication of whether or not information on all currently locked ownable synchronizers is to be included in the returned array
      Returns:
      an array of ThreadInfo objects

    • dumpAllThreads

      public ThreadInfo[] dumpAllThreads(boolean lockedMonitors, boolean lockedSynchronizers, int maxDepth)
      Returns an array of ThreadInfo objects holding information on all threads that were alive when the call was invoked.
      Specified by:
      dumpAllThreads in interface ThreadMXBean
      Parameters:
      lockedMonitors - boolean indication of whether or not information on all currently locked object monitors is to be included in the returned array
      lockedSynchronizers - boolean indication of whether or not information on all currently locked ownable synchronizers is to be included in the returned array
      maxDepth - limits the number of stack frames returned
      Returns:
      an array of ThreadInfo objects

    • getNativeThreadIds

      public long[] getNativeThreadIds(long[] threadIDs) throws IllegalArgumentException, SecurityException
      To satisfy com.ibm.lang.management.ThreadMXBean.
      Throws:
      IllegalArgumentException
      SecurityException

    • getNativeThreadId

      public long getNativeThreadId(long threadId) throws IllegalArgumentException, SecurityException
      To satisfy com.ibm.lang.management.
      Throws:
      IllegalArgumentException
      SecurityException

    • getObjectName

      public ObjectName getObjectName()
      Returns an ObjectName instance representing the object name of this platform managed object.
      Specified by:
      getObjectName in interface PlatformManagedObject
      Returns:
      an ObjectName instance representing the object name of this platform managed object.