A Java virtual machine has a single instance of the implementation * class of this interface. This instance implementing this interface is * an MXBean * that can be obtained by calling * the {@link ManagementFactory#getMemoryMXBean} method or * from the {@link ManagementFactory#getPlatformMBeanServer * platform MBeanServer} method. * *
The ObjectName for uniquely identifying the MXBean for * the memory system within an MBeanServer is: *
* {@link ManagementFactory#MEMORY_MXBEAN_NAME * java.lang:type=Memory} ** *
The heap may be of a fixed size or may be expanded and shrunk. * The memory for the heap does not need to be contiguous. * *
The Java virtual machine has a method area that is shared * among all threads. * The method area belongs to non-heap memory. It stores per-class structures * such as a runtime constant pool, field and method data, and the code for * methods and constructors. It is created at the Java virtual machine * start-up. * *
The method area is logically part of the heap but a Java virtual * machine implementation may choose not to either garbage collect * or compact it. Similar to the heap, the method area may be of a * fixed size or may be expanded and shrunk. The memory for the * method area does not need to be contiguous. * *
In addition to the method area, a Java virtual machine * implementation may require memory for internal processing or * optimization which also belongs to non-heap memory. * For example, the JIT compiler requires memory for storing the native * machine code translated from the Java virtual machine code for * high performance. * *
A memory pool represents a memory area that the Java virtual machine * manages. The Java virtual machine has at least one memory pool * and it may create or remove memory pools during execution. * A memory pool can belong to either the heap or the non-heap memory. * *
A memory manager is responsible for managing one or more memory pools. * The garbage collector is one type of memory manager responsible * for reclaiming memory occupied by unreachable objects. A Java virtual * machine may have one or more memory managers. It may * add or remove memory managers during execution. * A memory pool can be managed by more than one memory manager. * *
* The memory usage can be monitored in three ways: *
The memory usage monitoring mechanism is intended for load-balancing * or workload distribution use. For example, an application would stop * receiving any new workload when its memory usage exceeds a * certain threshold. It is not intended for an application to detect * and recover from a low memory condition. * *
This MemoryMXBean is a * {@link javax.management.NotificationEmitter NotificationEmitter} * that emits two types of memory {@link javax.management.Notification * notifications} if any one of the memory pools * supports a usage threshold * or a collection usage * threshold which can be determined by calling the * {@link MemoryPoolMXBean#isUsageThresholdSupported} and * {@link MemoryPoolMXBean#isCollectionUsageThresholdSupported} methods. *
* The notification emitted is a {@link javax.management.Notification} * instance whose {@link javax.management.Notification#setUserData * user data} is set to a {@link CompositeData CompositeData} * that represents a {@link MemoryNotificationInfo} object * containing information about the memory pool when the notification * was constructed. The CompositeData contains the attributes * as described in {@link MemoryNotificationInfo#from * MemoryNotificationInfo}. * *
* class MyListener implements javax.management.NotificationListener {
* public void handleNotification(Notification notif, Object handback) {
* // handle notification
* ....
* }
* }
*
* MemoryMXBean mbean = ManagementFactory.getMemoryMXBean();
* NotificationEmitter emitter = (NotificationEmitter) mbean;
* MyListener listener = new MyListener();
* emitter.addNotificationListener(listener, null, null);
* * The amount of used memory in the returned memory usage * is the amount of memory occupied by both live objects * and garbage objects that have not been collected, if any. * *
* MBeanServer access:
* The mapped type of MemoryUsage is
* CompositeData with attributes as specified in
* {@link MemoryUsage#from MemoryUsage}.
*
* @return a {@link MemoryUsage} object representing
* the heap memory usage.
*/
public MemoryUsage getHeapMemoryUsage();
/**
* Returns the current memory usage of non-heap memory that
* is used by the Java virtual machine.
* The non-heap memory consists of one or more memory pools.
* The used and committed size of the
* returned memory usage is the sum of those values of
* all non-heap memory pools whereas the init
* and max size of the returned memory usage
* represents the setting of the non-heap
* memory which may not be the sum of those of all non-heap
* memory pools.
*
*
* MBeanServer access:
* The mapped type of MemoryUsage is
* CompositeData with attributes as specified in
* {@link MemoryUsage#from MemoryUsage}.
*
* @return a {@link MemoryUsage} object representing
* the non-heap memory usage.
*/
public MemoryUsage getNonHeapMemoryUsage();
/**
* Tests if verbose output for the memory system is enabled.
*
* @return true if verbose output for the memory
* system is enabled; false otherwise.
*/
public boolean isVerbose();
/**
* Enables or disables verbose output for the memory
* system. The verbose output information and the output stream
* to which the verbose information is emitted are implementation
* dependent. Typically, a Java virtual machine implementation
* prints a message whenever it frees memory at garbage collection.
*
*
* Each invocation of this method enables or disables verbose
* output globally.
*
* @param value true to enable verbose output;
* false to disable.
*
* @exception java.lang.SecurityException if a security manager
* exists and the caller does not have
* ManagementPermission("control").
*/
public void setVerbose(boolean value);
/**
* Runs the garbage collector.
* The call gc() is effectively equivalent to the
* call:
*
* System.gc()
*