Source for java.lang.management.ThreadMXBean

   1: /* ThreadMXBean.java - Interface for a thread bean
   2:    Copyright (C) 2006 Free Software Foundation
   3: 
   4: This file is part of GNU Classpath.
   5: 
   6: GNU Classpath is free software; you can redistribute it and/or modify
   7: it under the terms of the GNU General Public License as published by
   8: the Free Software Foundation; either version 2, or (at your option)
   9: any later version.
  10: 
  11: GNU Classpath is distributed in the hope that it will be useful, but
  12: WITHOUT ANY WARRANTY; without even the implied warranty of
  13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14: General Public License for more details.
  15: 
  16: You should have received a copy of the GNU General Public License
  17: along with GNU Classpath; see the file COPYING.  If not, write to the
  18: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19: 02110-1301 USA.
  20: 
  21: Linking this library statically or dynamically with other modules is
  22: making a combined work based on this library.  Thus, the terms and
  23: conditions of the GNU General Public License cover the whole
  24: combination.
  25: 
  26: As a special exception, the copyright holders of this library give you
  27: permission to link this library with independent modules to produce an
  28: executable, regardless of the license terms of these independent
  29: modules, and to copy and distribute the resulting executable under
  30: terms of your choice, provided that you also meet, for each linked
  31: independent module, the terms and conditions of the license of that
  32: module.  An independent module is a module which is not derived from
  33: or based on this library.  If you modify this library, you may extend
  34: this exception to your version of the library, but you are not
  35: obligated to do so.  If you do not wish to do so, delete this
  36: exception statement from your version. */
  37: 
  38: package java.lang.management;
  39: 
  40: /**
  41:  * <p>
  42:  * Provides access to information about the threads
  43:  * of the virtual machine.  An instance of this bean is
  44:  * obtained by calling
  45:  * {@link ManagementFactory#getThreadMXBean()}.
  46:  * </p>
  47:  * <p>
  48:  * Each thread within the virtual machine is given an
  49:  * identifier, which is guaranteed to be unique to a
  50:  * particular thread over its lifetime (after which it
  51:  * may be reused). The identifier for a thread may be
  52:  * obtained by calling {@link java.lang.Thread#getId()}.
  53:  * This identifier is used within implementations of this
  54:  * interface to obtain information about a particular thread
  55:  * (or series of threads, in the case of an array of identifiers).
  56:  * </p>
  57:  * <p>
  58:  * This bean supports some optional behaviour, which all
  59:  * virtual machines may not choose to implement.  Specifically,
  60:  * this includes the monitoring of:
  61:  * </p>
  62:  * <ul>
  63:  * <li>the CPU time used by a thread</li>
  64:  * <li>thread contention</li>
  65:  * <li>object monitor usage</li>
  66:  * <li>ownable synchronizer usage</li>
  67:  * </ul>
  68:  * <p>
  69:  * The monitoring of CPU time is further subdivided into
  70:  * the monitoring of either just the current thread or all
  71:  * threads.  The methods
  72:  * {@link #isThreadCpuTimeSupported()},
  73:  * {@link #isCurrentThreadCpuTimeSupported()}
  74:  * {@link #isThreadContentionMonitoringSupported()},
  75:  * {@link #isObjectMonitorUsageSupported()} and
  76:  * {@link #isSynchronizerUsageSupported()} may be
  77:  * used to determine whether or not this functionality is
  78:  * supported.
  79:  * </p>
  80:  * <p>
  81:  * Furthermore, both time and contention monitoring may be
  82:  * disabled.  In fact, thread contention monitoring is disabled
  83:  * by default, and must be explictly turned on by calling
  84:  * the {@link #setThreadContentionMonitoringEnabled(boolean)}
  85:  * method.
  86:  * </p>
  87:  *
  88:  * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
  89:  * @since 1.5
  90:  */
  91: public interface ThreadMXBean
  92: {
  93: 
  94:   /**
  95:    * This method returns information on all live threads at the
  96:    * time of execution (some threads may have terminated by the
  97:    * time the method completes).  This method is simply a shorthand
  98:    * for calling {@link #getThreadInfo(long[], boolean,
  99:    * boolean)} with the return value of {@link #getAllThreadIds()}.
 100:    *
 101:    * @param lockedMonitors true if the returned {@link ThreadInfo}
 102:    *                       objects should contain information on
 103:    *                       locked monitors.
 104:    * @param lockedSynchronizers true if the returned {@link ThreadInfo}
 105:    *                            objects should contain information
 106:    *                            on locked ownable synchronizers.
 107:    * @return an array of {@link ThreadInfo} objects for all live threads.
 108:    * @throws SecurityException if a security manager exists and
 109:    *                           denies ManagementPermission("monitor").
 110:    * @throws UnsupportedOperationException if <code>lockedMonitors</code>
 111:    *                                       is true, but object monitor
 112:    *                                       usage monitoring is not supported
 113:    *                                       by the VM, or
 114:    *                                       <code>lockedSynchronizers</code>
 115:    *                                       is true, but ownable synchronizer
 116:    *                                       usage monitoring is not supported
 117:    *                                       by the VM.
 118:    * @since 1.6
 119:    * @see #getThreadInfo(long[], boolean, boolean)
 120:    * @see #getAllThreadIds()
 121:    * @see #isObjectMonitorUsageSupported()
 122:    * @see #isSynchronizerUsageSupported()
 123:    */
 124:   ThreadInfo[] dumpAllThreads(boolean lockedMonitors,
 125:                               boolean lockedSynchronizers);
 126: 
 127:   /**
 128:    * <p>
 129:    * This method obtains a list of threads which are deadlocked
 130:    * waiting to obtain monitor or ownable synchronizer ownership.
 131:    * This is similar to the behaviour described for
 132:    * {@link #getMonitorDeadlockedThreads()}, except this method also
 133:    * takes in to account deadlocks involving ownable synchronizers.
 134:    * </p>
 135:    * <p>
 136:    * Note that this method is not designed for controlling
 137:    * synchronization, but for troubleshooting problems which cause such
 138:    * deadlocks; it may be prohibitively expensive to use in normal
 139:    * operation.  If only deadlocks involving monitors are of interest,
 140:    * then {@link #findMonitorDeadlockedThreads()} should be used in
 141:    * preference to this method.
 142:    * </p>
 143:    *
 144:    * @return an array of thread identifiers, corresponding to threads
 145:    *         which are currently in a deadlocked situation, or
 146:    *         <code>null</code> if there are no deadlocks.
 147:    * @throws SecurityException if a security manager exists and
 148:    *                           denies ManagementPermission("monitor").
 149:    * @throws UnsupportedOperationException if the VM does not support
 150:    *                                       the monitoring of ownable
 151:    *                                       synchronizer usage.
 152:    * @since 1.6
 153:    * @see #findMonitorDeadlockedThreads()
 154:    * @see #isSynchronizerUsageSupported()
 155:    */
 156:   long[] findDeadlockedThreads();
 157: 
 158:   /**
 159:    * <p>
 160:    * This method obtains a list of threads which are deadlocked
 161:    * waiting to obtain monitor ownership.  On entering a synchronized
 162:    * method of an object, or re-entering it after returning from an
 163:    * {@link java.lang.Object#wait()} call, a thread obtains ownership
 164:    * of the object's monitor.
 165:    * </p>
 166:    * <p>
 167:    * Deadlocks can occur in this situation if one or more threads end up
 168:    * waiting for a monitor, P, while also retaining ownership of a monitor,
 169:    * Q, required by the thread that currently owns P.  To give a simple
 170:    * example, imagine thread A calls a synchronized method, R, obtaining the
 171:    * monitor, P.  It then sleeps within that method, allowing thread B
 172:    * to run, but still retaining ownership of P.  B calls another
 173:    * synchronized method, S, which causes it to obtain the monitor, Q,
 174:    * of a different object.  While in that method, it then wants to
 175:    * call the original synchronized method, R,  called by A.  Doing so
 176:    * requires ownership of P, which is still held by A.  Hence, it
 177:    * becomes blocked.
 178:    * </p>
 179:    * <p>
 180:    * A then finishes its sleep, becomes runnable, and is then allowed
 181:    * to run, being the only eligible thread in this scenario.  A tries
 182:    * to call the synchronized method, S.  It also gets blocked, because
 183:    * B still holds the monitor, Q.  Hence, the two threads, A and B,
 184:    * are deadlocked, as neither can give up its monitor without first
 185:    * obtaining the monitor held by the other thread.
 186:    * </p>
 187:    * <p>
 188:    * Calling this method in this scenario would return the thread IDs
 189:    * of A and B.  Note that this method is not designed for controlling
 190:    * synchronization, but for troubleshooting problems which cause such
 191:    * deadlocks; it may be prohibitively expensive to use in normal
 192:    * operation.  This method only returns deadlocks involving monitors;
 193:    * to include deadlocks involving ownable synchronizers,
 194:    * {@link #findDeadlockedThreads()} should be used instead.
 195:    * </p>
 196:    *
 197:    * @return an array of thread identifiers, corresponding to threads
 198:    *         which are currently in a deadlocked situation, or
 199:    *         <code>null</code> if there are no deadlocks.
 200:    * @throws SecurityException if a security manager exists and
 201:    *                           denies ManagementPermission("monitor").
 202:    * @see #findDeadlockedThreads()
 203:    */
 204:   long[] findMonitorDeadlockedThreads();
 205: 
 206:   /**
 207:    * Returns all live thread identifiers at the time of initial
 208:    * execution.  Some thread identifiers in the returned array
 209:    * may refer to terminated threads, if this occurs during the
 210:    * lifetime of this method.
 211:    *
 212:    * @return an array of thread identifiers, corresponding to
 213:    *         current live threads.
 214:    * @throws SecurityException if a security manager exists and
 215:    *                           denies ManagementPermission("monitor").
 216:    */
 217:   long[] getAllThreadIds();
 218: 
 219:   /**
 220:    * <p>
 221:    * Returns the total number of nanoseconds of CPU time
 222:    * the current thread has used.  This is equivalent to calling
 223:    * <code>{@link #getThreadCpuTime()}(Thread.currentThread.getId())</code>.
 224:    * </p>
 225:    * <p>
 226:    * Note that the value is only nanosecond-precise, and not accurate; there
 227:    * is no guarantee that the difference between two values is really a
 228:    * nanosecond.  Also, the value is prone to overflow if the offset
 229:    * exceeds 2^63.  The use of this method depends on virtual machine
 230:    * support for measurement of the CPU time of the current thread,
 231:    * and on this functionality being enabled.
 232:    * </p>
 233:    *
 234:    * @return the total number of nanoseconds of CPU time the current
 235:    *         thread has used, or -1 if CPU time monitoring is disabled.
 236:    * @throws UnsupportedOperationException if CPU time monitoring is not
 237:    *                                       supported.
 238:    * @see #getCurrentThreadUserTime()
 239:    * @see #isCurrentThreadCpuTimeSupported()
 240:    * @see #isThreadCpuTimeEnabled()
 241:    * @see #setThreadCpuTimeEnabled(boolean)
 242:    */
 243:   long getCurrentThreadCpuTime();
 244: 
 245:   /**
 246:    * <p>
 247:    * Returns the total number of nanoseconds of CPU time
 248:    * the current thread has executed in user mode.  This is
 249:    * equivalent to calling
 250:    * <code>{@link #getThreadUserTime()}(Thread.currentThread.getId())</code>.
 251:    * </p>
 252:    * <p>
 253:    * Note that the value is only nanosecond-precise, and not accurate; there
 254:    * is no guarantee that the difference between two values is really a
 255:    * nanosecond.  Also, the value is prone to overflow if the offset
 256:    * exceeds 2^63.  The use of this method depends on virtual machine
 257:    * support for measurement of the CPU time of the current thread,
 258:    * and on this functionality being enabled.
 259:    * </p>
 260:    *
 261:    * @return the total number of nanoseconds of CPU time the current
 262:    *         thread has executed in user mode, or -1 if CPU time
 263:    *         monitoring is disabled.
 264:    * @throws UnsupportedOperationException if CPU time monitoring is not
 265:    *                                       supported.
 266:    * @see #getCurrentThreadCpuTime()
 267:    * @see #isCurrentThreadCpuTimeSupported()
 268:    * @see #isThreadCpuTimeEnabled()
 269:    * @see #setThreadCpuTimeEnabled(boolean)
 270:    */
 271:   long getCurrentThreadUserTime();
 272: 
 273:   /**
 274:    * Returns the number of live daemon threads.
 275:    *
 276:    * @return the number of live daemon threads.
 277:    */
 278:   int getDaemonThreadCount();
 279: 
 280:   /**
 281:    * Returns the peak number of live threads since
 282:    * the virtual machine was started or the count
 283:    * reset using {@link #resetPeakThreadCount()}.
 284:    *
 285:    * @return the peak live thread count.
 286:    * @see #resetPeakThreadCount()
 287:    */
 288:   int getPeakThreadCount();
 289: 
 290:   /**
 291:    * Returns the number of live threads, including
 292:    * both daemon threads and non-daemon threads.
 293:    *
 294:    * @return the current number of live threads.
 295:    */
 296:   int getThreadCount();
 297: 
 298:   /**
 299:    * <p>
 300:    * Returns the total number of nanoseconds of CPU time
 301:    * the specified thread has used.
 302:    * </p>
 303:    * <p>
 304:    * Note that the value is only nanosecond-precise, and not accurate; there
 305:    * is no guarantee that the difference between two values is really a
 306:    * nanosecond.  Also, the value is prone to overflow if the offset
 307:    * exceeds 2^63.  The use of this method depends on virtual machine
 308:    * support for measurement of the CPU time of the current thread,
 309:    * and on this functionality being enabled.
 310:    * </p>
 311:    *
 312:    * @param id the thread identifier of the thread whose CPU time is being
 313:    *           monitored.
 314:    * @return the total number of nanoseconds of CPU time the specified
 315:    *         thread has used, or -1 if CPU time monitoring is disabled.
 316:    * @throws IllegalArgumentException if <code>id</code> <= 0.
 317:    * @throws UnsupportedOperationException if CPU time monitoring is not
 318:    *                                       supported.
 319:    * @see #getThreadUserTime(long)
 320:    * @see #isThreadCpuTimeSupported()
 321:    * @see #isThreadCpuTimeEnabled()
 322:    * @see #setThreadCpuTimeEnabled(boolean)
 323:    */
 324:   long getThreadCpuTime(long id);
 325: 
 326:   /**
 327:    * Returns information on the specified thread without any
 328:    * stack trace information.  This is equivalent to
 329:    * <code>{@link #getThreadInfo}(id, 0)</code>.  If the
 330:    * identifier specifies a thread which is either non-existant
 331:    * or not alive, then the method returns <code>null</code>.
 332:    *
 333:    * @param id the identifier of the thread to return information
 334:    *           on.
 335:    * @return a {@link ThreadInfo} object pertaining to the specified
 336:    *         thread, or <code>null</code> if the identifier specifies
 337:    *         a thread that doesn't exist or is not alive.
 338:    * @throws IllegalArgumentException if <code>id</code> <= 0.
 339:    * @throws SecurityException if a security manager exists and
 340:    *                           denies ManagementPermission("monitor").
 341:    */
 342:   ThreadInfo getThreadInfo(long id);
 343: 
 344:   /**
 345:    * Returns information on the specified threads without any
 346:    * stack trace information.  This is equivalent to
 347:    * <code>{@link #getThreadInfo}(ids, 0)</code>.  If an
 348:    * identifier specifies a thread which is either non-existant
 349:    * or not alive, then the corresponding element in the returned
 350:    * array is <code>null</code>.
 351:    *
 352:    * @param ids an array of thread identifiers to return information
 353:    *           on.
 354:    * @return an array of {@link ThreadInfo} objects matching the
 355:    *         specified threads.  The corresponding element is
 356:    *         <code>null</code> if the identifier specifies
 357:    *         a thread that doesn't exist or is not alive.
 358:    * @throws IllegalArgumentException if an identifier in the array is
 359:    *                                  <= 0.
 360:    * @throws SecurityException if a security manager exists and
 361:    *                           denies ManagementPermission("monitor").
 362:    */
 363:   ThreadInfo[] getThreadInfo(long[] ids);
 364: 
 365:   /**
 366:    * Returns information on the specified threads with full
 367:    * stack trace information and optional synchronization
 368:    * information.  If <code>lockedMonitors</code> is false,
 369:    * or there are no locked monitors for a particular thread,
 370:    * then the corresponding {@link ThreadInfo} object will have
 371:    * an empty {@link MonitorInfo} array.  Likewise, if
 372:    * <code>lockedSynchronizers</code> is false, or there are
 373:    * no locked ownable synchronizers for a particular thread,
 374:    * then the corresponding {@link ThreadInfo} object will have
 375:    * an empty {@link LockInfo} array.  If both
 376:    * <code>lockedMonitors</code> and <code>lockedSynchronizers</code>
 377:    * are false, the return value is equivalent to that from
 378:    * <code>{@link #getThreadInfo}(ids, Integer.MAX_VALUE)</code>.
 379:    * If an identifier specifies a thread which is either non-existant
 380:    * or not alive, then the corresponding element in the returned
 381:    * array is <code>null</code>.
 382:    *
 383:    * @param ids an array of thread identifiers to return information
 384:    *           on.
 385:    * @param lockedMonitors true if information on locked monitors
 386:    *                       should be included.
 387:    * @param lockedSynchronizers true if information on locked
 388:    *                            ownable synchronizers should be included.
 389:    * @return an array of {@link ThreadInfo} objects matching the
 390:    *         specified threads.  The corresponding element is
 391:    *         <code>null</code> if the identifier specifies
 392:    *         a thread that doesn't exist or is not alive.
 393:    * @throws IllegalArgumentException if an identifier in the array is
 394:    *                                  <= 0.
 395:    * @throws SecurityException if a security manager exists and
 396:    *                           denies ManagementPermission("monitor").
 397:    * @throws UnsupportedOperationException if <code>lockedMonitors</code>
 398:    *                                       is true, but object monitor
 399:    *                                       usage monitoring is not supported
 400:    *                                       by the VM, or
 401:    *                                       <code>lockedSynchronizers</code>
 402:    *                                       is true, but ownable synchronizer
 403:    *                                       usage monitoring is not supported
 404:    *                                       by the VM.
 405:    * @since 1.6
 406:    * @see #isObjectMonitorUsageSupported()
 407:    * @see #isSynchronizerUsageSupported()
 408:    */
 409:   ThreadInfo[] getThreadInfo(long[] ids, boolean lockedMonitors,
 410:                              boolean lockedSynchronizers);
 411: 
 412:   /**
 413:    * Returns information on the specified thread with
 414:    * stack trace information to the supplied depth.  If the
 415:    * identifier specifies a thread which is either non-existant
 416:    * or not alive, then the method returns <code>null</code>.
 417:    * A maximum depth of 0 corresponds to an empty stack trace
 418:    * (an empty array is returned by the appropriate
 419:    * {@link ThreadInfo} method).  A maximum depth of
 420:    * <code>Integer.MAX_VALUE</code> returns the full stack trace.
 421:    *
 422:    * @param id the identifier of the thread to return information
 423:    *           on.
 424:    * @param maxDepth the maximum depth of the stack trace.
 425:    *                 Values of 0 or <code>Integer.MAX_VALUE</code>
 426:    *                 correspond to an empty and full stack trace
 427:    *                 respectively.
 428:    * @return a {@link ThreadInfo} object pertaining to the specified
 429:    *         thread, or <code>null</code> if the identifier specifies
 430:    *         a thread that doesn't exist or is not alive.
 431:    * @throws IllegalArgumentException if <code>id</code> <= 0.
 432:    * @throws IllegalArgumentException if <code>maxDepth</code> < 0.
 433:    * @throws SecurityException if a security manager exists and
 434:    *                           denies ManagementPermission("monitor").
 435:    */
 436:   ThreadInfo getThreadInfo(long id, int maxDepth);
 437: 
 438:   /**
 439:    * Returns information on the specified threads with
 440:    * stack trace information to the supplied depth.  If an
 441:    * identifier specifies a thread which is either non-existant
 442:    * or not alive, then the corresponding element in the returned
 443:    * array is <code>null</code>.  A maximum depth of 0 corresponds
 444:    * to an empty stack trace (an empty array is returned by the
 445:    * appropriate {@link ThreadInfo} method).  A maximum depth of
 446:    * <code>Integer.MAX_VALUE</code> returns the full stack trace.
 447:    *
 448:    * @param ids an array of thread identifiers to return information
 449:    *           on.
 450:    * @param maxDepth the maximum depth of the stack trace.
 451:    *                 Values of 0 or <code>Integer.MAX_VALUE</code>
 452:    *                 correspond to an empty and full stack trace
 453:    *                 respectively.
 454:    * @return an array of {@link ThreadInfo} objects matching the
 455:    *         specified threads.  The corresponding element is
 456:    *         <code>null</code> if the identifier specifies
 457:    *         a thread that doesn't exist or is not alive.
 458:    * @throws IllegalArgumentException if an identifier in the array is
 459:    *                                  <= 0.
 460:    * @throws IllegalArgumentException if <code>maxDepth</code> < 0.
 461:    * @throws SecurityException if a security manager exists and
 462:    *                           denies ManagementPermission("monitor").
 463:    */
 464:   ThreadInfo[] getThreadInfo(long[] ids, int maxDepth);
 465: 
 466:   /**
 467:    * <p>
 468:    * Returns the total number of nanoseconds of CPU time
 469:    * the specified thread has executed in user mode.
 470:    * </p>
 471:    * <p>
 472:    * Note that the value is only nanosecond-precise, and not accurate; there
 473:    * is no guarantee that the difference between two values is really a
 474:    * nanosecond.  Also, the value is prone to overflow if the offset
 475:    * exceeds 2^63.  The use of this method depends on virtual machine
 476:    * support for measurement of the CPU time of the current thread,
 477:    * and on this functionality being enabled.
 478:    * </p>
 479:    *
 480:    * @param id the thread identifier of the thread whose CPU time is being
 481:    *           monitored.
 482:    * @return the total number of nanoseconds of CPU time the specified
 483:    *         thread has executed in user mode, or -1 if CPU time monitoring
 484:    *         is disabled.
 485:    * @throws IllegalArgumentException if <code>id</code> <= 0.
 486:    * @throws UnsupportedOperationException if CPU time monitoring is not
 487:    *                                       supported.
 488:    * @see #getThreadCpuTime(long)
 489:    * @see #isThreadCpuTimeSupported()
 490:    * @see #isThreadCpuTimeEnabled()
 491:    * @see #setThreadCpuTimeEnabled(boolean)
 492:    */
 493:   long getThreadUserTime(long id);
 494: 
 495:   /**
 496:    * Returns the total number of threads that have been
 497:    * created and started during the lifetime of the virtual
 498:    * machine.
 499:    *
 500:    * @return the total number of started threads.
 501:    */
 502:   long getTotalStartedThreadCount();
 503: 
 504:   /**
 505:    * Returns true if the virtual machine supports the monitoring
 506:    * of the CPU time used by the current thread.  This is implied
 507:    * by {@link isThreadCpuTimeSupported()} returning true.
 508:    *
 509:    * @return true if monitoring of the CPU time used by the current
 510:    *         thread is supported by the virtual machine.
 511:    * @see #isThreadCpuTimeEnabled()
 512:    * @see #isThreadCpuTimeSupported()
 513:    * @see #setThreadCpuTimeEnabled(boolean)
 514:    */
 515:   boolean isCurrentThreadCpuTimeSupported();
 516: 
 517:   /**
 518:    * Returns true if the virtual machine supports the monitoring
 519:    * of object monitor usage.
 520:    *
 521:    * @return true if the monitoring of object monitor usage
 522:    *         is supported by the virtual machine.
 523:    * @since 1.6
 524:    */
 525:   boolean isObjectMonitorUsageSupported();
 526: 
 527:   /**
 528:    * Returns true if the virtual machine supports the monitoring
 529:    * of ownable synchronizer usage.
 530:    *
 531:    * @return true if the monitoring of ownable synchronizer usage
 532:    *         is supported by the virtual machine.
 533:    * @since 1.6
 534:    */
 535:   boolean isSynchronizerUsageSupported();
 536: 
 537:   /**
 538:    * Returns true if thread contention monitoring is currently
 539:    * enabled.
 540:    *
 541:    * @return true if thread contention monitoring is enabled.
 542:    * @throws UnsupportedOperationException if the virtual
 543:    *                                       machine does not
 544:    *                                       support contention
 545:    *                                       monitoring.
 546:    * @see #isThreadContentionMonitoringSupported()
 547:    * @see #setThreadContentionMonitoringEnabled(boolean)
 548:    */
 549:   boolean isThreadContentionMonitoringEnabled();
 550: 
 551:   /**
 552:    * Returns true if thread contention monitoring is supported
 553:    * by the virtual machine.
 554:    *
 555:    * @return true if thread contention monitoring is supported
 556:    *         by the virtual machine.
 557:    * @see #isThreadContentionMonitoringEnabled()
 558:    * @see #setThreadContentionMonitoringEnabled(boolean)
 559:    */
 560:   boolean isThreadContentionMonitoringSupported();
 561: 
 562:   /**
 563:    * Returns true if monitoring of the CPU time used by a thread
 564:    * is currently enabled.
 565:    *
 566:    * @return true if thread CPU time monitoring is enabled.
 567:    * @throws UnsupportedOperationException if the virtual
 568:    *                                       machine does not
 569:    *                                       support CPU time
 570:    *                                       monitoring.
 571:    * @see #isCurrentThreadCpuTimeSupported()
 572:    * @see #isThreadCpuTimeSupported()
 573:    * @see #setThreadCpuTimeEnabled(boolean)
 574:    */
 575:   boolean isThreadCpuTimeEnabled();
 576: 
 577:   /**
 578:    * Returns true if the virtual machine supports the monitoring
 579:    * of the CPU time used by all threads.  This implies
 580:    * that {@link isCurrentThreadCpuTimeSupported()} returns true.
 581:    *
 582:    * @return true if monitoring of the CPU time used by the current
 583:    *         thread is supported by the virtual machine.
 584:    * @see #isCurrentThreadCpuTimeSupported()
 585:    * @see #isThreadCpuTimeEnabled()
 586:    * @see #setThreadCpuTimeEnabled(boolean)
 587:    */
 588:   boolean isThreadCpuTimeSupported();
 589: 
 590:   /**
 591:    * Resets the peak live thread count to the
 592:    * current number of live threads, as returned
 593:    * by {@link #getThreadCount()}.
 594:    *
 595:    * @see #getPeakThreadCount()
 596:    * @see #getThreadCount()
 597:    * @throws SecurityException if a security manager exists and
 598:    *                           denies ManagementPermission("control").
 599:    */
 600:   void resetPeakThreadCount();
 601: 
 602:   /**
 603:    * Toggles the monitoring of thread contention.  Thread
 604:    * contention monitoring is disabled by default.  Each
 605:    * time contention monitoring is re-enabled, the times
 606:    * it maintains are reset.
 607:    *
 608:    * @param enable true if monitoring should be enabled,
 609:    *               false if it should be disabled.
 610:    * @throws UnsupportedOperationException if the virtual
 611:    *                                       machine does not
 612:    *                                       support contention
 613:    *                                       monitoring.
 614:    * @throws SecurityException if a security manager exists and
 615:    *                           denies ManagementPermission("control").
 616:    * @see #isThreadContentionMonitoringEnabled()
 617:    * @see #isThreadContentionMonitoringSupported()
 618:    */
 619:   void setThreadContentionMonitoringEnabled(boolean enable);
 620: 
 621:   /**
 622:    * Toggles the monitoring of CPU time used by threads. The
 623:    * initial setting is dependent on the underlying virtual
 624:    * machine.  On enabling CPU time monitoring, the virtual
 625:    * machine may take any value up to and including the current
 626:    * time as the start time for monitoring.
 627:    *
 628:    * @param enable true if monitoring should be enabled,
 629:    *               false if it should be disabled.
 630:    * @throws UnsupportedOperationException if the virtual
 631:    *                                       machine does not
 632:    *                                       support CPU time
 633:    *                                       monitoring.
 634:    * @throws SecurityException if a security manager exists and
 635:    *                           denies ManagementPermission("control").
 636:    * @see #isCurrentThreadCpuTimeSupported()
 637:    * @see #isThreadCpuTimeEnabled()
 638:    * @see #isThreadCpuTimeSupported()
 639:    */
 640:   void setThreadCpuTimeEnabled(boolean enable);
 641: 
 642: }