History

My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/sun/management/ThreadInfoCompositeData.java (1 of 18352 files). Show all

Unified · Split

java/pkg/sun/management/ThreadInfoCompositeData.java+415−0
@@ -0,0 +1,415 @@
1/*
2 * Copyright (c) 2004, 2008, 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
26package sun.management;
27
28import java.lang.management.ThreadInfo;
29import java.lang.management.MonitorInfo;
30import java.lang.management.LockInfo;
31import javax.management.openmbean.CompositeType;
32import javax.management.openmbean.CompositeData;
33import javax.management.openmbean.CompositeDataSupport;
34import javax.management.openmbean.OpenDataException;
35import javax.management.openmbean.OpenType;
36
37/**
38 * A CompositeData for ThreadInfo for the local management support.
39 * This class avoids the performance penalty paid to the
40 * construction of a CompositeData use in the local case.
41 */
42public class ThreadInfoCompositeData extends LazyCompositeData {
43 private final ThreadInfo threadInfo;
44 private final CompositeData cdata;
45 private final boolean currentVersion;
46
47 private ThreadInfoCompositeData(ThreadInfo ti) {
48 this.threadInfo = ti;
49 this.currentVersion = true;
50 this.cdata = null;
51 }
52
53 private ThreadInfoCompositeData(CompositeData cd) {
54 this.threadInfo = null;
55 this.currentVersion = ThreadInfoCompositeData.isCurrentVersion(cd);
56 this.cdata = cd;
57 }
58
59 public ThreadInfo getThreadInfo() {
60 return threadInfo;
61 }
62
63 public boolean isCurrentVersion() {
64 return currentVersion;
65 }
66
67 public static ThreadInfoCompositeData getInstance(CompositeData cd) {
68 validateCompositeData(cd);
69 return new ThreadInfoCompositeData(cd);
70 }
71
72 public static CompositeData toCompositeData(ThreadInfo ti) {
73 ThreadInfoCompositeData ticd = new ThreadInfoCompositeData(ti);
74 return ticd.getCompositeData();
75 }
76
77 protected CompositeData getCompositeData() {
78 // Convert StackTraceElement[] to CompositeData[]
79 StackTraceElement[] stackTrace = threadInfo.getStackTrace();
80 CompositeData[] stackTraceData =
81 new CompositeData[stackTrace.length];
82 for (int i = 0; i < stackTrace.length; i++) {
83 StackTraceElement ste = stackTrace[i];
84 stackTraceData[i] = StackTraceElementCompositeData.toCompositeData(ste);
85 }
86
87 // Convert MonitorInfo[] and LockInfo[] to CompositeData[]
88 LockDataConverter converter = new LockDataConverter(threadInfo);
89 CompositeData lockInfoData = converter.toLockInfoCompositeData();
90 CompositeData[] lockedSyncsData = converter.toLockedSynchronizersCompositeData();
91
92 // Convert MonitorInfo[] to CompositeData[]
93 MonitorInfo[] lockedMonitors = threadInfo.getLockedMonitors();
94 CompositeData[] lockedMonitorsData =
95 new CompositeData[lockedMonitors.length];
96 for (int i = 0; i < lockedMonitors.length; i++) {
97 MonitorInfo mi = lockedMonitors[i];
98 lockedMonitorsData[i] = MonitorInfoCompositeData.toCompositeData(mi);
99 }
100
101
102 // CONTENTS OF THIS ARRAY MUST BE SYNCHRONIZED WITH
103 // threadInfoItemNames!
104 final Object[] threadInfoItemValues = {
105 new Long(threadInfo.getThreadId()),
106 threadInfo.getThreadName(),
107 threadInfo.getThreadState().name(),
108 new Long(threadInfo.getBlockedTime()),
109 new Long(threadInfo.getBlockedCount()),
110 new Long(threadInfo.getWaitedTime()),
111 new Long(threadInfo.getWaitedCount()),
112 lockInfoData,
113 threadInfo.getLockName(),
114 new Long(threadInfo.getLockOwnerId()),
115 threadInfo.getLockOwnerName(),
116 stackTraceData,
117 new Boolean(threadInfo.isSuspended()),
118 new Boolean(threadInfo.isInNative()),
119 lockedMonitorsData,
120 lockedSyncsData,
121 };
122
123 try {
124 return new CompositeDataSupport(threadInfoCompositeType,
125 threadInfoItemNames,
126 threadInfoItemValues);
127 } catch (OpenDataException e) {
128 // Should never reach here
129 throw new AssertionError(e);
130 }
131 }
132
133 // Attribute names
134 private static final String THREAD_ID = "threadId";
135 private static final String THREAD_NAME = "threadName";
136 private static final String THREAD_STATE = "threadState";
137 private static final String BLOCKED_TIME = "blockedTime";
138 private static final String BLOCKED_COUNT = "blockedCount";
139 private static final String WAITED_TIME = "waitedTime";
140 private static final String WAITED_COUNT = "waitedCount";
141 private static final String LOCK_INFO = "lockInfo";
142 private static final String LOCK_NAME = "lockName";
143 private static final String LOCK_OWNER_ID = "lockOwnerId";
144 private static final String LOCK_OWNER_NAME = "lockOwnerName";
145 private static final String STACK_TRACE = "stackTrace";
146 private static final String SUSPENDED = "suspended";
147 private static final String IN_NATIVE = "inNative";
148 private static final String LOCKED_MONITORS = "lockedMonitors";
149 private static final String LOCKED_SYNCS = "lockedSynchronizers";
150
151 private static final String[] threadInfoItemNames = {
152 THREAD_ID,
153 THREAD_NAME,
154 THREAD_STATE,
155 BLOCKED_TIME,
156 BLOCKED_COUNT,
157 WAITED_TIME,
158 WAITED_COUNT,
159 LOCK_INFO,
160 LOCK_NAME,
161 LOCK_OWNER_ID,
162 LOCK_OWNER_NAME,
163 STACK_TRACE,
164 SUSPENDED,
165 IN_NATIVE,
166 LOCKED_MONITORS,
167 LOCKED_SYNCS,
168 };
169
170 // New attributes added in 6.0 ThreadInfo
171 private static final String[] threadInfoV6Attributes = {
172 LOCK_INFO,
173 LOCKED_MONITORS,
174 LOCKED_SYNCS,
175 };
176
177 // Current version of ThreadInfo
178 private static final CompositeType threadInfoCompositeType;
179 // Previous version of ThreadInfo
180 private static final CompositeType threadInfoV5CompositeType;
181 private static final CompositeType lockInfoCompositeType;
182 static {
183 try {
184 threadInfoCompositeType = (CompositeType)
185 MappedMXBeanType.toOpenType(ThreadInfo.class);
186 // Form a CompositeType for JDK 5.0 ThreadInfo version
187 String[] itemNames =
188 threadInfoCompositeType.keySet().toArray(new String[0]);
189 int numV5Attributes = threadInfoItemNames.length -
190 threadInfoV6Attributes.length;
191 String[] v5ItemNames = new String[numV5Attributes];
192 String[] v5ItemDescs = new String[numV5Attributes];
193 OpenType[] v5ItemTypes = new OpenType[numV5Attributes];
194 int i = 0;
195 for (String n : itemNames) {
196 if (isV5Attribute(n)) {
197 v5ItemNames[i] = n;
198 v5ItemDescs[i] = threadInfoCompositeType.getDescription(n);
199 v5ItemTypes[i] = threadInfoCompositeType.getType(n);
200 i++;
201 }
202 }
203
204 threadInfoV5CompositeType =
205 new CompositeType("java.lang.management.ThreadInfo",
206 "J2SE 5.0 java.lang.management.ThreadInfo",
207 v5ItemNames,
208 v5ItemDescs,
209 v5ItemTypes);
210 } catch (OpenDataException e) {
211 // Should never reach here
212 throw new AssertionError(e);
213 }
214
215 // Each CompositeData object has its CompositeType associated
216 // with it. So we can get the CompositeType representing LockInfo
217 // from a mapped CompositeData for any LockInfo object.
218 // Thus we construct a random LockInfo object and pass it
219 // to LockDataConverter to do the conversion.
220 Object o = new Object();
221 LockInfo li = new LockInfo(o.getClass().getName(),
222 System.identityHashCode(o));
223 CompositeData cd = LockDataConverter.toLockInfoCompositeData(li);
224 lockInfoCompositeType = cd.getCompositeType();
225 }
226
227 private static boolean isV5Attribute(String itemName) {
228 for (String n : threadInfoV6Attributes) {
229 if (itemName.equals(n)) {
230 return false;
231 }
232 }
233 return true;
234 }
235
236 public static boolean isCurrentVersion(CompositeData cd) {
237 if (cd == null) {
238 throw new NullPointerException("Null CompositeData");
239 }
240
241 return isTypeMatched(threadInfoCompositeType, cd.getCompositeType());
242 }
243
244 public long threadId() {
245 return getLong(cdata, THREAD_ID);
246 }
247
248 public String threadName() {
249 // The ThreadName item cannot be null so we check that
250 // it is present with a non-null value.
251 String name = getString(cdata, THREAD_NAME);
252 if (name == null) {
253 throw new IllegalArgumentException("Invalid composite data: " +
254 "Attribute " + THREAD_NAME + " has null value");
255 }
256 return name;
257 }
258
259 public Thread.State threadState() {
260 return Thread.State.valueOf(getString(cdata, THREAD_STATE));
261 }
262
263 public long blockedTime() {
264 return getLong(cdata, BLOCKED_TIME);
265 }
266
267 public long blockedCount() {
268 return getLong(cdata, BLOCKED_COUNT);
269 }
270
271 public long waitedTime() {
272 return getLong(cdata, WAITED_TIME);
273 }
274
275 public long waitedCount() {
276 return getLong(cdata, WAITED_COUNT);
277 }
278
279 public String lockName() {
280 // The LockName and LockOwnerName can legitimately be null,
281 // we don't bother to check the value
282 return getString(cdata, LOCK_NAME);
283 }
284
285 public long lockOwnerId() {
286 return getLong(cdata, LOCK_OWNER_ID);
287 }
288
289 public String lockOwnerName() {
290 return getString(cdata, LOCK_OWNER_NAME);
291 }
292
293 public boolean suspended() {
294 return getBoolean(cdata, SUSPENDED);
295 }
296
297 public boolean inNative() {
298 return getBoolean(cdata, IN_NATIVE);
299 }
300
301 public StackTraceElement[] stackTrace() {
302 CompositeData[] stackTraceData =
303 (CompositeData[]) cdata.get(STACK_TRACE);
304
305 // The StackTrace item cannot be null, but if it is we will get
306 // a NullPointerException when we ask for its length.
307 StackTraceElement[] stackTrace =
308 new StackTraceElement[stackTraceData.length];
309 for (int i = 0; i < stackTraceData.length; i++) {
310 CompositeData cdi = stackTraceData[i];
311 stackTrace[i] = StackTraceElementCompositeData.from(cdi);
312 }
313 return stackTrace;
314 }
315
316 // 6.0 new attributes
317 public LockInfo lockInfo() {
318 LockDataConverter converter = new LockDataConverter();
319 CompositeData lockInfoData = (CompositeData) cdata.get(LOCK_INFO);
320 return converter.toLockInfo(lockInfoData);
321 }
322
323 public MonitorInfo[] lockedMonitors() {
324 CompositeData[] lockedMonitorsData =
325 (CompositeData[]) cdata.get(LOCKED_MONITORS);
326
327 // The LockedMonitors item cannot be null, but if it is we will get
328 // a NullPointerException when we ask for its length.
329 MonitorInfo[] monitors =
330 new MonitorInfo[lockedMonitorsData.length];
331 for (int i = 0; i < lockedMonitorsData.length; i++) {
332 CompositeData cdi = lockedMonitorsData[i];
333 monitors[i] = MonitorInfo.from(cdi);
334 }
335 return monitors;
336 }
337
338 public LockInfo[] lockedSynchronizers() {
339 LockDataConverter converter = new LockDataConverter();
340 CompositeData[] lockedSyncsData =
341 (CompositeData[]) cdata.get(LOCKED_SYNCS);
342
343 // The LockedSynchronizers item cannot be null, but if it is we will
344 // get a NullPointerException when we ask for its length.
345 return converter.toLockedSynchronizers(lockedSyncsData);
346 }
347
348 /** Validate if the input CompositeData has the expected
349 * CompositeType (i.e. contain all attributes with expected
350 * names and types).
351 */
352 public static void validateCompositeData(CompositeData cd) {
353 if (cd == null) {
354 throw new NullPointerException("Null CompositeData");
355 }
356
357 CompositeType type = cd.getCompositeType();
358 boolean currentVersion = true;
359 if (!isTypeMatched(threadInfoCompositeType, type)) {
360 currentVersion = false;
361 // check if cd is an older version
362 if (!isTypeMatched(threadInfoV5CompositeType, type)) {
363 throw new IllegalArgumentException(
364 "Unexpected composite type for ThreadInfo");
365 }
366 }
367
368 CompositeData[] stackTraceData =
369 (CompositeData[]) cd.get(STACK_TRACE);
370 if (stackTraceData == null) {
371 throw new IllegalArgumentException(
372 "StackTraceElement[] is missing");
373 }
374 if (stackTraceData.length > 0) {
375 StackTraceElementCompositeData.validateCompositeData(stackTraceData[0]);
376 }
377
378 // validate v6 attributes
379 if (currentVersion) {
380 CompositeData li = (CompositeData) cd.get(LOCK_INFO);
381 if (li != null) {
382 if (!isTypeMatched(lockInfoCompositeType,
383 li.getCompositeType())) {
384 throw new IllegalArgumentException(
385 "Unexpected composite type for \"" +
386 LOCK_INFO + "\" attribute.");
387 }
388 }
389
390 CompositeData[] lms = (CompositeData[]) cd.get(LOCKED_MONITORS);
391 if (lms == null) {
392 throw new IllegalArgumentException("MonitorInfo[] is null");
393 }
394 if (lms.length > 0) {
395 MonitorInfoCompositeData.validateCompositeData(lms[0]);
396 }
397
398 CompositeData[] lsyncs = (CompositeData[]) cd.get(LOCKED_SYNCS);
399 if (lsyncs == null) {
400 throw new IllegalArgumentException("LockInfo[] is null");
401 }
402 if (lsyncs.length > 0) {
403 if (!isTypeMatched(lockInfoCompositeType,
404 lsyncs[0].getCompositeType())) {
405 throw new IllegalArgumentException(
406 "Unexpected composite type for \"" +
407 LOCKED_SYNCS + "\" attribute.");
408 }
409 }
410
411 }
412 }
413
414 private static final long serialVersionUID = 2464378539119753175L;
415}