`
longgangbai
  • 浏览: 7325770 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

JMX 和系统管理

阅读更多

          

检测虚拟机当前的状态总是 Java 开放人员所关心的,也正是因为如此,出现了大量的 profiler 工具来检测当前的虚拟机状态。从 Java SE 5 之后,在 JDK 中,我们有了一些 Java 的虚拟机检测 API,即 java.lang.management包。Management 包里面包括了许多 MXBean 的接口类和 LockInfo、MemoryUsage、MonitorInfo 和 ThreadInfo 等类。从名字可以看出,该包提供了虚拟机内存分配、垃圾收集(GC)情况、操作系统层、线程调度和共享锁,甚至编译情况的检测机制。这样一来,Java 的开发人员就可以很简单地为自己做一些轻量级的系统检测,来确定当前程序的各种状态,以便随时调整。

要获得这些信息,我们首先通过 java.lang.management.ManagementFactory这个工厂类来获得一系列的 MXBean。包括:

  • ClassLoadingMXBean

    ClassLoadMXBean 包括一些类的装载信息,比如有多少类已经装载 / 卸载(unloaded),虚拟机类装载的 verbose 选项(即命令行中的 Java – verbose:class 选项)是否打开,还可以帮助用户打开 / 关闭该选项。

  • CompilationMXBean

    CompilationMXBean 帮助用户了解当前的编译器和编译情况,该 mxbean 提供的信息不多。

  • GarbageCollectorMXBean

    相对于开放人员对 GC 的关注程度来说,该 mxbean 提供的信息十分有限,仅仅提供了 GC 的次数和 GC 花费总时间的近似值。但是这个包中还提供了三个的内存管理检测类:MemoryManagerMXBean,MemoryMXBean 和 MemoryPoolMXBean。

    • MemoryManagerMXBean

      这个类相对简单,提供了内存管理类和内存池(memory pool)的名字信息。

    • MemoryMXBean

      这个类提供了整个虚拟机中内存的使用情况,包括 Java 堆(heap)和非 Java 堆所占用的内存,提供当前等待 finalize 的对象数量,它甚至可以做 gc(实际上是调用 System.gc)。

    • MemoryPoolMXBean

      该信息提供了大量的信息。在 JVM 中,可能有几个内存池,因此有对应的内存池信息,因此,在工厂类中,getMemoryPoolMXBean() 得到是一个 MemoryPoolMXBean 的 list。每一个 MemoryPoolMXBean 都包含了该内存池的详细信息,如是否可用、当前已使用内存 / 最大使用内存值、以及设置最大内存值等等。

  • OperatingSystemMXBean

    该类提供的是操作系统的简单信息,如构架名称、当前 CPU 数、最近系统负载等。

  • RuntimeMXBean

    运行时信息包括当前虚拟机的名称、提供商、版本号,以及 classpath、bootclasspath 和系统参数等等。

  • ThreadMXBean

    在 Java 这个多线程的系统中,对线程的监控是相当重要的。ThreadMXBean 就是起到这个作用。ThreadMXBean 可以提供的信息包括各个线程的各种状态,CPU 占用情况,以及整个系统中的线程状况。从 ThreadMXBean 可以得到某一个线程的 ThreadInfo 对象。这个对象中则包含了这个线程的所有信息。

java.lang.management 和虚拟机的关系

我们知道,management 和底层虚拟机的关系是非常紧密的。其实,有一些的是直接依靠虚拟机提供的公开 API 实现的,比如 JVMTI;而另外一些则不然,很大一块都是由虚拟机底层提供某些不公开的 API / Native Code 提供的。这样的设计方式,保证了 management 包可以提供足够的信息,并且使这些信息的提供又有足够的效率;也使 management 包和底层的联系非常紧密。

 

package com.easyway.space.commons.systems;

import java.lang.management.ClassLoadingMXBean;
import java.lang.management.CompilationMXBean;
import java.lang.management.GarbageCollectorMXBean;
import java.lang.management.LockInfo;
import java.lang.management.ManagementFactory;
import java.lang.management.MemoryMXBean;
import java.lang.management.MemoryManagerMXBean;
import java.lang.management.MemoryPoolMXBean;
import java.lang.management.MemoryType;
import java.lang.management.MemoryUsage;
import java.lang.management.MonitorInfo;
import java.lang.management.OperatingSystemMXBean;
import java.lang.management.RuntimeMXBean;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;

/**
 * 系统监控工具
 * management 和底层虚拟机的关系是非常紧密的。其实,有一些的是直接依靠虚拟机提供的公
 * 开 API 实现的,比如 JVMTI;而另外一些则不然,很大一块都是由虚拟机底层提供某些不公开
 * 的 API / Native Code 提供的。这样的设计方式,保证了 management 包可以提供足够的信
 * 息,并且使这些信息的提供又有足够的效率;也使 management 包和底层的联系非常紧密。
 * @author longgangbai
 * 
 */
public class SystemUtils {

	/**
	 *ClassLoadingMXBean ClassLoadMXBean 包括一些类的装载信息,
	 * 比如有多少类已经装载 / 卸载(unloaded),
	 * 虚拟机类装载的 verbose 选项(即命令行中的 Java – verbose:class 选项)是否打开,
	 * 还可以帮助用户打开 / 关闭该选项。
	 */
	public static void getVMClassInformation(){
		
		ClassLoadingMXBean classLoadMXBean=ManagementFactory.getClassLoadingMXBean();
		
		int loadClazzCount=classLoadMXBean.getLoadedClassCount();
		System.out.println("加载类的数量:"+loadClazzCount);
		
		long hasloadClazzCount=classLoadMXBean.getTotalLoadedClassCount();
		System.out.println("已经加载类的数量:"+hasloadClazzCount);
		long hasUnloadClazzCount=classLoadMXBean.getUnloadedClassCount();
		System.out.println("尚未加载类的数量:"+hasUnloadClazzCount);
		boolean isVerbose=classLoadMXBean.isVerbose();
		System.out.println("是否开始加载类信息:"+isVerbose);
		//CompilationMXBean 帮助用户了解当前的编译器和编译情况,该 mxbean 提供的信息不多。
		CompilationMXBean compilationMXBean=ManagementFactory.getCompilationMXBean();
		String jitName=compilationMXBean.getName();
		System.out.println("即时编译的名称:"+jitName);
		long totalCompileTime=compilationMXBean.getTotalCompilationTime();
		System.out.println("总的编译时间:"+totalCompileTime+"/s");
		boolean isSupport=compilationMXBean.isCompilationTimeMonitoringSupported();
		if(isSupport){
			System.out.println("支持即时编译器编译监控");
		}else{
			System.out.println("不支持即时编译器编译监控");
		}
		List<GarbageCollectorMXBean> gcMXBeanList=ManagementFactory.getGarbageCollectorMXBeans();
		//相对于开放人员对 GC 的关注程度来说,该 mxbean 提供的信息十分有限,仅仅提供了 GC 的次数和 GC 花费总时间的近似值。
		for (GarbageCollectorMXBean gcMXBean : gcMXBeanList) {
			//内存池名称
			String[] poolNames=gcMXBean.getMemoryPoolNames();
			for (String poolName : poolNames) {
				System.out.println("poolNames="+poolName);
			}
		} 
		//提供了内存管理类和内存池(memory pool)的名字信息。
		List<MemoryManagerMXBean> memoryMgrMXBeanList=ManagementFactory.getMemoryManagerMXBeans();
		//内存管理器的信息
		for (MemoryManagerMXBean memoryManagerMXBean : memoryMgrMXBeanList) {
			String[] poolNames=memoryManagerMXBean.getMemoryPoolNames();
			for (String poolName : poolNames) {
				System.out.println("poolNames="+poolName);
			}
		}
		//内存信息
		MemoryMXBean memoryMXBean=ManagementFactory.getMemoryMXBean();
		//java堆得使用情况信息
		MemoryUsage heapMemoryUsage=memoryMXBean.getHeapMemoryUsage();
		long usaged=heapMemoryUsage.getUsed();
		System.out.println("java 内存堆使用内存:"+usaged);
		long maxUsage=heapMemoryUsage.getMax();
		System.out.println("java 内存堆最大使用内存:"+maxUsage);
		long initUsage=heapMemoryUsage.getInit();
		System.out.println("java 内存堆初始化时占用内存:"+initUsage);
		List<MemoryPoolMXBean> memoryPoolMXBeanList=ManagementFactory.getMemoryPoolMXBeans();
		//该信息提供了大量的信息。在 JVM 中,可能有几个内存池,因此有对应的内存池信息,因此,在工厂类中
		//,getMemoryPoolMXBean() 得到是一个 MemoryPoolMXBean 的 list。每一个 MemoryPoolMXBean 都包含
		//了该内存池的详细信息,如是否可用、当前已使用内存 / 最大使用内存值、以及设置最大内存值等等。
		for (MemoryPoolMXBean memoryPoolMXBean : memoryPoolMXBeanList) {
			//内存池的名称
			String poolName=memoryPoolMXBean.getName();
			//内存管理器的名称
			String[] memoryMgrNames=memoryPoolMXBean.getMemoryManagerNames();
			for (String mgrName : memoryMgrNames) {
				System.out.println("内存管理器的名称:"+mgrName);
			}
		    //java JVM最近内存的使用情况
			MemoryUsage memoryUsage=memoryPoolMXBean.getCollectionUsage();
			System.out.println("内存池的收集器内存使用率:"+memoryUsage.getUsed()/memoryUsage.getMax()+"%");
			memoryPoolMXBean.getCollectionUsageThreshold();
			
			memoryPoolMXBean.getCollectionUsageThresholdCount();
			MemoryType  memoryType=memoryPoolMXBean.getType();
			System.out.println("内存的信息:"+memoryType.name());
			MemoryUsage memoryUage=memoryPoolMXBean.getUsage();
			System.out.println("内存池的内存使用率:"+memoryUage.getUsed()/memoryUage.getMax()+"%");
			memoryPoolMXBean.getUsageThreshold();
			System.out.println();
			memoryPoolMXBean.getUsageThresholdCount();
			System.out.println();
		}
		//该类提供的是操作系统的简单信息,如构架名称、当前 CPU 数、最近系统负载等。
		OperatingSystemMXBean operateSystemMBean=ManagementFactory.getOperatingSystemMXBean();
		
		String operateName=operateSystemMBean.getName();
		System.out.println("操作系统的名称:"+operateName);
		
		int processListCount=operateSystemMBean.getAvailableProcessors();
		System.out.println("操作系统的进程数:"+processListCount);
		
		String osArchName=operateSystemMBean.getArch();//System.getProperty("os.arch");
		System.out.println("操作系统的架构:"+osArchName);
		
		double loadAverage=operateSystemMBean.getSystemLoadAverage();
		System.out.println("操作系统的负载均衡信息:"+loadAverage);
		
		String versionName=operateSystemMBean.getVersion();//System.getProperty("os.version");
		System.out.println("操作系统的版本号码:"+versionName);
		//运行时信息包括当前虚拟机的名称、提供商、版本号,以及 classpath、bootclasspath 和系统参数等等。
		RuntimeMXBean runtimeMXBean=ManagementFactory.getRuntimeMXBean();
		String vmName=runtimeMXBean.getVmName();
		System.out.println("虚拟机的名称:"+vmName);
		
		String vmVersion=runtimeMXBean.getVmVersion();
		System.out.println("虚拟机的版本:"+vmVersion);
		
		Map<String, String> sysMaps=runtimeMXBean.getSystemProperties();
		Set<Entry<String,String>> keyLists=sysMaps.entrySet();
		for (Entry<String, String> entry : keyLists) {
			System.out.println(entry.getKey()+":"+entry.getValue());
		}
		String vmVendor=runtimeMXBean.getVmVendor();
		System.out.println("系统的供应商的名称:"+vmVendor);
		
		//类加载器的路径
		String clazzPath=runtimeMXBean.getClassPath();//System.getProperty("java.class.path")}
		System.out.println("操作系统的类加载器的名称:"+clazzPath);
		
		List<String> argsList=runtimeMXBean.getInputArguments();
		System.out.println("操作系统的参数信息");
		for (String args : argsList) {
			System.out.println("  "+args);
		}
		
		String libPath=runtimeMXBean.getLibraryPath();// System.getProperty("java.library.path")
		System.out.println("java 的类库路径:"+libPath );
		
		String specVersion=runtimeMXBean.getManagementSpecVersion();
		System.out.println("实施运行Java虚拟机管理接口规范 的版本"+specVersion);
		
		String specName=runtimeMXBean.getSpecName();
		System.out.println("规范的名称:"+specName);
		
		String specVender=runtimeMXBean.getSpecVendor();
		System.out.println("规范管理接口供应商 :"+specVender);
		
		long startTime=runtimeMXBean.getStartTime();
		System.out.println("java 虚拟机的开始启动的时间:"+startTime);
		

		runtimeMXBean.getSpecVersion();
		System.out.println("规范接口版本::"+operateName);
		
		
		String bottClassPath =runtimeMXBean.getBootClassPath();
		System.out.println("操作系统的bootstrap 的classloader:"+bottClassPath);
		
		//在 Java 这个多线程的系统中,对线程的监控是相当重要的。ThreadMXBean 就是起到这个作用。
		//ThreadMXBean 可以提供的信息包括各个线程的各种状态,CPU 占用情况,以及整个系统中的线
		//程状况。从 ThreadMXBean 可以得到某一个线程的 ThreadInfo 对象。这个对象中则包含了这个
		//线程的所有信息。
		//线程的信息
		ThreadMXBean threadMXBean=ManagementFactory.getThreadMXBean();
		//所有的线程的编号
		long[] threadIds=threadMXBean.getAllThreadIds();
		for (long threadId : threadIds) {
			//线程的信息
			ThreadInfo  threadInfo=threadMXBean.getThreadInfo(threadId);
			//线程被阻塞的数量
			threadInfo.getBlockedCount();
			//被锁定线程的监控信息
			MonitorInfo[] monitorInfos=threadInfo.getLockedMonitors();
			for (MonitorInfo monitorInfo : monitorInfos) {
				int depth=monitorInfo.getLockedStackDepth();
				System.out.println("锁定的程度:"+depth);
			}
			//异步锁定的信息
			LockInfo[] lockinfos=threadInfo.getLockedSynchronizers();
			//锁定的信息
			for (LockInfo lockInfo : lockinfos) {
				System.out.println("锁定类的名称:"+lockInfo.getClassName());
			}
			//线程的名称
			String threadName=threadInfo.getThreadName();
			System.out.println("线程的名称:"+threadName);
			Thread.State state=threadInfo.getThreadState();
			System.out.println("线程的信息:"+state.name());
			
		}
		
		long cpuTime=threadMXBean.getCurrentThreadCpuTime();
		long curentTime=threadMXBean.getCurrentThreadUserTime();
		long threadCount=threadMXBean.getDaemonThreadCount();
		long peakliveThreadCount=threadMXBean.getPeakThreadCount();
		long threadCounts=threadMXBean.getThreadCount();
		System.out.println("当前处于live状态的线程总的数量:"+threadCounts);
		long totalThreadCount=threadMXBean.getTotalStartedThreadCount();
		System.out.println("JVM 启动之后,总的自动线程数量:"+totalThreadCount);
		
		
		
		
		
	}
	/**
	 * 
	 * @return
	 */
	public static final String getHeapMemoryUsage() {
		ClassLoadingMXBean mxbean;
		return ManagementFactory.getMemoryMXBean().getHeapMemoryUsage()
				.getUsed()
				+ "/"
				+ ManagementFactory.getMemoryMXBean().getHeapMemoryUsage()
						.getMax();
	}
    /**
     * 当前使用内存的百分比
     * @return
     */
	public static final String getHeapMemoryUsagePercent() {
		return (((double) ManagementFactory.getMemoryMXBean()
				.getHeapMemoryUsage().getUsed() / (double) ManagementFactory
				.getMemoryMXBean().getHeapMemoryUsage().getMax()) * 100L)
				+ "%";
	}
    /**
     * 当前非java堆占用的百分比
     * @return
     */
	public static final String getNonHeapMemoryUsage() {
		return ManagementFactory.getMemoryMXBean().getNonHeapMemoryUsage()
				.getUsed()
				+ "/"
				+ ManagementFactory.getMemoryMXBean().getNonHeapMemoryUsage()
						.getMax();
	}
	  /**
     * 
     * @return
     */
	public static final String getNonHeapMemoryUsagePercent() {
		return (((double) ManagementFactory.getMemoryMXBean()
				.getNonHeapMemoryUsage().getUsed() / (double) ManagementFactory
				.getMemoryMXBean().getNonHeapMemoryUsage().getMax()) * 100)
				+ "%";
	}
	  /**
     * 获取线程数
     * @return
     */
	public static final String getThreadCount() {
		return "" + ManagementFactory.getThreadMXBean().getThreadCount();
	}

}

 

分享到:
评论

相关推荐

    基于JMX的IT系统管理关键技术研究与实现

    ### 基于JMX的IT系统管理关键技术研究与实现 #### 一、引言 在当前快速发展的信息技术领域中,对于IT系统的管理和监控变得日益重要。Java Management Extensions(JMX)作为一种强大的管理框架,为Java平台上的...

    论文研究-基于JMX的网络管理系统.pdf

    通过MBean和MBean服务器,JMX系统可以提供强大的配置管理、性能监控、日志记录和事件通知等功能。 JMX与SNMP(简单网络管理协议)相比,它们都是网络管理技术,但JMX更加适合于对Java应用程序的管理。JMX允许通过...

    基于Spring+JMX+Tomcat实现资源动态管理

    Java Management Extensions (JMX) 是Java平台的一个标准API,用于创建、管理和监控各种资源,如Java应用程序、网络设备、操作系统等。JMX提供了一种标准的方式来注册MBeans(Managed Beans),这些MBeans是代表可...

    jmx-tools.zip

    Java Management Extensions(JMX)是Java平台上的一个标准技术,用于管理和监控应用程序、服务和设备。JMX提供了创建、配置、查询和管理管理对象(MBeans)的能力,这些对象可以代表任何可管理的资源,从操作系统到...

    JMX与JMS的概念

    JMX 提供了一种框架,使得开发者能够轻松地在他们的软件中添加管理和监控的功能,无论这些软件运行在何种操作系统、架构或网络环境中。JMX 的核心组成部分包括: 1. **设备层(Instrumentation Level)**:在这个...

    书籍JMX-IN-ACTION

    这本书通过实例详细解释了JMX的工作原理和应用方法,旨在帮助读者提高系统管理和自动化运维的效率。 书中首先介绍了JMX的基本概念,包括MBean(管理bean)、MBean服务器、代理和通知等核心元素,以及它们在JMX架构...

    Hbase和Hadoop JMX监控实战

    JMX(Java Management Extensions)是一种Java平台标准,用于管理和监控应用程序。在本实战中,我们将深入探讨如何利用JMX对HBase和Hadoop进行监控,以确保系统的稳定性和性能。 首先,我们需要理解HBase。HBase是...

    7.Coherence企业级缓存(六) JMX 管理和监控.pdf

    本文将重点探讨Coherence中JMX(Java Management Extensions)管理和监控的实践,旨在帮助企业IT团队更有效地管理和优化Coherence集群。 #### Coherence与JMX管理监控的重要性 在大型分布式系统中,Coherence通过...

    jmxtools-1.2.1.jar和jmxri-1.2.1.jar

    总结来说,`jmxtools-1.2.1.jar` 和 `jmxri-1.2.1.jar` 提供了完整的JMX工具集和实现,使得开发人员能够有效地管理和监控基于Java的应用程序,提高系统的可维护性和可扩展性。它们是Java开发者在进行系统监控和运维...

    jmx三种访问方式

    通过JMX,开发者可以创建管理代理(MBeans),这些代理暴露了各种管理特性,使得系统管理员可以通过JMX API来监控和操作。本文将深入探讨JMX的三种访问方式:HTTP页面方式、VM参数方式和RMI方式。 ### HTTP页面方式...

    JMX、MXBean学习

    理解并掌握JMX和MXBean技术,有助于提升Java应用的可维护性和可管理性,特别是在大型分布式系统中,JMX成为不可或缺的管理和监控工具。通过阅读博文(链接已给出,但实际无法点击),你可以深入了解JMX的实际应用和...

    论文研究-利用JMX改进网络管理系统中指标实时监控.pdf

    网络的迅速发展对现有网络管理系统的优化提出了迫切的...因此提出了一种利用JMX技术来改进网络管理系统中实时监控管理的一个实现模型。此模型有效地解决了实时监控中的网络拥塞、指标管理混乱、客户端负载过重等问题。

    jmx-1.2.1(jmxri+jmxtools) jar

    Java Management Extensions(JMX)是Java平台上的一个标准,它提供了一种管理和监控应用程序、操作系统、网络设备和其他Java应用程序的方式。这个"jmx-1.2.1(jmxri+jmxtools) jar"包含了JMX的两个核心组件:JMX ...

    jmx监控weblogic,tomcat,websphere源码

    Java管理扩展(JMX)是Java平台提供的一种标准机制,用于管理和监视应用程序、服务和设备。在本项目中,"jmx监控weblogic,tomcat,websphere源码"涉及了使用JMX来监控三个主流的Java应用服务器:WebLogic、Tomcat和...

    最简单JMX例子

    Java Management Extensions(JMX)是Java平台上的一个标准技术,用于管理和监控应用程序、服务和设备。JMX允许开发者创建管理接口,以便在运行时收集和操作应用的状态信息。本示例是一个简单的JMX实现,适合初学者...

    JMX一步一步来,快速学会开发JMX应用

    JMX(Java Management Extensions)是一个用于在Java应用程序中添加管理和监控功能的框架。它提供了一套标准的接口和服务,使得开发者能够轻松地在Java应用中集成管理和监控的能力。JMX的核心概念包括MBeans...

    jmx相关jar包

    Java Management Extensions(JMX)是Java平台上的一个标准技术,用于管理和监控应用程序、操作系统和网络设备。它提供了一种统一的方式来创建、配置、查询和控制管理资源,使得开发者能够轻松地在他们的应用中添加...

    JMX学习,开发文档

    通过这种方式,`Hello`类成为了一个可管理的组件,可以被JMX系统用来动态地改变其行为。 ### 准备工作 在开始使用JMX前,需要确保你的开发环境已经正确配置。对于不同版本的JDK,配置JMX的步骤略有不同: 1. **...

    jmxri.jar包

    Java Management Extensions (JMX) 是Java...由于其灵活性和广泛的适用性,JMX已经成为Java开发者进行系统管理和监控的重要工具。了解和掌握JMX可以提高系统的可维护性和稳定性,同时也能有效地提高开发和运维的效率。

    JMX入门的好资料啊

    Java Management Extensions(JMX)是Java平台上的一个标准技术,用于管理和监控应用程序、操作系统和网络设备等资源。它提供了一种灵活的框架,允许开发者创建可管理的组件,并通过标准接口进行交互。JMX入门是一个...

Global site tag (gtag.js) - Google Analytics