Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
JDK 11 java.management.jmod - Management Module
JDK 11 java.management.jmod is the JMOD file for JDK 11 Management module.
JDK 11 Management module compiled class files are stored in \fyicenter\jdk-11.0.1\jmods\java.management.jmod.
JDK 11 Management module compiled class files are also linked and stored in the \fyicenter\jdk-11.0.1\lib\modules JImage file.
JDK 11 Management module source code files are stored in \fyicenter\jdk-11.0.1\lib\src.zip\java.management.
You can click and view the content of each source code file in the list below.
✍: FYIcenter
⏎ java/lang/management/MemoryUsage.java
/* * Copyright (c) 2003, 2017, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */ package java.lang.management; import javax.management.openmbean.CompositeData; import sun.management.MemoryUsageCompositeData; /** * A {@code MemoryUsage} object represents a snapshot of memory usage. * Instances of the {@code MemoryUsage} class are usually constructed * by methods that are used to obtain memory usage * information about individual memory pool of the Java virtual machine or * the heap or non-heap memory of the Java virtual machine as a whole. * * <p> A {@code MemoryUsage} object contains four values: * <table class="striped"> * <caption style="display:none">Describes the MemoryUsage object content</caption> * <thead> * <tr><th scope="col">Value</th><th scope="col">Description</th></tr> * </thead> * <tbody style="text-align:left"> * <tr> * <th scope="row" style="vertical-align:top"> {@code init} </th> * <td style="vertical-align:top"> represents the initial amount of memory (in bytes) that * the Java virtual machine requests from the operating system * for memory management during startup. The Java virtual machine * may request additional memory from the operating system and * may also release memory to the system over time. * The value of {@code init} may be undefined. * </td> * </tr> * <tr> * <th scope="row" style="vertical-align:top"> {@code used} </th> * <td style="vertical-align:top"> represents the amount of memory currently used (in bytes). * </td> * </tr> * <tr> * <th scope="row" style="vertical-align:top"> {@code committed} </th> * <td style="vertical-align:top"> represents the amount of memory (in bytes) that is * guaranteed to be available for use by the Java virtual machine. * The amount of committed memory may change over time (increase * or decrease). The Java virtual machine may release memory to * the system and {@code committed} could be less than {@code init}. * {@code committed} will always be greater than * or equal to {@code used}. * </td> * </tr> * <tr> * <th scope="row" style="vertical-align:top"> {@code max} </th> * <td style="vertical-align:top"> represents the maximum amount of memory (in bytes) * that can be used for memory management. Its value may be undefined. * The maximum amount of memory may change over time if defined. * The amount of used and committed memory will always be less than * or equal to {@code max} if {@code max} is defined. * A memory allocation may fail if it attempts to increase the * used memory such that {@code used > committed} even * if {@code used <= max} would still be true (for example, * when the system is low on virtual memory). * </td> * </tr> * </tbody> * </table> * * Below is a picture showing an example of a memory pool: * * <pre> * +----------------------------------------------+ * +//////////////// | + * +//////////////// | + * +----------------------------------------------+ * * |--------| * init * |---------------| * used * |---------------------------| * committed * |----------------------------------------------| * max * </pre> * * <h3>MXBean Mapping</h3> * {@code MemoryUsage} is mapped to a {@link CompositeData CompositeData} * with attributes as specified in the {@link #from from} method. * * @author Mandy Chung * @since 1.5 */ public class MemoryUsage { private final long init; private final long used; private final long committed; private final long max; /** * Constructs a {@code MemoryUsage} object. * * @param init the initial amount of memory in bytes that * the Java virtual machine allocates; * or {@code -1} if undefined. * @param used the amount of used memory in bytes. * @param committed the amount of committed memory in bytes. * @param max the maximum amount of memory in bytes that * can be used; or {@code -1} if undefined. * * @throws IllegalArgumentException if * <ul> * <li> the value of {@code init} or {@code max} is negative * but not {@code -1}; or</li> * <li> the value of {@code used} or {@code committed} is negative; * or</li> * <li> {@code used} is greater than the value of {@code committed}; * or</li> * <li> {@code committed} is greater than the value of {@code max} * {@code max} if defined.</li> * </ul> */ public MemoryUsage(long init, long used, long committed, long max) { if (init < -1) { throw new IllegalArgumentException( "init parameter = " + init + " is negative but not -1."); } if (max < -1) { throw new IllegalArgumentException( "max parameter = " + max + " is negative but not -1."); } if (used < 0) { throw new IllegalArgumentException( "used parameter = " + used + " is negative."); } if (committed < 0) { throw new IllegalArgumentException( "committed parameter = " + committed + " is negative."); } if (used > committed) { throw new IllegalArgumentException( "used = " + used + " should be <= committed = " + committed); } if (max >= 0 && committed > max) { throw new IllegalArgumentException( "committed = " + committed + " should be < max = " + max); } this.init = init; this.used = used; this.committed = committed; this.max = max; } /** * Constructs a {@code MemoryUsage} object from a * {@link CompositeData CompositeData}. */ private MemoryUsage(CompositeData cd) { // validate the input composite data MemoryUsageCompositeData.validateCompositeData(cd); this.init = MemoryUsageCompositeData.getInit(cd); this.used = MemoryUsageCompositeData.getUsed(cd); this.committed = MemoryUsageCompositeData.getCommitted(cd); this.max = MemoryUsageCompositeData.getMax(cd); } /** * Returns the amount of memory in bytes that the Java virtual machine * initially requests from the operating system for memory management. * This method returns {@code -1} if the initial memory size is undefined. * * @return the initial size of memory in bytes; * {@code -1} if undefined. */ public long getInit() { return init; } /** * Returns the amount of used memory in bytes. * * @return the amount of used memory in bytes. * */ public long getUsed() { return used; }; /** * Returns the amount of memory in bytes that is committed for * the Java virtual machine to use. This amount of memory is * guaranteed for the Java virtual machine to use. * * @return the amount of committed memory in bytes. * */ public long getCommitted() { return committed; }; /** * Returns the maximum amount of memory in bytes that can be * used for memory management. This method returns {@code -1} * if the maximum memory size is undefined. * * <p> This amount of memory is not guaranteed to be available * for memory management if it is greater than the amount of * committed memory. The Java virtual machine may fail to allocate * memory even if the amount of used memory does not exceed this * maximum size. * * @return the maximum amount of memory in bytes; * {@code -1} if undefined. */ public long getMax() { return max; }; /** * Returns a descriptive representation of this memory usage. */ public String toString() { StringBuilder buf = new StringBuilder(); buf.append("init = " + init + "(" + (init >> 10) + "K) "); buf.append("used = " + used + "(" + (used >> 10) + "K) "); buf.append("committed = " + committed + "(" + (committed >> 10) + "K) " ); buf.append("max = " + max + "(" + (max >> 10) + "K)"); return buf.toString(); } /** * Returns a {@code MemoryUsage} object represented by the * given {@code CompositeData}. The given {@code CompositeData} * must contain the following attributes: * * <table class="striped" style="margin-left:2em;"> * <caption style="display:none">The attributes and the types the given CompositeData contains</caption> * <thead> * <tr> * <th scope="col">Attribute Name</th> * <th scope="col">Type</th> * </tr> * </thead> * <tbody style="text-align:left"> * <tr> * <th scope="row">init</th> * <td>{@code java.lang.Long}</td> * </tr> * <tr> * <th scope="row">used</th> * <td>{@code java.lang.Long}</td> * </tr> * <tr> * <th scope="row">committed</th> * <td>{@code java.lang.Long}</td> * </tr> * <tr> * <th scope="row">max</th> * <td>{@code java.lang.Long}</td> * </tr> * </tbody> * </table> * * @param cd {@code CompositeData} representing a {@code MemoryUsage} * * @throws IllegalArgumentException if {@code cd} does not * represent a {@code MemoryUsage} with the attributes described * above. * * @return a {@code MemoryUsage} object represented by {@code cd} * if {@code cd} is not {@code null}; * {@code null} otherwise. */ public static MemoryUsage from(CompositeData cd) { if (cd == null) { return null; } if (cd instanceof MemoryUsageCompositeData) { return ((MemoryUsageCompositeData) cd).getMemoryUsage(); } else { return new MemoryUsage(cd); } } }
⏎ java/lang/management/MemoryUsage.java
Or download all of them as a single archive file:
File name: java.management-11.0.1-src.zip File size: 828174 bytes Release date: 2018-11-04 Download
⇒ JDK 11 java.management.rmi.jmod - Management RMI Module
2020-04-30, 97665👍, 0💬
Popular Posts:
Snappy-Java is a Java port of the "snappy", a fast C++ compresser/decompresser developed by Google. ...
JAX-WS is an API for building web services and clients. It is the next generation Web Services API r...
Apache Commons Codec library provides implementations of common encoders and decoders such as Base64...
Where to find answers to frequently asked questions on Downloading and Using JDK (Java Development K...
What Is jaxb-impl-2.1.12.jar? Java Architecture for XML Binding (JAXB) is a Java API that allows Jav...