Subversion Repositories openrisc

/* 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.");

  }

}