JDK源码-java.lang.management-第一部分-源码学习

最新推荐文章于 2021-04-22 11:57:08 发布

quxiuchengdev

最新推荐文章于 2021-04-22 11:57:08 发布

阅读量2.2k

点赞数 1

分类专栏： jdk源码文章标签：源码

本文链接：https://blog.csdn.net/QXC1281/article/details/53857295

版权

jdk源码专栏收录该内容

5 篇文章 0 订阅

订阅专栏

源码结构

接口

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<String> getInputArguments();

    /**
     * 返回 Java 虚拟机的正常运行时间（以毫秒为单位）。
     */
    public long getUptime();

    /**
     * 返回 Java 虚拟机的启动时间（以毫秒为单位）。
     */
    public long getStartTime();

    /**
     * 返回所有系统属性的名称和值的映射。
     */
    public java.util.Map<String, String> 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<MemoryPoolMXBean> getMemoryPoolMXBeans() {
        return sun.management.ManagementFactory.getMemoryPoolMXBeans();
    }

    public static List<MemoryManagerMXBean> getMemoryManagerMXBeans() {
        return sun.management.ManagementFactory.getMemoryManagerMXBeans();
    }

    public static List<GarbageCollectorMXBean> 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> T
        newPlatformMXBeanProxy(MBeanServerConnection connection,
                               String mxbeanName,
                               Class<T> 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
* |———————————————-|