Overview | Package | Class | Use | Tree | Deprecated | Index | Help
|  | BEA Systems, Inc.
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## Type-Safe Access to BEA WebLogic Server 9.1 MBeans (Deprecated)
(Methods marked with @since 9.0.0.0 or later are not available through the deprecated `MBeanHome` interface.)

## weblogic.management.runtime
Interface JRockitRuntimeMBean

All Superinterfaces:
  DynamicMBean, JVMRuntimeMBean, MBeanRegistration, NotificationBroadcaster, weblogic.management.runtime.RuntimeMBean, weblogic.management.WebLogicMBean

public interface JRockitRuntimeMBean
extends JVMRuntimeMBean

Exposes runtime data about the JRockit Virtual Machine (VM) that is running the current WebLogic Server instance. You cannot change the VM's operating parameters while the VM is active. Instead, use the startup options that are described in the JRockit documentation.

### Deprecation of MBeanHome and Type-Safe Interfaces

This is a type-safe interface for a WebLogic Server MBean, which you can import into your client classes and access through `weblogic.management.MBeanHome`. As of 9.0, the `MBeanHome` interface and all type-safe interfaces for WebLogic Server MBeans are deprecated. Instead, client classes that interact with WebLogic Server MBeans should use standard JMX design patterns in which clients use the `javax.management.MBeanServerConnection` interface to discover MBeans, attributes, and attribute types at runtime. For more information, see "Developing Manageable Applications with JMX" on http://edocs.bea.com.

  Copyright © 2005 BEA Systems, Inc. All Rights Reserved.

Method Summary
`double` | `getAllProcessorsAverageLoad()` A snapshot of the average load of all processors in the host computer.
`long` | `getConstructorInvocationCount(Constructor constructor)` The number of times a constructor has been invoked since enabling invocation counting.
`long` | `getConstructorTiming(Constructor constructor)` The amount of time (in milliseconds) the Virtual Machine has spent in the constructor since enabling time measuring.
`long` | `getExceptionCount(Class throwableClass)` The number of times an exception type has been thrown since enabling exception counting.
`long` | `getFreeHeap()` The amount (in bytes) of Java heap memory that is currently free in the Virtual Machine.
`long` | `getFreePhysicalMemory()` The amount (in bytes) of physical memory that is currently free on the host computer.
`String` | `getGcAlgorithm()` The type of garbage collector (GC) that the Virtual Machine is using.
`String` | `getJVMDescription()` A description of the Java Virtual Machine.
`double` | `getJvmProcessorLoad()` A snapshot of the load that the Virtual Machine is placing on all processors in the host computer.
`long` | `getLastGCEnd()` The time at which the last garbage collection run ended.
`long` | `getLastGCStart()` The time at which the last garbage collection run started.
`long` | `getMethodInvocationCount(Method method)` The number of times a method has been invoked since enabling invocation counting.
`long` | `getMethodTiming(Method method)` The amount of time (in milliseconds) the Virtual Machine has spent in the method since enabling time measuring.
`String` | `getName()` The name of the Java Virtual Machine.
`int` | `getNumberOfDaemonThreads()` The number of daemon Java threads currently running in the Virtual Machine across all processors.
`int` | `getNumberOfProcessors()` The number of processors on the Virtual Machine's host computer.
`long` | `getTotalGarbageCollectionCount()` The number of garbage collection runs that have occurred since the Virtual Machine was started.
`long` | `getTotalGarbageCollectionTime()` The number of milliseconds that the Virtual Machine has spent on all garbage collection runs since the VM was started.
`long` | `getTotalHeap()` The amount (in bytes) of memory currently allocated to the Virtual Machine's Java heap.
`int` | `getTotalNumberOfThreads()` The number of Java threads (daemon and non-daemon) that are currently running in the Virtual Machine across all processors.
`long` | `getTotalNurserySize()` The amount (in bytes) of memory that is currently allocated to the nursery.
`long` | `getTotalPhysicalMemory()` The amount (in bytes) of physical memory on the host computer.
`long` | `getUsedHeap()` The amount (in bytes) of Java heap memory that is currently being used by the Virtual Machine.
`long` | `getUsedPhysicalMemory()` The amount (in bytes) of physical memory that is currently being used on the host computer.
`String` | `getVendor()` The name of the JVM vendor.
`String` | `getVersion()` The current version of Java Virtual Machine.
`boolean` | `isConcurrent()` Indicates whether the VM's garbage collector runs in a separate Java thread concurrently with other Java threads.
`boolean` | `isConstructorInvocationCountEnabled(Constructor cons)` Indicates whether the Virtual Machine counts how many times a constructor is invoked.
`boolean` | `isConstructorTimingEnabled(Constructor constructor)` Indicates whether the Virtual Machine measures how much time it spends in a constructor.
`boolean` | `isExceptionCountEnabled(Class throwableClass)` Indicates whether the Virtual Machine counts how many times an exception is thrown.
`boolean` | `isGCHandlesCompaction()` Indicates whether the VM's garbage collector compacts the Java heap.
`boolean` | `isGenerational()` Indicates whether the VM's garbage collector uses a nursery space.
`boolean` | `isIncremental()` Indicates whether the VM's garbage collector collects (increments) garbage as it scans the memory space and dumps the garbage at the end of its cycle.
`boolean` | `isMethodInvocationCountEnabled(Method method)` Indicates whether the Virtual Machine counts how many times a method is invoked.
`boolean` | `isMethodTimingEnabled(Method method)` Indicates whether the Virtual Machine measures how much time it spends in a method.
`boolean` | `isParallel()` Indicates whether the VM's garbage collector is able to run in parallel on multiple processors if multiple processors are available.

Methods inherited from interface weblogic.management.runtime.JVMRuntimeMBean
`getHeapFreeCurrent, getHeapFreePercent, getHeapSizeCurrent, getHeapSizeMax, getJavaVendor, getJavaVersion, getJavaVMVendor, getOSName, getOSVersion, getThreadStackDump, getUptime`

Methods inherited from interface weblogic.management.WebLogicMBean
`getMBeanInfo, getObjectName, getParent, getType, isCachingDisabled, isRegistered, setName, setParent`

Methods inherited from interface javax.management.DynamicMBean
`getAttribute, getAttributes, invoke, setAttribute, setAttributes`

Methods inherited from interface javax.management.MBeanRegistration
`postDeregister, postRegister, preDeregister, preRegister`

Methods inherited from interface javax.management.NotificationBroadcaster
`addNotificationListener, getNotificationInfo, removeNotificationListener`

Method Detail

### getAllProcessorsAverageLoad

    public double getAllProcessorsAverageLoad()

  A snapshot of the average load of all processors in the host computer. If the computer has only one processor, this method returns the same value as `getJvmProcessorLoad(0)`.

  The value is returned as a double, where 1.0 represents 100% load (no idle time) and 0.0 represents 0% load (pure idle time).

  Returns:
    a double that represents a snapshot of the average load of all processors.
  See Also:
    `#getProcessorLoad(int)`

### getConstructorInvocationCount

    public long getConstructorInvocationCount(Constructor constructor)
                                       throws NotFoundException

  The number of times a constructor has been invoked since enabling invocation counting.

  Parameters:
    `constructor` - - the constructor for which to return the invocation count.
  Returns:
    long the invocaton count for the specified constructor.
  Throws:
    `NotFoundException`

### getConstructorTiming

    public long getConstructorTiming(Constructor constructor)
                              throws NotFoundException

  The amount of time (in milliseconds) the Virtual Machine has spent in the constructor since enabling time measuring.

  If time measuring hasn't been enabled for the specified constructor, this method returns a null value.

  Parameters:
    `constructor` - the constructor you want to check.
  Returns:
    long cumulative milliseconds spent in the constructor.
  Throws:
    `NotFoundException`

### getExceptionCount

    public long getExceptionCount(Class throwableClass)

  The number of times an exception type has been thrown since enabling exception counting. If exception counting has not been enabled for the specified type, the result is unspecified.

  Parameters:
    `throwableClass` - the exception class to get the counter for. If the throwableClass is null, a NullPointerException will be thrown.
  Returns:
    long the current number of exceptions of this type thrown.

### getFreeHeap

    public long getFreeHeap()

  The amount (in bytes) of Java heap memory that is currently free in the Virtual Machine.

  Returns:
    Bytes of free Java heap memory.

### getFreePhysicalMemory

    public long getFreePhysicalMemory()

  The amount (in bytes) of physical memory that is currently free on the host computer.

  Returns:
    Bytes of free physical memory.

### getGcAlgorithm

    public String getGcAlgorithm()

  The type of garbage collector (GC) that the Virtual Machine is using.

  JRockit provides the following types of GCs:

  - Generational Copying, which is suitable for testing applications on a desktop machine with a small (less then 128 MB) heap.

  - Single Spaced Concurrent, which reduces or eliminates pauses in the VM that are due to garbage collection. Because it trades memory throughput for reduced pause time, you generally need a larger heap size than with other GC types. If your ordinary Java threads create more garbage than this GC can collect, the VM will pause while the Java threads wait for the garbage collection to finish.

  - Generational Concurrent, which creates a "nursery" space within the heap. New objects are created within the nursery. When the nursery is full, JRockit "stops-the-world," removes the dead objects from the nursery, and moves live objects to a different space within the heap. Another thread runs in the background to remove dead objects from the non-nursery space. This GC type has a higher memory throughput than a single spaced concurrent GC.

  - Parallel, which allocates all objects to a single spaced heap. When the heap is full, all Java threads are stopped and every CPU is used to perform a complete garbage collection of the entire heap. This behavior causes longer pause times than for the concurrent collectors but maximizes memory throughput.

  Returns:
    Type of garbage collector being used by the VM.

### getJVMDescription

    public String getJVMDescription()

  A description of the Java Virtual Machine. For example, "BEA WebLogic JRockit Java Virtual Machine."

  Returns:
    A description of the JVM as a String.

### getJvmProcessorLoad

    public double getJvmProcessorLoad()

  A snapshot of the load that the Virtual Machine is placing on all processors in the host computer. If the host contains multiple processors, the value represents a snapshot of the average load.

  The value is returned as a double, where 1.0 represents 100% load (no idle time) and 0.0 represents 0% load (pure idle time).

  Returns:
    a double that indicates the average load that the VM is placing on all processors.

### getLastGCEnd

    public long getLastGCEnd()
                      throws NotFoundException

  The time at which the last garbage collection run ended.

  Returns:
    the time the last GC ended.
  Throws:
    `NotFoundException`

### getLastGCStart

    public long getLastGCStart()
                        throws NotFoundException

  The time at which the last garbage collection run started.

  Returns:
    The time the last GC started.
  Throws:
    `NotFoundException`

### getMethodInvocationCount

    public long getMethodInvocationCount(Method method)
                                  throws NotFoundException

  The number of times a method has been invoked since enabling invocation counting.

  Parameters:
    `method` - the method you want to check.
  Returns:
    long the invocaton count for the specified Method.
  Throws:
    `NotFoundException`

### getMethodTiming

    public long getMethodTiming(Method method)
                         throws NotFoundException

  The amount of time (in milliseconds) the Virtual Machine has spent in the method since enabling time measuring.

  If time measuring has not been enabled for the specified method, this method returns a null value.

  Returns:
    long cumulative milliseconds spent in the method.
  Throws:
    `NotFoundException`

### getName

    public String getName()

  The name of the Java Virtual Machine. For example, "WebLogic JRockit."

  Specified by:
    `getName` in interface `weblogic.management.WebLogicMBean`
  Returns:
    The JVM name as a String.

### getNumberOfDaemonThreads

    public int getNumberOfDaemonThreads()

  The number of daemon Java threads currently running in the Virtual Machine across all processors.

  Returns:
    the total number of daemon Java threads running in the VM.

### getNumberOfProcessors

    public int getNumberOfProcessors()

  The number of processors on the Virtual Machine's host computer. If this is not a Symmetric Multi Processor (SMP) system, the value will be `1`.

  Returns:
    The number of processors on the VM's host computer.

### getTotalGarbageCollectionCount

    public long getTotalGarbageCollectionCount()

  The number of garbage collection runs that have occurred since the Virtual Machine was started.

  Returns:
    The number of GCs perfomed so far.

### getTotalGarbageCollectionTime

    public long getTotalGarbageCollectionTime()
                                       throws NotFoundException

  The number of milliseconds that the Virtual Machine has spent on all garbage collection runs since the VM was started.

  Returns:
    Total milliseconds spent for all garbage collection runs.
  Throws:
    `NotFoundException`

### getTotalHeap

    public long getTotalHeap()

  The amount (in bytes) of memory currently allocated to the Virtual Machine's Java heap.

  This value, which is also known as the "heap size," may grow up to the specified maximum heap size.

  Returns:
    Bytes of memory allocated to the Java heap.
  See Also:
    `getMaxHeapSize()`

### getTotalNumberOfThreads

    public int getTotalNumberOfThreads()

  The number of Java threads (daemon and non-daemon) that are currently running in the Virtual Machine across all processors.

  Returns:
    the number of Java threads running in the VM.

### getTotalNurserySize

    public long getTotalNurserySize()

  The amount (in bytes) of memory that is currently allocated to the nursery.

  The nursery is the area of the Java heap that the VM allocates to most objects. Instead of garbage collecting the entire heap, generational garbage collectors focus on the nursery. Because most objects die young, most of the time it is sufficient to garbage collect only the nursery and not the entire heap.

  If you are not using a generational garbage collector, the nursery size is ``0``.

  Returns:
    Bytes allocated to the nursery.

### getTotalPhysicalMemory

    public long getTotalPhysicalMemory()

  The amount (in bytes) of physical memory on the host computer.

  The value does not include memory that an operating makes available through swap space on a disk or other types of virtual memory.

  Returns:
    Bytes of physical memory on the host computer.

### getUsedHeap

    public long getUsedHeap()

  The amount (in bytes) of Java heap memory that is currently being used by the Virtual Machine.

  Returns:
    Bytes of Java heap memory that is being used.

### getUsedPhysicalMemory

    public long getUsedPhysicalMemory()

  The amount (in bytes) of physical memory that is currently being used on the host computer.

  The value describes the memory that is being used by all processes on the computer, not just by the Virtual Machine.

  Returns:
    Bytes of physical memory being used.

### getVendor

    public String getVendor()

  The name of the JVM vendor. For example, "BEA Systems Inc."

  Returns:
    The name of the vendor as a String.

### getVersion

    public String getVersion()

  The current version of Java Virtual Machine.

  Returns:
    The current version of the JVM as a String.

### isConcurrent

    public boolean isConcurrent()
                         throws NotFoundException

  Indicates whether the VM's garbage collector runs in a separate Java thread concurrently with other Java threads.

  Returns:
    true if this GC runs in a separate concurrent thread.
  Throws:
    `NotFoundException`

### isConstructorInvocationCountEnabled

    public boolean isConstructorInvocationCountEnabled(Constructor cons)
                                                throws NotFoundException

  Indicates whether the Virtual Machine counts how many times a constructor is invoked.

  Parameters:
    `cons` - the constructor you want to check.
  Returns:
    boolean true if invocation counting is enabled for the constructor.
  Throws:
    `NotFoundException`

### isConstructorTimingEnabled

    public boolean isConstructorTimingEnabled(Constructor constructor)
                                       throws NotFoundException

  Indicates whether the Virtual Machine measures how much time it spends in a constructor.

  Parameters:
    `constructor` - the constructor you want to check.
  Returns:
    boolean true if time measuring is enabled for the constructor.
  Throws:
    `NotFoundException`

### isExceptionCountEnabled

    public boolean isExceptionCountEnabled(Class throwableClass)
                                    throws ClassCastException

  Indicates whether the Virtual Machine counts how many times an exception is thrown.

  Parameters:
    `throwableClass` - the exception class to get the counter for.
  Returns:
    true if exception counting is enabled for the argument, false otherwise.
  Throws:
    `ClassCastException` - thrown if the argument is not a subclass of Throwable

### isGCHandlesCompaction

    public boolean isGCHandlesCompaction()
                                  throws NotFoundException

  Indicates whether the VM's garbage collector compacts the Java heap.

  Usually the heap is scattered throughout available memory. A garbage collector that compacts the heap defragments the memory space in addition to deleting unused objects.

  Returns:
    true if this garbage collector compacts the Java heap.
  Throws:
    `NotFoundException`

### isGenerational

    public boolean isGenerational()
                           throws NotFoundException

  Indicates whether the VM's garbage collector uses a nursery space.

  A nursery is the area of the Java heap that the VM allocates to most objects. Instead of garbage collecting the entire heap, generational garbage collectors focus on the nursery. Because most objects die young, most of the time it is sufficient to garbage collect only the nursery and not the entire heap.

  Returns:
    true if this GC has a nursery.
  Throws:
    `NotFoundException`

### isIncremental

    public boolean isIncremental()
                          throws NotFoundException

  Indicates whether the VM's garbage collector collects (increments) garbage as it scans the memory space and dumps the garbage at the end of its cycle.

  With a non-incremental garbage collector, garbage is dumped as soon as it is encountered.

  Returns:
    true if this GC is incremental.
  Throws:
    `NotFoundException`

### isMethodInvocationCountEnabled

    public boolean isMethodInvocationCountEnabled(Method method)
                                           throws NotFoundException

  Indicates whether the Virtual Machine counts how many times a method is invoked.

  Parameters:
    `method` - the method you want to check.
  Returns:
    boolean true if invocation counting is enabled for the method.
  Throws:
    `NotFoundException`

### isMethodTimingEnabled

    public boolean isMethodTimingEnabled(Method method)
                                  throws NotFoundException

  Indicates whether the Virtual Machine measures how much time it spends in a method.

  Parameters:
    `method` - the method you want to check.
  Returns:
    boolean true if time measuring is enabled for the method.
  Throws:
    `NotFoundException`

### isParallel

    public boolean isParallel()
                       throws NotFoundException

  Indicates whether the VM's garbage collector is able to run in parallel on multiple processors if multiple processors are available.

  Returns:
    true if this GC runs in parallel on multiple processors.
  Throws:
    `NotFoundException`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Documentation is available at http://e-docs.bea.com/wls/docs91 Copyright 2005 BEA Systems Inc.
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD