1 /*
2 * Copyright (c) 2011, 2019, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package com.sun.management;
27
28 import java.util.Map;
29
30 /**
31 * Platform-specific management interface for the thread system
32 * of the Java virtual machine.
33 * <p>
34 * This platform extension is only available to a thread
35 * implementation that supports this extension.
36 *
37 * @author Paul Hohensee
38 * @since 6u25
39 */
40
41 public interface ThreadMXBean extends java.lang.management.ThreadMXBean {
42 /**
43 * Returns the total CPU time for each thread whose ID is
44 * in the input array {@code ids} in nanoseconds.
45 * The returned values are of nanoseconds precision but
46 * not necessarily nanoseconds accuracy.
47 * <p>
48 * This method is equivalent to calling the
49 * {@link ThreadMXBean#getThreadCpuTime(long)}
50 * method for each thread ID in the input array {@code ids} and setting the
51 * returned value in the corresponding element of the returned array.
52 *
53 * @param ids an array of thread IDs.
54 * @return an array of long values, each of which is the amount of CPU
55 * time the thread whose ID is in the corresponding element of the input
56 * array of IDs has used,
57 * if the thread of a specified ID exists, the thread is alive,
58 * and CPU time measurement is enabled;
59 * {@code -1} otherwise.
60 *
61 * @throws NullPointerException if {@code ids} is {@code null}
62 * @throws IllegalArgumentException if any element in the input array
63 * {@code ids} is {@code <=} {@code 0}.
64 * @throws UnsupportedOperationException if the Java
65 * virtual machine implementation does not support CPU time
66 * measurement.
67 *
68 * @see ThreadMXBean#getThreadCpuTime(long)
69 * @see #getThreadUserTime
70 * @see ThreadMXBean#isThreadCpuTimeSupported
71 * @see ThreadMXBean#isThreadCpuTimeEnabled
72 * @see ThreadMXBean#setThreadCpuTimeEnabled
73 */
74 public long[] getThreadCpuTime(long[] ids);
75
76 /**
77 * Returns the CPU time that each thread whose ID is in the input array
78 * {@code ids} has executed in user mode in nanoseconds.
79 * The returned values are of nanoseconds precision but
80 * not necessarily nanoseconds accuracy.
81 * <p>
82 * This method is equivalent to calling the
83 * {@link ThreadMXBean#getThreadUserTime(long)}
84 * method for each thread ID in the input array {@code ids} and setting the
85 * returned value in the corresponding element of the returned array.
86 *
87 * @param ids an array of thread IDs.
88 * @return an array of long values, each of which is the amount of user
89 * mode CPU time the thread whose ID is in the corresponding element of
90 * the input array of IDs has used,
91 * if the thread of a specified ID exists, the thread is alive,
92 * and CPU time measurement is enabled;
93 * {@code -1} otherwise.
94 *
95 * @throws NullPointerException if {@code ids} is {@code null}
96 * @throws IllegalArgumentException if any element in the input array
97 * {@code ids} is {@code <=} {@code 0}.
98 * @throws UnsupportedOperationException if the Java
99 * virtual machine implementation does not support CPU time
100 * measurement.
101 *
102 * @see ThreadMXBean#getThreadUserTime(long)
103 * @see #getThreadCpuTime
104 * @see ThreadMXBean#isThreadCpuTimeSupported
105 * @see ThreadMXBean#isThreadCpuTimeEnabled
106 * @see ThreadMXBean#setThreadCpuTimeEnabled
107 */
108 public long[] getThreadUserTime(long[] ids);
109
110 /**
111 * Returns an approximation of the total amount of memory, in bytes,
112 * allocated in heap memory for the current thread.
113 * The returned value is an approximation because some Java virtual machine
114 * implementations may use object allocation mechanisms that result in a
115 * delay between the time an object is allocated and the time its size is
116 * recorded.
117 *
118 * <p>
119 * This is a convenience method for local management use and is
120 * equivalent to calling:
121 * <blockquote><pre>
122 * {@link #getThreadAllocatedBytes getThreadAllocatedBytes}(Thread.currentThread().getId());
123 * </pre></blockquote>
124 *
125 * @return an approximation of the total memory allocated, in bytes, in
126 * heap memory for the current thread
127 * if thread memory allocation measurement is enabled;
128 * {@code -1} otherwise.
129 *
130 * @throws UnsupportedOperationException if the Java virtual
131 * machine implementation does not support thread memory allocation
132 * measurement.
133 *
134 * @see #isThreadAllocatedMemorySupported
135 * @see #isThreadAllocatedMemoryEnabled
136 * @see #setThreadAllocatedMemoryEnabled
137 * @since 14
138 */
139 public long getCurrentThreadAllocatedBytes();
140
141 /**
142 * Returns an approximation of the total amount of memory, in bytes,
143 * allocated in heap memory for the thread with the specified ID.
144 * The returned value is an approximation because some Java virtual machine
145 * implementations may use object allocation mechanisms that result in a
146 * delay between the time an object is allocated and the time its size is
147 * recorded.
148 * <p>
149 * If the thread with the specified ID is not alive or does not exist,
150 * this method returns {@code -1}. If thread memory allocation measurement
151 * is disabled, this method returns {@code -1}.
152 * A thread is alive if it has been started and has not yet died.
153 * <p>
154 * If thread memory allocation measurement is enabled after the thread has
155 * started, the Java virtual machine implementation may choose any time up
156 * to and including the time that the capability is enabled as the point
157 * where thread memory allocation measurement starts.
158 *
159 * @param id the thread ID of a thread
160 * @return an approximation of the total memory allocated, in bytes, in
161 * heap memory for the thread with the specified ID
162 * if the thread with the specified ID exists, the thread is alive,
163 * and thread memory allocation measurement is enabled;
164 * {@code -1} otherwise.
165 *
166 * @throws IllegalArgumentException if {@code id} {@code <=} {@code 0}.
167 * @throws UnsupportedOperationException if the Java virtual
168 * machine implementation does not support thread memory allocation
169 * measurement.
170 *
171 * @see #isThreadAllocatedMemorySupported
172 * @see #isThreadAllocatedMemoryEnabled
173 * @see #setThreadAllocatedMemoryEnabled
174 */
175 public long getThreadAllocatedBytes(long id);
176
177 /**
178 * Returns an approximation of the total amount of memory, in bytes,
179 * allocated in heap memory for each thread whose ID is in the input
180 * array {@code ids}.
181 * The returned values are approximations because some Java virtual machine
182 * implementations may use object allocation mechanisms that result in a
183 * delay between the time an object is allocated and the time its size is
184 * recorded.
185 * <p>
186 * This method is equivalent to calling the
187 * {@link #getThreadAllocatedBytes(long)}
188 * method for each thread ID in the input array {@code ids} and setting the
189 * returned value in the corresponding element of the returned array.
190 *
191 * @param ids an array of thread IDs.
192 * @return an array of long values, each of which is an approximation of
193 * the total memory allocated, in bytes, in heap memory for the thread
194 * whose ID is in the corresponding element of the input array of IDs.
195 *
196 * @throws NullPointerException if {@code ids} is {@code null}
197 * @throws IllegalArgumentException if any element in the input array
198 * {@code ids} is {@code <=} {@code 0}.
199 * @throws UnsupportedOperationException if the Java virtual
200 * machine implementation does not support thread memory allocation
201 * measurement.
202 *
203 * @see #getThreadAllocatedBytes(long)
204 * @see #isThreadAllocatedMemorySupported
205 * @see #isThreadAllocatedMemoryEnabled
206 * @see #setThreadAllocatedMemoryEnabled
207 */
208 public long[] getThreadAllocatedBytes(long[] ids);
209
210 /**
211 * Tests if the Java virtual machine implementation supports thread memory
212 * allocation measurement.
213 *
214 * @return
215 * {@code true}
216 * if the Java virtual machine implementation supports thread memory
217 * allocation measurement;
218 * {@code false} otherwise.
219 */
220 public boolean isThreadAllocatedMemorySupported();
221
222 /**
223 * Tests if thread memory allocation measurement is enabled.
224 *
225 * @return {@code true} if thread memory allocation measurement is enabled;
226 * {@code false} otherwise.
227 *
228 * @throws UnsupportedOperationException if the Java virtual
229 * machine does not support thread memory allocation measurement.
230 *
231 * @see #isThreadAllocatedMemorySupported
232 */
233 public boolean isThreadAllocatedMemoryEnabled();
234
235 /**
236 * Enables or disables thread memory allocation measurement. The default
237 * is platform dependent.
238 *
239 * @param enable {@code true} to enable;
240 * {@code false} to disable.
241 *
242 * @throws UnsupportedOperationException if the Java virtual
243 * machine does not support thread memory allocation measurement.
244 *
245 * @throws SecurityException if a security manager
246 * exists and the caller does not have
247 * ManagementPermission("control").
248 *
249 * @see #isThreadAllocatedMemorySupported
250 */
251 public void setThreadAllocatedMemoryEnabled(boolean enable);
252 }