| /* |
| * Copyright (c) 2004, 2012, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package sun.management; |
| |
| import java.lang.management.ThreadInfo; |
| import java.lang.management.MonitorInfo; |
| import java.lang.management.LockInfo; |
| import javax.management.openmbean.CompositeType; |
| import javax.management.openmbean.CompositeData; |
| import javax.management.openmbean.CompositeDataSupport; |
| import javax.management.openmbean.OpenDataException; |
| |
| /** |
| * A CompositeData for ThreadInfo for the local management support. |
| * This class avoids the performance penalty paid to the |
| * construction of a CompositeData use in the local case. |
| */ |
| public class ThreadInfoCompositeData extends LazyCompositeData { |
| private final ThreadInfo threadInfo; |
| private final CompositeData cdata; |
| private final boolean currentVersion; |
| private final boolean hasV6; |
| |
| private ThreadInfoCompositeData(ThreadInfo ti) { |
| this.threadInfo = ti; |
| this.currentVersion = true; |
| this.cdata = null; |
| this.hasV6 = true; |
| } |
| |
| private ThreadInfoCompositeData(CompositeData cd) { |
| this.threadInfo = null; |
| this.currentVersion = ThreadInfoCompositeData.isCurrentVersion(cd); |
| this.cdata = cd; |
| this.hasV6 = ThreadInfoCompositeData.hasV6(cd); |
| } |
| |
| public ThreadInfo getThreadInfo() { |
| return threadInfo; |
| } |
| |
| public boolean hasV6() { |
| return hasV6; |
| } |
| |
| public boolean isCurrentVersion() { |
| return currentVersion; |
| } |
| |
| public static ThreadInfoCompositeData getInstance(CompositeData cd) { |
| validateCompositeData(cd); |
| return new ThreadInfoCompositeData(cd); |
| } |
| |
| public static CompositeData toCompositeData(ThreadInfo ti) { |
| ThreadInfoCompositeData ticd = new ThreadInfoCompositeData(ti); |
| return ticd.getCompositeData(); |
| } |
| |
| protected CompositeData getCompositeData() { |
| // Convert StackTraceElement[] to CompositeData[] |
| StackTraceElement[] stackTrace = threadInfo.getStackTrace(); |
| CompositeData[] stackTraceData = |
| new CompositeData[stackTrace.length]; |
| for (int i = 0; i < stackTrace.length; i++) { |
| StackTraceElement ste = stackTrace[i]; |
| stackTraceData[i] = StackTraceElementCompositeData.toCompositeData(ste); |
| } |
| |
| // Convert MonitorInfo[] and LockInfo[] to CompositeData[] |
| CompositeData lockInfoData = |
| LockInfoCompositeData.toCompositeData(threadInfo.getLockInfo()); |
| |
| // Convert LockInfo[] and MonitorInfo[] to CompositeData[] |
| LockInfo[] lockedSyncs = threadInfo.getLockedSynchronizers(); |
| CompositeData[] lockedSyncsData = |
| new CompositeData[lockedSyncs.length]; |
| for (int i = 0; i < lockedSyncs.length; i++) { |
| LockInfo li = lockedSyncs[i]; |
| lockedSyncsData[i] = LockInfoCompositeData.toCompositeData(li); |
| } |
| |
| MonitorInfo[] lockedMonitors = threadInfo.getLockedMonitors(); |
| CompositeData[] lockedMonitorsData = |
| new CompositeData[lockedMonitors.length]; |
| for (int i = 0; i < lockedMonitors.length; i++) { |
| MonitorInfo mi = lockedMonitors[i]; |
| lockedMonitorsData[i] = MonitorInfoCompositeData.toCompositeData(mi); |
| } |
| |
| // CONTENTS OF THIS ARRAY MUST BE SYNCHRONIZED WITH |
| // threadInfoItemNames! |
| final Object[] threadInfoItemValues = { |
| threadInfo.getThreadId(), |
| threadInfo.getThreadName(), |
| threadInfo.getThreadState().name(), |
| threadInfo.getBlockedTime(), |
| threadInfo.getBlockedCount(), |
| threadInfo.getWaitedTime(), |
| threadInfo.getWaitedCount(), |
| lockInfoData, |
| threadInfo.getLockName(), |
| threadInfo.getLockOwnerId(), |
| threadInfo.getLockOwnerName(), |
| stackTraceData, |
| threadInfo.isSuspended(), |
| threadInfo.isInNative(), |
| lockedMonitorsData, |
| lockedSyncsData, |
| threadInfo.isDaemon(), |
| threadInfo.getPriority(), |
| }; |
| |
| try { |
| return new CompositeDataSupport(threadInfoCompositeType, |
| threadInfoItemNames, |
| threadInfoItemValues); |
| } catch (OpenDataException e) { |
| // Should never reach here |
| throw new AssertionError(e); |
| } |
| } |
| |
| // Attribute names |
| private static final String THREAD_ID = "threadId"; |
| private static final String THREAD_NAME = "threadName"; |
| private static final String THREAD_STATE = "threadState"; |
| private static final String BLOCKED_TIME = "blockedTime"; |
| private static final String BLOCKED_COUNT = "blockedCount"; |
| private static final String WAITED_TIME = "waitedTime"; |
| private static final String WAITED_COUNT = "waitedCount"; |
| private static final String LOCK_INFO = "lockInfo"; |
| private static final String LOCK_NAME = "lockName"; |
| private static final String LOCK_OWNER_ID = "lockOwnerId"; |
| private static final String LOCK_OWNER_NAME = "lockOwnerName"; |
| private static final String STACK_TRACE = "stackTrace"; |
| private static final String SUSPENDED = "suspended"; |
| private static final String IN_NATIVE = "inNative"; |
| private static final String DAEMON = "daemon"; |
| private static final String PRIORITY = "priority"; |
| private static final String LOCKED_MONITORS = "lockedMonitors"; |
| private static final String LOCKED_SYNCS = "lockedSynchronizers"; |
| |
| private static final String[] threadInfoItemNames = { |
| THREAD_ID, |
| THREAD_NAME, |
| THREAD_STATE, |
| BLOCKED_TIME, |
| BLOCKED_COUNT, |
| WAITED_TIME, |
| WAITED_COUNT, |
| LOCK_INFO, |
| LOCK_NAME, |
| LOCK_OWNER_ID, |
| LOCK_OWNER_NAME, |
| STACK_TRACE, |
| SUSPENDED, |
| IN_NATIVE, |
| LOCKED_MONITORS, |
| LOCKED_SYNCS, |
| DAEMON, |
| PRIORITY, |
| }; |
| |
| // New attributes added in 6.0 ThreadInfo |
| private static final String[] threadInfoV6Attributes = { |
| LOCK_INFO, |
| LOCKED_MONITORS, |
| LOCKED_SYNCS, |
| }; |
| |
| private static final String[] threadInfoV9Attributes = { |
| DAEMON, |
| PRIORITY, |
| }; |
| |
| // Current version of ThreadInfo |
| private static final CompositeType threadInfoCompositeType; |
| // Previous version of ThreadInfo |
| private static final CompositeType threadInfoV6CompositeType; |
| // Previous-previous version of ThreadInfo |
| private static final CompositeType threadInfoV5CompositeType; |
| private static final CompositeType lockInfoCompositeType; |
| static { |
| try { |
| threadInfoCompositeType = (CompositeType) |
| MappedMXBeanType.toOpenType(ThreadInfo.class); |
| // Form a CompositeType for JDK 5.0 ThreadInfo version |
| |
| threadInfoV5CompositeType = |
| TypeVersionMapper.getInstance().getVersionedCompositeType( |
| threadInfoCompositeType, TypeVersionMapper.V5 |
| ); |
| |
| threadInfoV6CompositeType = |
| TypeVersionMapper.getInstance().getVersionedCompositeType( |
| threadInfoCompositeType, TypeVersionMapper.V6 |
| ); |
| } catch (OpenDataException e) { |
| // Should never reach here |
| throw new AssertionError(e); |
| } |
| |
| // Each CompositeData object has its CompositeType associated |
| // with it. So we can get the CompositeType representing LockInfo |
| // from a mapped CompositeData for any LockInfo object. |
| // Thus we construct a random LockInfo object and pass it |
| // to LockInfoCompositeData to do the conversion. |
| Object o = new Object(); |
| LockInfo li = new LockInfo(o.getClass().getName(), |
| System.identityHashCode(o)); |
| CompositeData cd = LockInfoCompositeData.toCompositeData(li); |
| lockInfoCompositeType = cd.getCompositeType(); |
| } |
| |
| static boolean isV5Attribute(String itemName) { |
| for (String n : threadInfoV6Attributes) { |
| if (itemName.equals(n)) { |
| return false; |
| } |
| } |
| for (String n : threadInfoV9Attributes) { |
| if (itemName.equals(n)) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| static boolean isV6Attribute(String itemName) { |
| for (String n : threadInfoV9Attributes) { |
| if (itemName.equals(n)) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| public static boolean isCurrentVersion(CompositeData cd) { |
| if (cd == null) { |
| throw new NullPointerException("Null CompositeData"); |
| } |
| |
| return isTypeMatched(threadInfoCompositeType, cd.getCompositeType()); |
| } |
| |
| private static boolean hasV6(CompositeData cd) { |
| if (cd == null) { |
| throw new NullPointerException("Null CompositeData"); |
| } |
| |
| return isTypeMatched(threadInfoCompositeType, cd.getCompositeType()) || |
| isTypeMatched(threadInfoV6CompositeType, cd.getCompositeType()); |
| } |
| |
| public long threadId() { |
| return getLong(cdata, THREAD_ID); |
| } |
| |
| public String threadName() { |
| // The ThreadName item cannot be null so we check that |
| // it is present with a non-null value. |
| String name = getString(cdata, THREAD_NAME); |
| if (name == null) { |
| throw new IllegalArgumentException("Invalid composite data: " + |
| "Attribute " + THREAD_NAME + " has null value"); |
| } |
| return name; |
| } |
| |
| public Thread.State threadState() { |
| return Thread.State.valueOf(getString(cdata, THREAD_STATE)); |
| } |
| |
| public long blockedTime() { |
| return getLong(cdata, BLOCKED_TIME); |
| } |
| |
| public long blockedCount() { |
| return getLong(cdata, BLOCKED_COUNT); |
| } |
| |
| public long waitedTime() { |
| return getLong(cdata, WAITED_TIME); |
| } |
| |
| public long waitedCount() { |
| return getLong(cdata, WAITED_COUNT); |
| } |
| |
| public String lockName() { |
| // The LockName and LockOwnerName can legitimately be null, |
| // we don't bother to check the value |
| return getString(cdata, LOCK_NAME); |
| } |
| |
| public long lockOwnerId() { |
| return getLong(cdata, LOCK_OWNER_ID); |
| } |
| |
| public String lockOwnerName() { |
| return getString(cdata, LOCK_OWNER_NAME); |
| } |
| |
| public boolean suspended() { |
| return getBoolean(cdata, SUSPENDED); |
| } |
| |
| public boolean inNative() { |
| return getBoolean(cdata, IN_NATIVE); |
| } |
| |
| public boolean isDaemon() { |
| return getBoolean(cdata, DAEMON); |
| } |
| |
| public int getPriority(){ |
| return getInt(cdata, PRIORITY); |
| } |
| |
| public StackTraceElement[] stackTrace() { |
| CompositeData[] stackTraceData = |
| (CompositeData[]) cdata.get(STACK_TRACE); |
| |
| // The StackTrace item cannot be null, but if it is we will get |
| // a NullPointerException when we ask for its length. |
| StackTraceElement[] stackTrace = |
| new StackTraceElement[stackTraceData.length]; |
| for (int i = 0; i < stackTraceData.length; i++) { |
| CompositeData cdi = stackTraceData[i]; |
| stackTrace[i] = StackTraceElementCompositeData.from(cdi); |
| } |
| return stackTrace; |
| } |
| |
| // 6.0 new attributes |
| public LockInfo lockInfo() { |
| CompositeData lockInfoData = (CompositeData) cdata.get(LOCK_INFO); |
| return LockInfo.from(lockInfoData); |
| } |
| |
| public MonitorInfo[] lockedMonitors() { |
| CompositeData[] lockedMonitorsData = |
| (CompositeData[]) cdata.get(LOCKED_MONITORS); |
| |
| // The LockedMonitors item cannot be null, but if it is we will get |
| // a NullPointerException when we ask for its length. |
| MonitorInfo[] monitors = |
| new MonitorInfo[lockedMonitorsData.length]; |
| for (int i = 0; i < lockedMonitorsData.length; i++) { |
| CompositeData cdi = lockedMonitorsData[i]; |
| monitors[i] = MonitorInfo.from(cdi); |
| } |
| return monitors; |
| } |
| |
| public LockInfo[] lockedSynchronizers() { |
| CompositeData[] lockedSyncsData = |
| (CompositeData[]) cdata.get(LOCKED_SYNCS); |
| |
| // The LockedSynchronizers item cannot be null, but if it is we will |
| // get a NullPointerException when we ask for its length. |
| LockInfo[] locks = new LockInfo[lockedSyncsData.length]; |
| for (int i = 0; i < lockedSyncsData.length; i++) { |
| CompositeData cdi = lockedSyncsData[i]; |
| locks[i] = LockInfo.from(cdi); |
| } |
| return locks; |
| } |
| |
| /** Validate if the input CompositeData has the expected |
| * CompositeType (i.e. contain all attributes with expected |
| * names and types). |
| */ |
| public static void validateCompositeData(CompositeData cd) { |
| if (cd == null) { |
| throw new NullPointerException("Null CompositeData"); |
| } |
| |
| CompositeType type = cd.getCompositeType(); |
| boolean currentVersion = true; |
| if (!isTypeMatched(threadInfoCompositeType, type)) { |
| currentVersion = false; |
| // check if cd is an older version |
| if (!isTypeMatched(threadInfoV5CompositeType, type) && |
| !isTypeMatched(threadInfoV6CompositeType, type)) { |
| throw new IllegalArgumentException( |
| "Unexpected composite type for ThreadInfo"); |
| } |
| } |
| |
| CompositeData[] stackTraceData = |
| (CompositeData[]) cd.get(STACK_TRACE); |
| if (stackTraceData == null) { |
| throw new IllegalArgumentException( |
| "StackTraceElement[] is missing"); |
| } |
| if (stackTraceData.length > 0) { |
| StackTraceElementCompositeData.validateCompositeData(stackTraceData[0]); |
| } |
| |
| // validate v6 attributes |
| if (currentVersion) { |
| CompositeData li = (CompositeData) cd.get(LOCK_INFO); |
| if (li != null) { |
| if (!isTypeMatched(lockInfoCompositeType, |
| li.getCompositeType())) { |
| throw new IllegalArgumentException( |
| "Unexpected composite type for \"" + |
| LOCK_INFO + "\" attribute."); |
| } |
| } |
| |
| CompositeData[] lms = (CompositeData[]) cd.get(LOCKED_MONITORS); |
| if (lms == null) { |
| throw new IllegalArgumentException("MonitorInfo[] is null"); |
| } |
| if (lms.length > 0) { |
| MonitorInfoCompositeData.validateCompositeData(lms[0]); |
| } |
| |
| CompositeData[] lsyncs = (CompositeData[]) cd.get(LOCKED_SYNCS); |
| if (lsyncs == null) { |
| throw new IllegalArgumentException("LockInfo[] is null"); |
| } |
| if (lsyncs.length > 0) { |
| if (!isTypeMatched(lockInfoCompositeType, |
| lsyncs[0].getCompositeType())) { |
| throw new IllegalArgumentException( |
| "Unexpected composite type for \"" + |
| LOCKED_SYNCS + "\" attribute."); |
| } |
| } |
| |
| } |
| } |
| |
| private static final long serialVersionUID = 2464378539119753175L; |
| } |