001    /* ThreadMXBean.java - Interface for a thread bean
002       Copyright (C) 2006 Free Software Foundation
003    
004    This file is part of GNU Classpath.
005    
006    GNU Classpath is free software; you can redistribute it and/or modify
007    it under the terms of the GNU General Public License as published by
008    the Free Software Foundation; either version 2, or (at your option)
009    any later version.
010    
011    GNU Classpath is distributed in the hope that it will be useful, but
012    WITHOUT ANY WARRANTY; without even the implied warranty of
013    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
014    General Public License for more details.
015    
016    You should have received a copy of the GNU General Public License
017    along with GNU Classpath; see the file COPYING.  If not, write to the
018    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
019    02110-1301 USA.
020    
021    Linking this library statically or dynamically with other modules is
022    making a combined work based on this library.  Thus, the terms and
023    conditions of the GNU General Public License cover the whole
024    combination.
025    
026    As a special exception, the copyright holders of this library give you
027    permission to link this library with independent modules to produce an
028    executable, regardless of the license terms of these independent
029    modules, and to copy and distribute the resulting executable under
030    terms of your choice, provided that you also meet, for each linked
031    independent module, the terms and conditions of the license of that
032    module.  An independent module is a module which is not derived from
033    or based on this library.  If you modify this library, you may extend
034    this exception to your version of the library, but you are not
035    obligated to do so.  If you do not wish to do so, delete this
036    exception statement from your version. */
037    
038    package java.lang.management;
039    
040    /**
041     * <p>
042     * Provides access to information about the threads 
043     * of the virtual machine.  An instance of this bean is
044     * obtained by calling
045     * {@link ManagementFactory#getThreadMXBean()}.
046     * </p>
047     * <p>
048     * Each thread within the virtual machine is given an
049     * identifier, which is guaranteed to be unique to a
050     * particular thread over its lifetime (after which it
051     * may be reused). The identifier for a thread may be
052     * obtained by calling {@link java.lang.Thread#getId()}.
053     * This identifier is used within implementations of this
054     * interface to obtain information about a particular thread
055     * (or series of threads, in the case of an array of identifiers).
056     * </p>
057     * <p>
058     * This bean supports some optional behaviour, which all
059     * virtual machines may not choose to implement.  Specifically,
060     * this includes the monitoring of:
061     * </p>
062     * <ul>
063     * <li>the CPU time used by a thread</li>
064     * <li>thread contention</li>
065     * <li>object monitor usage</li>
066     * <li>ownable synchronizer usage</li>
067     * </ul>
068     * <p>
069     * The monitoring of CPU time is further subdivided into
070     * the monitoring of either just the current thread or all
071     * threads.  The methods
072     * {@link #isThreadCpuTimeSupported()},
073     * {@link #isCurrentThreadCpuTimeSupported()}
074     * {@link #isThreadContentionMonitoringSupported()},
075     * {@link #isObjectMonitorUsageSupported()} and
076     * {@link #isSynchronizerUsageSupported()} may be
077     * used to determine whether or not this functionality is
078     * supported.
079     * </p>
080     * <p>
081     * Furthermore, both time and contention monitoring may be
082     * disabled.  In fact, thread contention monitoring is disabled
083     * by default, and must be explictly turned on by calling
084     * the {@link #setThreadContentionMonitoringEnabled(boolean)}
085     * method.
086     * </p>
087     *
088     * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
089     * @since 1.5
090     */
091    public interface ThreadMXBean
092    {
093    
094      /**
095       * This method returns information on all live threads at the
096       * time of execution (some threads may have terminated by the
097       * time the method completes).  This method is simply a shorthand
098       * for calling {@link #getThreadInfo(long[], boolean,
099       * 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    }