1 files changed, 350 insertions, 0 deletions
diff --git a/libjava/classpath/gnu/java/lang/management/ThreadMXBeanImpl.java b/libjava/classpath/gnu/java/lang/management/ThreadMXBeanImpl.java
new file mode 100644
index 000000000..97040997b
--- /dev/null
+++ b/libjava/classpath/gnu/java/lang/management/ThreadMXBeanImpl.java
@@ -0,0 +1,350 @@
+/* ThreadMXBeanImpl.java - Implementation of a thread bean
+   Copyright (C) 2006 Free Software Foundation
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath 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 for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package gnu.java.lang.management;
+
+import gnu.classpath.SystemProperties;
+
+import java.lang.management.ThreadInfo;
+import java.lang.management.ThreadMXBean;
+
+import javax.management.NotCompliantMBeanException;
+
+/**
+ * Provides access to information about the threads
+ * of the virtual machine.  An instance of this bean is
+ * obtained by calling
+ * {@link ManagementFactory#getThreadMXBean()}.
+ * See {@link java.lang.management.ThreadMXBean} for
+ * full documentation.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+public final class ThreadMXBeanImpl
+  extends BeanImpl
+  implements ThreadMXBean
+{
+
+  /**
+   * Constant for current thread time support.
+   */
+  private static final String CURRENT_THREAD_TIME_SUPPORT =
+    "gnu.java.lang.management.CurrentThreadTimeSupport";
+
+  /**
+   * Constant for thread time support.
+   */
+  private static final String THREAD_TIME_SUPPORT =
+    "gnu.java.lang.management.ThreadTimeSupport";
+
+  /**
+   * Constant for thread contention support.
+   */
+  private static final String CONTENTION_SUPPORT =
+    "gnu.java.lang.management.ThreadContentionSupport";
+
+  /**
+   * Constant for initial value of thread time support.
+   */
+  private static final String TIME_ENABLED =
+    "gnu.java.lang.management.ThreadTimeInitallyEnabled";
+
+  /**
+   * Constant for monitor usage monitoring support.
+   */
+  private static final String MONITOR_SUPPORT =
+    "gnu.java.lang.management.MonitorUsageMonitoringSupport";
+
+  /**
+   * Constant for ownable synchronizer usage monitoring support.
+   */
+  private static final String SYNCHRONIZER_SUPPORT =
+    "gnu.java.lang.management.OwnableSynchronizerUsageMonitoringSupport";
+
+  /**
+   * Flag to indicate whether time monitoring is enabled or not.
+   */
+  private boolean timeEnabled;
+
+  /**
+   * Flag to indicate whether contention monitoring is enabled or not.
+   */
+  private boolean contentionEnabled;
+
+  /**
+   * Default constructor to set up flag states.  The
+   * VM has to specify whether time monitoring is initially
+   * enabled or not.
+   *
+   * @throws NotCompliantMBeanException if this class doesn't implement
+   *                                    the interface or a method appears
+   *                                    in the interface that doesn't comply
+   *                                    with the naming conventions.
+   */
+  public ThreadMXBeanImpl()
+    throws NotCompliantMBeanException
+  {
+    super(ThreadMXBean.class);
+    timeEnabled = Boolean.parseBoolean(SystemProperties.getProperty(TIME_ENABLED));
+    contentionEnabled = false;
+  }
+
+  public ThreadInfo[] dumpAllThreads(boolean lockedMonitors,
+                                     boolean lockedSynchronizers)
+  {
+    return getThreadInfo(getAllThreadIds(), lockedMonitors,
+                         lockedSynchronizers);
+  }
+
+  public long[] findDeadlockedThreads()
+  {
+    checkMonitorPermissions();
+    if (!isSynchronizerUsageSupported())
+      throw new UnsupportedOperationException("Ownable synchronizer usage " +
+                                              "monitoring is not provided " +
+                                              "by this VM.");
+    return VMThreadMXBeanImpl.findDeadlockedThreads();
+  }
+
+  public long[] findMonitorDeadlockedThreads()
+  {
+    checkMonitorPermissions();
+    return VMThreadMXBeanImpl.findMonitorDeadlockedThreads();
+  }
+
+  public long[] getAllThreadIds()
+  {
+    checkMonitorPermissions();
+    return VMThreadMXBeanImpl.getAllThreadIds();
+  }
+
+  public long getCurrentThreadCpuTime()
+  {
+    if (!isCurrentThreadCpuTimeSupported())
+      throw new UnsupportedOperationException("Current thread CPU " +
+                                              "time not supported.");
+    if (!timeEnabled)
+      return -1;
+    return VMThreadMXBeanImpl.getCurrentThreadCpuTime();
+  }
+
+  public long getCurrentThreadUserTime()
+  {
+    if (!isCurrentThreadCpuTimeSupported())
+      throw new UnsupportedOperationException("Current thread user " +
+                                              "time not supported.");
+    if (!timeEnabled)
+      return -1;
+    return VMThreadMXBeanImpl.getCurrentThreadUserTime();
+  }
+
+  public int getDaemonThreadCount()
+  {
+    return VMThreadMXBeanImpl.getDaemonThreadCount();
+  }
+
+  public int getPeakThreadCount()
+  {
+    return VMThreadMXBeanImpl.getPeakThreadCount();
+  }
+
+  public int getThreadCount()
+  {
+    return VMThreadMXBeanImpl.getThreadCount();
+  }
+
+  public long getThreadCpuTime(long id)
+  {
+    if (!isThreadCpuTimeSupported())
+      throw new UnsupportedOperationException("Thread CPU time not " +
+                                              "supported.");
+    if (id <= 0)
+      throw new IllegalArgumentException("Invalid thread id: " + id);
+    if (!timeEnabled)
+      return -1;
+    return VMThreadMXBeanImpl.getThreadCpuTime(id);
+  }
+
+  public ThreadInfo getThreadInfo(long id)
+  {
+    return getThreadInfo(id, 0);
+  }
+
+  public ThreadInfo[] getThreadInfo(long[] ids)
+  {
+    return getThreadInfo(ids, 0);
+  }
+
+  public ThreadInfo getThreadInfo(long id, int maxDepth)
+  {
+    checkMonitorPermissions();
+    if (id <= 0)
+      throw new IllegalArgumentException("Invalid thread id: " + id);
+    if (maxDepth < 0)
+      throw new IllegalArgumentException("Invalid depth: " + maxDepth);
+    return VMThreadMXBeanImpl.getThreadInfoForId(id, maxDepth);
+  }
+
+  public ThreadInfo[] getThreadInfo(long[] ids, int maxDepth)
+  {
+    checkMonitorPermissions();
+    if (maxDepth < 0)
+      throw new IllegalArgumentException("Invalid depth: " + maxDepth);
+    ThreadInfo[] infos = new ThreadInfo[ids.length];
+    for (int a = 0; a < ids.length; ++a)
+      {
+        if (ids[a] <= 0)
+          throw new IllegalArgumentException("Invalid thread id " + a +
+                                             ": " + ids[a]);
+        infos[a] = VMThreadMXBeanImpl.getThreadInfoForId(ids[a], maxDepth);
+      }
+    return infos;
+  }
+
+  public ThreadInfo[] getThreadInfo(long[] ids, boolean lockedMonitors,
+                                    boolean lockedSynchronizers)
+  {
+    checkMonitorPermissions();
+    if (lockedMonitors && !isObjectMonitorUsageSupported())
+      throw new UnsupportedOperationException("Monitor usage monitoring is " +
+                                              "not provided by this VM.");
+    if (lockedSynchronizers && !isSynchronizerUsageSupported())
+      throw new UnsupportedOperationException("Ownable synchronizer usage " +
+                                              "monitoring is not provided " +
+                                              "by this VM.");
+    ThreadInfo[] infos = getThreadInfo(ids, Integer.MAX_VALUE);
+    if (lockedMonitors)
+      for (ThreadInfo info : infos)
+        VMThreadMXBeanImpl.getMonitorInfo(info);
+    if (lockedSynchronizers)
+      for (ThreadInfo info : infos)
+        VMThreadMXBeanImpl.getLockInfo(info);
+    return infos;
+  }
+
+  public long getThreadUserTime(long id)
+  {
+    if (!isThreadCpuTimeSupported())
+      throw new UnsupportedOperationException("Thread user time not " +
+                                              "supported.");
+    if (id <= 0)
+      throw new IllegalArgumentException("Invalid thread id: " + id);
+    if (!timeEnabled)
+      return -1;
+    return VMThreadMXBeanImpl.getThreadUserTime(id);
+  }
+
+  public long getTotalStartedThreadCount()
+  {
+    return VMThreadMXBeanImpl.getTotalStartedThreadCount();
+  }
+
+  public boolean isCurrentThreadCpuTimeSupported()
+  {
+    if (isThreadCpuTimeSupported())
+      return true;
+    return SystemProperties.getProperty(CURRENT_THREAD_TIME_SUPPORT) != null;
+  }
+
+  public boolean isObjectMonitorUsageSupported()
+  {
+    return SystemProperties.getProperty(MONITOR_SUPPORT) != null;
+  }
+
+  public boolean isSynchronizerUsageSupported()
+  {
+    return SystemProperties.getProperty(SYNCHRONIZER_SUPPORT) != null;
+  }
+
+  public boolean isThreadContentionMonitoringEnabled()
+  {
+    if (isThreadContentionMonitoringSupported())
+      return contentionEnabled;
+    else
+      throw new UnsupportedOperationException("Contention monitoring " +
+                                              "not supported.");
+  }
+
+  public boolean isThreadContentionMonitoringSupported()
+  {
+    return SystemProperties.getProperty(CONTENTION_SUPPORT) != null;
+  }
+
+  public boolean isThreadCpuTimeEnabled()
+  {
+    if (isThreadCpuTimeSupported() ||
+        isCurrentThreadCpuTimeSupported())
+      return timeEnabled;
+    else
+      throw new UnsupportedOperationException("Thread time not " +
+                                              "supported.");
+  }
+
+  public boolean isThreadCpuTimeSupported()
+  {
+    return SystemProperties.getProperty(THREAD_TIME_SUPPORT) != null;
+  }
+
+  public void resetPeakThreadCount()
+  {
+    checkControlPermissions();
+    VMThreadMXBeanImpl.resetPeakThreadCount();
+  }
+
+  public void setThreadContentionMonitoringEnabled(boolean enable)
+  {
+    checkControlPermissions();
+    if (isThreadContentionMonitoringSupported())
+      contentionEnabled = enable;
+    else
+      throw new UnsupportedOperationException("Contention monitoring " +
+                                              "not supported.");
+  }
+
+  public void setThreadCpuTimeEnabled(boolean enable)
+  {
+    checkControlPermissions();
+    if (isThreadCpuTimeSupported() ||
+        isCurrentThreadCpuTimeSupported())
+      timeEnabled = enable;
+    else
+      throw new UnsupportedOperationException("Thread time not " +
+                                              "supported.");
+  }
+
+}