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 */ dumpAllThreads(boolean lockedMonitors, boolean lockedSynchronizers)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 */ findDeadlockedThreads()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 */ findMonitorDeadlockedThreads()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 */ getAllThreadIds()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 */ getCurrentThreadCpuTime()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 */ getCurrentThreadUserTime()271 long getCurrentThreadUserTime(); 272 273 /** 274 * Returns the number of live daemon threads. 275 * 276 * @return the number of live daemon threads. 277 */ getDaemonThreadCount()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 */ getPeakThreadCount()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 */ getThreadCount()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 */ getThreadCpuTime(long id)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 */ getThreadInfo(long id)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 */ getThreadInfo(long[] ids)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 */ getThreadInfo(long[] ids, boolean lockedMonitors, boolean lockedSynchronizers)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 */ getThreadInfo(long id, int maxDepth)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 */ getThreadInfo(long[] ids, int maxDepth)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 */ getThreadUserTime(long id)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 */ getTotalStartedThreadCount()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 */ isCurrentThreadCpuTimeSupported()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 */ isObjectMonitorUsageSupported()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 */ isSynchronizerUsageSupported()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 */ isThreadContentionMonitoringEnabled()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 */ isThreadContentionMonitoringSupported()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 */ isThreadCpuTimeEnabled()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 */ isThreadCpuTimeSupported()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 */ resetPeakThreadCount()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 */ setThreadContentionMonitoringEnabled(boolean enable)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 */ setThreadCpuTimeEnabled(boolean enable)640 void setThreadCpuTimeEnabled(boolean enable); 641 642 } 643