JDK源码-java.lang.management-第一部分-源码学习
源码结构
接口
ClassLoadingMXBean
Java 虚拟机的类加载系统
public interface ClassLoadingMXBean {
/**
* 返回自 Java 虚拟机开始执行到目前已经加载的类的总数。
*/
public long getTotalLoadedClassCount();
/**
* 返回当前加载到 Java 虚拟机中的类的数量。
*/
public int getLoadedClassCount();
/**
* 返回自 Java 虚拟机开始执行到目前已经卸载的类的总数。
*/
public long getUnloadedClassCount();
/**
* 测试是否已为类加载系统启用了 verbose 输出
*/
public boolean isVerbose();
/**
* 为类加载系统启用或禁用 verbose 输出。
*/
public void setVerbose(boolean value);
}CompilationMXBean
Java 虚拟机的编译系统。
public interface CompilationMXBean {
/**
* 返回编译器名称
*/
public java.lang.String getName();
/**
* 测试 Java 虚拟机是否支持监视编译时间。
*/
public boolean isCompilationTimeMonitoringSupported();
/**
* 返回在编译上花费的累积耗费时间的近似值（以毫秒为单位)
*/
public long getTotalCompilationTime();
}GarbageCollectorMXBean
Java 虚拟机中的垃圾回收器
public interface GarbageCollectorMXBean extends MemoryManagerMXBean {
/**
*/
public long getCollectionCount();
/**
*/
public long getCollectionTime();
}MemoryManagerMXBean
Java 虚拟机中的内存管理器
public interface MemoryManagerMXBean {
/**
*/
public String getName();
/**
*/
public boolean isValid();
/**
*/
public String[] getMemoryPoolNames();
}
MemoryMXBean
Java 虚拟机的内存系统.
public interface MemoryMXBean {
/**
* 返回其终止被挂起的对象的近似数目。
*/
public int getObjectPendingFinalizationCount();
/**
* 返回用于对象分配的堆的当前内存使用量
*/
public MemoryUsage getHeapMemoryUsage();
/**
* 返回 Java 虚拟机使用的非堆内存的当前内存使用量。
*/
public MemoryUsage getNonHeapMemoryUsage();
/**
* 测试内存系统的 verbose 输出是否已启用。
*/
public boolean isVerbose();
/**
* 启用或禁用内存系统的 verbose 输出。
*/
public void setVerbose(boolean value);
/**
* 运行垃圾回收器。
*/
public void gc();
}MemoryPoolMXBean
Java 虚拟机中的内存池
public interface MemoryPoolMXBean {
/**
*/
public String getName();
/**
*/
public MemoryType getType();
/**
*/
public MemoryUsage getUsage();
/**
*
*/
public MemoryUsage getPeakUsage();
/**
*/
public void resetPeakUsage();
/**
*/
public boolean isValid();
/**
*/
public String[] getMemoryManagerNames();
/**
*/
public long getUsageThreshold();
/**
*/
public void setUsageThreshold(long threshold);
/**
*/
public boolean isUsageThresholdExceeded();
/**
*/
public long getUsageThresholdCount();
/**
*/
public boolean isUsageThresholdSupported();
/**
*/
public long getCollectionUsageThreshold();
/**
*/
public void setCollectionUsageThreshold(long threhsold);
/**
*/
public boolean isCollectionUsageThresholdExceeded();
/**
*/
public long getCollectionUsageThresholdCount();
/**
*/
public MemoryUsage getCollectionUsage();
/**
*/
public boolean isCollectionUsageThresholdSupported();
}OperatingSystemMXBean
Java 虚拟机在其上运行的操作系统
public interface OperatingSystemMXBean {
/**
* 返回操作系统名称
*/
public String getName();
/**
* 返回操作系统的架构。
*/
public String getArch();
/**
* 返回操作系统的版本。
*/
public String getVersion();
/**
* 返回 Java 虚拟机可以使用的处理器数目。
*/
public int getAvailableProcessors();
/**
* 返回最后一分钟内系统加载平均值。
*/
public double getSystemLoadAverage();
}
RuntimeMXBean
Java 虚拟机的运行时系统
public interface RuntimeMXBean {
/**
* 返回表示正在运行的 Java 虚拟机的名称。
*/
public String getName();
/**
* 返回 Java 虚拟机实现名称。
*/
public String getVmName();
/**
* 返回 Java 虚拟机实现供应商
*/
public String getVmVendor();
/**
* 返回 Java 虚拟机实现版本。
*/
public String getVmVersion();
/**
* 返回 Java 虚拟机规范名称。
*/
public String getSpecName();
/**
* 返回 Java 虚拟机规范供应商
*/
public String getSpecVendor();
/**
* 回 Java 虚拟机规范版本。
*/
public String getSpecVersion();
/**
* 返回正在运行的 Java 虚拟机实现的管理接口的规范版本。
*/
public String getManagementSpecVersion();
/**
* 返回系统类加载器用于搜索类文件的 Java 类路径
*/
public String getClassPath();
/**
* 返回 Java 库路径。
*/
public String getLibraryPath();
/**
* 测试 Java 虚拟机是否支持由引导类加载器用于搜索类文件的引导类路径机制。
*/
public boolean isBootClassPathSupported();
/**
* 返回由引导类加载器用于搜索类文件的引导类路径。
*/
public String getBootClassPath();
/**
* 返回传递给 Java 虚拟机的输入变量，其中不包括传递给 main 方法的变量。
*/
public java.util.List getInputArguments();
/**
* 返回 Java 虚拟机的正常运行时间（以毫秒为单位）。
*/
public long getUptime();
/**
* 返回 Java 虚拟机的启动时间（以毫秒为单位）。
*/
public long getStartTime();
/**
* 返回所有系统属性的名称和值的映射。
*/
public java.util.Map getSystemProperties();
}
ThreadMXBean
Java 虚拟机的线程系统
public interface ThreadMXBean {
/**
*
*/
public int getThreadCount();
/**
*
*/
public int getPeakThreadCount();
/**
*
*/
public long getTotalStartedThreadCount();
/**
*
*/
public int getDaemonThreadCount();
/**
*.
*/
public long[] getAllThreadIds();
/**
*
*/
public ThreadInfo getThreadInfo(long id);
/**
*
*/
public ThreadInfo[] getThreadInfo(long[] ids);
/**
*
*/
public ThreadInfo getThreadInfo(long id, int maxDepth);
/**
*
*/
public ThreadInfo[] getThreadInfo(long[] ids, int maxDepth);
/**
*
*/
public boolean isThreadContentionMonitoringSupported();
/**
*
*/
public boolean isThreadContentionMonitoringEnabled();
/**
*
*/
public void setThreadContentionMonitoringEnabled(boolean enable);
/**
*
*/
public long getCurrentThreadCpuTime();
/**
*
*/
public long getCurrentThreadUserTime();
/**
*
*/
public long getThreadCpuTime(long id);
/**
*
*/
public long getThreadUserTime(long id);
/**
*
*/
public boolean isThreadCpuTimeSupported();
/**
*
*/
public boolean isCurrentThreadCpuTimeSupported();
/**
*
*/
public boolean isThreadCpuTimeEnabled();
/**
*
*/
public void setThreadCpuTimeEnabled(boolean enable);
/**
*
*/
public long[] findMonitorDeadlockedThreads();
/**
*
*/
public void resetPeakThreadCount();
/**
*
*/
public long[] findDeadlockedThreads();
/**
*
*/
public boolean isObjectMonitorUsageSupported();
/**
*
*/
public boolean isSynchronizerUsageSupported();
/**
*
*/
public ThreadInfo[] getThreadInfo(long[] ids, boolean lockedMonitors, boolean lockedSynchronizers);
/**
*
*/
public ThreadInfo[] dumpAllThreads(boolean lockedMonitors, boolean lockedSynchronizers);
}
枚举类
MemoryType
public enum MemoryType {
/**
*/
HEAP("Heap memory"),
/**
*
*/
NON_HEAP("Non-heap memory");
private final String description;
private MemoryType(String s) {
this.description = s;
}
/**
*/
public String toString() {
return description;
}
private static final long serialVersionUID = 6992337162326171013L;
}
实体类(部分源码)
LockInfo
构造函数
/**
* className - 锁对象的完全限定类名称。
* identityHashCode - 锁对象的标识哈希码。
*/
@ConstructorProperties({"className", "identityHashCode"})
public LockInfo(String className, int identityHashCode) {
if (className == null) {
throw new NullPointerException("Parameter className cannot be null");
}
this.className = className;
this.identityHashCode = identityHashCode;
}方法
对象锁信息
//返回锁的字符串表示形式
public String toString() {
return className + '@' + Integer.toHexString(identityHashCode);
}ManagementFactory(重要)
解释
类是一种工厂类，用于获取 Java 平台的管理 Bean
每种静态方法都会返回一个或多个表示 Java 虚拟机组件的管理接口的平台 MXBean
源码解释
public class ManagementFactory {
// 构造函数私有化
private ManagementFactory() {};
/****************获取各个接口的字符串标示形式 开始*******************/
public final static String CLASS_LOADING_MXBEAN_NAME =
"java.lang:type=ClassLoading";
public final static String COMPILATION_MXBEAN_NAME =
"java.lang:type=Compilation";
public final static String MEMORY_MXBEAN_NAME =
"java.lang:type=Memory";
public final static String OPERATING_SYSTEM_MXBEAN_NAME =
"java.lang:type=OperatingSystem";
public final static String RUNTIME_MXBEAN_NAME =
"java.lang:type=Runtime";
public final static String THREAD_MXBEAN_NAME =
"java.lang:type=Threading";
public final static String GARBAGE_COLLECTOR_MXBEAN_DOMAIN_TYPE =
"java.lang:type=GarbageCollector";
public final static String MEMORY_MANAGER_MXBEAN_DOMAIN_TYPE=
"java.lang:type=MemoryManager";
public final static String MEMORY_POOL_MXBEAN_DOMAIN_TYPE=
"java.lang:type=MemoryPool";
/****************获取各个接口的字符串标示形式 结束*******************/
/****************获取各个接口的具体实现类 开始*******************/
public static ClassLoadingMXBean getClassLoadingMXBean() {
return sun.management.ManagementFactory.getClassLoadingMXBean();
}
public static MemoryMXBean getMemoryMXBean() {
return sun.management.ManagementFactory.getMemoryMXBean();
}
public static ThreadMXBean getThreadMXBean() {
return sun.management.ManagementFactory.getThreadMXBean();
}
public static RuntimeMXBean getRuntimeMXBean() {
return sun.management.ManagementFactory.getRuntimeMXBean();
}
public static CompilationMXBean getCompilationMXBean() {
return sun.management.ManagementFactory.getCompilationMXBean();
}
public static OperatingSystemMXBean getOperatingSystemMXBean() {
return sun.management.ManagementFactory.getOperatingSystemMXBean();
}
public static List getMemoryPoolMXBeans() {
return sun.management.ManagementFactory.getMemoryPoolMXBeans();
}
public static List getMemoryManagerMXBeans() {
return sun.management.ManagementFactory.getMemoryManagerMXBeans();
}
public static List getGarbageCollectorMXBeans() {
return sun.management.ManagementFactory.getGarbageCollectorMXBeans();
}
/****************获取各个接口的具体实现类 结束*******************/
private static MBeanServer platformMBeanServer;
/**
* 返回平添的基本信息,静态单线程方法
*/
public static synchronized MBeanServer getPlatformMBeanServer() {
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
Permission perm = new MBeanServerPermission("createMBeanServer");
sm.checkPermission(perm);
}
if (platformMBeanServer == null) {
platformMBeanServer =
sun.management.ManagementFactory.createPlatformMBeanServer();
}
return platformMBeanServer;
}
/**
* 返回平台接口的代理方法
* MXBean 接口的代理，以便通过给定 MBeanServerConnection 转发其方法调用。
* connection - 要转发到的目标 MBeanServerConnection。
* mxbeanName - 要转发到的 connection 的平台 MXBean。mxbeanName 的格式必须为 ObjectName 的格式。
* mxbeanInterface - 要由代理实现的 MXBean 接口。
*/
public static T
newPlatformMXBeanProxy(MBeanServerConnection connection,
String mxbeanName,
Class mxbeanInterface)
throws java.io.IOException {
final Class interfaceClass = mxbeanInterface;
// Only allow MXBean interfaces from rt.jar loaded by the
// bootstrap class loader
// 调用类加载器
final ClassLoader loader = (ClassLoader)
AccessController.doPrivileged(new PrivilegedAction() {
public Object run() {
return interfaceClass.getClassLoader();
}
});
if (loader != null) {
throw new IllegalArgumentException(mxbeanName +
" is not a platform MXBean");
}
try {
final ObjectName objName = new ObjectName(mxbeanName);
if (!connection.isInstanceOf(objName, interfaceClass.getName())) {
throw new IllegalArgumentException(mxbeanName +
" is not an instance of " + interfaceClass);
}
final Class[] interfaces;
// check if the registered MBean is a notification emitter
// 判断是否注册
boolean emitter = connection.isInstanceOf(objName, NOTIF_EMITTER);
// create an MXBean proxy
// 创建代理
return JMX.newMXBeanProxy(connection, objName, mxbeanInterface,
emitter);
} catch (InstanceNotFoundException e) {
final IllegalArgumentException iae =
new IllegalArgumentException(mxbeanName +
" not found in the connection.");
iae.initCause(e);
throw iae;
} catch (MalformedObjectNameException e) {
final IllegalArgumentException iae =
new IllegalArgumentException(mxbeanName +
" is not a valid ObjectName format.");
iae.initCause(e);
throw iae;
}
}
// 静态类名称 management
private static final String NOTIF_EMITTER =
"javax.management.NotificationEmitter";
}
ManagementPermission
使用 SecurityManager 运行的代码调用 Java 平台的管理接口中定义的方法时，SecurityManager 将要检查的权限。
//不允许继承,继承基础权限类
public final class ManagementPermission extends java.security.BasicPermission {MemoryNotificationInfo
关于内存通知的信息
MemoryUsageManagementFactory
表示内存使用量快照的 MemoryUsage
* +———————————————-+
* + | +
* + | +
* +———————————————-+
*
* |——–|
* init
* |—————|
* used
* |—————————|
* committed
* |———————————————-|
MonitorInfo
关于对象监视器锁的信息
ThreadInfo
线程信息