精华内容
下载资源
问答
  • 本文概要: 1、监控JVM的哪些指标; 2、一目了然的JVM监控的UI界面; 3、Java代码获取JVM监控状态。 1、监控JVM的哪些指标 javaVersion /** Java版本号 */ ...

    本文概要:

               1、监控JVM的哪些指标;

               2、一目了然的JVM监控的UI界面;

               3、Java代码获取JVM监控状态。

     

    1、监控JVM的哪些指标

                    javaVersion                                        /** Java版本号 */
                    runTime                                                /** 程序运行时间(ms) */
                    loadedClassCount                            /** JVM当前加载类数量 */
                    unloadedClassCount                        /** JVM已卸载类数量 */
                    heapTotal                                            /** 堆内存大小(字节) */
                    heapUsed                                            /** 堆内存已使用(字节) */
                    heapUsedPercent                                /** 堆内存使用率 */
                    nonHeapTotal                                    /** 堆外内存大小(字节) */
                    nonHeapUsed                                        /** 堆外内存已使用(字节) */
                    nonHeapUsedPercent                        /** 堆外内存使用率 */
                    edenTotal                                            /** Eden区大小(字节) */
                    edenUsed                                            /** Eden区已使用(字节) */
                    edenUsedPercent                                /** Eden区使用率 */
                    edenPeakUsedPercent                        /** Eden区使用率峰值(从上次采集统计) */
                    survivorTotal                                    /** Survivor区大小(字节) */
                    survivorUsed                                    /** Survivor区已使用(字节) */
                    survivorUsedPercent                        /** Survivor区已使用率 */
                    survivorPeakUsedPercent                /** Survivor区已使用率峰值(从上次采集统计) */
                    oldTotal                                            /** 老区大小(字节) */
                    oldUsed                                                /** 老区已使用(字节) */
                    oldUsedPercent                                /** 老区已使用率峰值 */
                    oldPeakUsedPercent                        /** 老区已使用率峰值(从上次采集统计) */
                    permTotal                                            /** 永久区大小(字节) */
                    permUsed                                            /** 永久区已使用(字节) */
                    permUsedPercent                                /** 永久区使用率 */
                    permPeakUsedPercent                        /** 永久区使用率峰值(从上次采集统计) */
                    codeCacheTotal                                /** CodeCache区大小(字节) */
                    codeCacheUsed                                    /** CodeCache区已使用(字节) */
                    codeCacheUsedPercent                    /** CodeCache区使用率 */
                    codeCachePeakUsedPercent            /** CodeCache区使用率峰值(从上次采集统计) */
                    ygcName                                                /** young gc名称 */
                    ygc                                                        /** young gc次数 */
                    ygcTime                                                /** young gc总时间 (ms)*/
                    fgcName                                                /** full gc名称 */
                    fgc                                                        /** full gc次数 */
                    fgcTime                                                /** full gc总时间 (ms)*/
                    threadCount                                        /** JVM当前线程数量 */
                    threadPeakCount                                /** JVM线程数量峰值 */
                    userThreadCount                                /** JVM当前用户线程数量 */
                    deadLockedThreadCount                    /** JVM死锁线程数量 */

     

    2、一目了然的JVM监控的UI界面

    3、Java代码获取JVM监控状态

        前面有一篇文章是用Python获取JVM状态数据的《JVM监控:python脚本JMX获取JVM状态》,这里用Java代码获取JVM状态数据,可以在自己的应用程序里定时运行获取JVM状态数据,测试兼容JDK1.7/1.8。

    package com.tjy.util;
    
    import java.lang.management.GarbageCollectorMXBean;
    import java.lang.management.ManagementFactory;
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * 类描述:JVM GC信息工具类
     * 
     **/
    public class JVMGCUtils {
    	static private GarbageCollectorMXBean youngGC;
        static private GarbageCollectorMXBean fullGC; 
    
        static{
        	List<GarbageCollectorMXBean> gcMXBeanList = ManagementFactory.getGarbageCollectorMXBeans();        
            for (final GarbageCollectorMXBean gcMXBean : gcMXBeanList) {
    			String gcName = gcMXBean.getName();
    			if(gcName==null) {
    				continue;
    			}
    			//G1 Old Generation
    			//Garbage collection optimized for short pausetimes Old Collector
    			//Garbage collection optimized for throughput Old Collector
    			//Garbage collection optimized for deterministic pausetimes Old Collector
    			//G1 Young Generation
    			//Garbage collection optimized for short pausetimes Young Collector
    			//Garbage collection optimized for throughput Young Collector
    			//Garbage collection optimized for deterministic pausetimes Young Collector
                if (fullGC == null &&
                	(gcName.endsWith("Old Collector")
                	|| "ConcurrentMarkSweep".equals(gcName) 
                    || "MarkSweepCompact".equals(gcName) 
                    || "PS MarkSweep".equals(gcName))
                ) {
                    fullGC = gcMXBean;
                } else if (youngGC == null &&
                		(gcName.endsWith("Young Generation")
                		|| "ParNew".equals(gcName) 
                        || "Copy".equals(gcName) 
                        || "PS Scavenge".equals(gcName)) 
                ) {
                    youngGC = gcMXBean;
                }
            }
        }//static
    
        //YGC名称
        static public String getYoungGCName() {
            return youngGC == null ? "" : youngGC.getName();
        }
        
        //YGC总次数
        static public long getYoungGCCollectionCount() {
            return youngGC == null ? 0 : youngGC.getCollectionCount();
        }
    
        //YGC总时间
        static public long getYoungGCCollectionTime() {
            return youngGC == null ? 0 : youngGC.getCollectionTime();
        }
    
        //FGC名称
        static public String getFullGCName() {
            return fullGC == null ? "" : fullGC.getName();
        }
        
        //FGC总次数
        static public long getFullGCCollectionCount() {
            return fullGC == null ? 0 : fullGC.getCollectionCount();
        }
    
        //FGC总次数
        static public long getFullGCCollectionTime() {
            return fullGC == null ? 0 : fullGC.getCollectionTime();
        }
        
        public static void main(String[] args) {
        	List<List<Long>> listRoot = new ArrayList<List<Long>>();
        	for(;;) {
        		System.out.println("=======================================================================");
    	        System.out.println("getYoungGCName: " + JVMGCUtils.getYoungGCName());
    	        System.out.println("getYoungGCCollectionCount: " + JVMGCUtils.getYoungGCCollectionCount());
    	        System.out.println("getYoungGCCollectionTime: " + JVMGCUtils.getYoungGCCollectionTime());
    	        System.out.println("getFullGCName: " + JVMGCUtils.getFullGCName());
    	        System.out.println("getFullGCCollectionCount: " + JVMGCUtils.getFullGCCollectionCount());
    	        System.out.println("getFullGCCollectionTime: " + JVMGCUtils.getFullGCCollectionTime());
    	        List<Long> list = new ArrayList<Long>(1000);
    	        listRoot.add(list);
    	        try {	        	
    				Thread.sleep(3000);
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    	        if(list.size() > 1) {
    	        	list.remove(0);
    	        }
    	        Runtime.getRuntime().gc();
        	}
        }
    }
    package com.tjy.util;
    
    import java.lang.management.ClassLoadingMXBean;
    import java.lang.management.CompilationMXBean;
    import java.lang.management.ManagementFactory;
    import java.lang.management.RuntimeMXBean;
    import java.util.Properties;
    
    /**
     * 类描述:JVM信息工具类
     * 
     **/
    public class JVMInfoUtils {
        static private RuntimeMXBean runtime = ManagementFactory.getRuntimeMXBean();
        static private ClassLoadingMXBean classLoad = ManagementFactory.getClassLoadingMXBean();
        //可能为null
        static private CompilationMXBean compilation = ManagementFactory.getCompilationMXBean();
        static private Properties properties = System.getProperties();
    
    	/**
    	 * 获取JVM进程PID
    	 * @return
    	 */
    	public static String getPID() {
    		String pid = System.getProperty("pid");
    		if (pid == null) {
    	        String name = runtime.getName();
    	        if(name != null) {
    	        	pid = name.split("@")[0]; 
    	        	System.setProperty("pid", pid);        	                    	
    	        } 	        
    		}
    		return pid;
    	}
    	
        /**
         * 获取JVM规范名称
         * @return
         */
        static public String getJVMSpecName() {
            return runtime.getSpecName();
        }
    
        /**
         * 获取JVM规范运营商
         * @return
         */
        static public String getJVMSpecVendor() {
            return runtime.getSpecVendor();
        }
    
        /**
         * 获取JVM规范版本(如:1.7)
         * @return
         */
        static public String getJVMSpecVersion() {
            return runtime.getSpecVersion();
        }
    
        /**
         * 获取JVM名称
         * @return
         */
        static public String getJVMName() {
            return runtime.getVmName();
        }
    
        /**
         * 获取Java的运行环境版本(如:1.7.0_67)
         * @return
         */
        static public String getJavaVersion() {
            return getSystemProperty("java.version");
        }
        
        /**
         * 获取JVM运营商
         * @return
         */
        static public String getJVMVendor() {
            return runtime.getVmVendor();
        }
    
        /**
         * 获取JVM实现版本(如:25.102-b14)
         * @return
         */
        static public String getJVMVersion() {
            return runtime.getVmVersion();
        }
    
        /**
         * 获取JVM启动时间
         * @return
         */
        static public long getJVMStartTimeMs() {
            return runtime.getStartTime();
        }
    
        /**
         * 获取JVM运行时间
         * @return
         */
        static public long getJVMUpTimeMs() {
            return runtime.getUptime();
        }
    
        /**
         * 获取JVM当前加载类总量
         * @return
         */
        static public long getJVMLoadedClassCount() {
            return classLoad.getLoadedClassCount();
        }
    
        /**
         * 获取JVM已卸载类总量
         * @return
         */
        static public long getJVMUnLoadedClassCount() {
            return classLoad.getUnloadedClassCount();
        }
    
        /**
         * 获取JVM从启动到现在加载类总量
         * @return
         */
        static public long getJVMTotalLoadedClassCount() {
            return classLoad.getTotalLoadedClassCount();
        }
    
        /**
         * 获取JIT编译器名称
         * @return
         */
        static public String getJITName() {
            return null == compilation ? "" : compilation.getName();
        }
    
        /**
         * 获取JIT总编译时间
         * @return
         */
        static public long getJITTimeMs() {
            if (null!=compilation && compilation.isCompilationTimeMonitoringSupported()) {
                return compilation.getTotalCompilationTime();
            }
            return -1;
        }
    
        /**
         * 获取指定key的属性值
         * @param key
         * @return
         */
        static public String getSystemProperty(String key) {
            return properties.getProperty(key);
        }
    
        static public Properties getSystemProperty() {
            return properties;
        }
    }
    package com.tjy.util;
    
    import java.lang.management.ManagementFactory;
    import java.lang.management.MemoryMXBean;
    import java.lang.management.MemoryPoolMXBean;
    import java.lang.management.MemoryUsage;
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * 类描述:JVM内存信息工具类
     * 
     **/
    public class JVMMemoryUtils {
        static private MemoryMXBean memoryMXBean;
        static private MemoryPoolMXBean edenSpaceMxBean;
        static private MemoryPoolMXBean survivorSpaceMxBean;
        static private MemoryPoolMXBean oldGenMxBean;
        static private MemoryPoolMXBean permGenMxBean;
        static private MemoryPoolMXBean codeCacheMxBean;
        
    	/**
    	 * JVM内存区域使用情况。</br>
    	 * <pre>
    	 * init:初始内存大小(字节)
    	 * used:当前使用内存大小(字节)
    	 * committed:已经申请分配的内存大小(字节)
    	 * max:最大内存大小(字节)
    	 * usedPercent:已经申请分配内存与最大内存大小的百分比
    	 * </pre>
    	 * @author tangjiyu
    	 */
    	static public class JVMMemoryUsage {
    		//初始内存大小(字节)
    	    private long init;
    	    //当前使用内存大小(字节)
    	    private long used;
    	    //已经申请分配的内存大小(字节)
    	    private long committed;
    	    //最大内存大小(字节)
    	    private long max;
    	    //已经申请分配内存与最大内存大小的百分比
    	    private float usedPercent;
    	    
    	    public JVMMemoryUsage(MemoryUsage memoryUsage) {
    	    	this.setMemoryUsage(memoryUsage);
    	    	//this(memoryUsage.getInit(), memoryUsage.getUsed(), memoryUsage.getCommitted(), memoryUsage.getMax());
    		}
    	    
    		public JVMMemoryUsage(long init, long used, long committed, long max) {
    			super();			
    			this.setMemoryUsage(init, used, committed, max);
    		}
    		
    		private void setMemoryUsage(MemoryUsage memoryUsage) {
    	    	if(memoryUsage!=null) {
    	    		this.setMemoryUsage(memoryUsage.getInit(), memoryUsage.getUsed(), memoryUsage.getCommitted(), memoryUsage.getMax());
    	    	} else {
    	    		this.setMemoryUsage(0, 0, 0, 0);
    	    	}
    		}
    		
    		private void setMemoryUsage(long init, long used, long committed, long max) {
    			this.init = init;
    			this.used = used;		
    			this.committed = committed;		
    			this.max = max;
    			if(this.used>0 && max>0) {
    				this.usedPercent = used * Float.valueOf("1.0") / max;
    			} else {
    				this.usedPercent = 0;
    			}
    		}
    		
    		public long getInit() {
    			return init;
    		}
    		public long getUsed() {
    			return used;
    		}
    		public long getCommitted() {
    			return committed;
    		}
    		public long getMax() {
    			return max;
    		}
    		public float getUsedPercent() {
    			return usedPercent;
    		}
    		
    		@Override
    		public String toString() {
    			StringBuffer buf = new StringBuffer();
    		    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)");
    		    buf.append("usedPercent = " + usedPercent);
    		    return buf.toString();
    		}	
    	}
    	
        static {
            memoryMXBean = ManagementFactory.getMemoryMXBean();
            
            List<MemoryPoolMXBean> memoryPoolMXBeanList = ManagementFactory.getMemoryPoolMXBeans();        
            for (final MemoryPoolMXBean memoryPoolMXBean : memoryPoolMXBeanList) {
    			String poolName = memoryPoolMXBean.getName();
    			if(poolName==null) {
    				continue;
    			}
    			// 官方JVM(HotSpot)提供的MemoryPoolMXBean
    			// JDK1.7/1.8 Eden区内存池名称: "Eden Space" 或  "PS Eden Space"、 “G1 Eden Space”(和垃圾收集器有关)
    			// JDK1.7/1.8 Survivor区内存池名称:"Survivor Space" 或 "PS Survivor Space"、“G1 Survivor Space”(和垃圾收集器有关)
    			// JDK1.7  老区内存池名称: "Tenured Gen" 
    			// JDK1.8  老区内存池名称:"Old Gen" 或 "PS Old Gen"、“G1 Old Gen”(和垃圾收集器有关)
    			// JDK1.7  方法/永久区内存池名称: "Perm Gen" 或 "PS Perm Gen"(和垃圾收集器有关)
    			// JDK1.8  方法/永久区内存池名称:"Metaspace"(注意:不在堆内存中)
    			// JDK1.7/1.8  CodeCache区内存池名称: "Code Cache" 
    			if (edenSpaceMxBean==null && poolName.endsWith("Eden Space")) {
    				edenSpaceMxBean = memoryPoolMXBean;
    			} else if (survivorSpaceMxBean==null && poolName.endsWith("Survivor Space")) {
    				survivorSpaceMxBean = memoryPoolMXBean;
    			} else if (oldGenMxBean==null && (poolName.endsWith("Tenured Gen") || poolName.endsWith("Old Gen"))) {
    				oldGenMxBean = memoryPoolMXBean;
    			} else if (permGenMxBean==null && (poolName.endsWith("Perm Gen") || poolName.endsWith("Metaspace"))) {
    				permGenMxBean = memoryPoolMXBean;
    			}  else if (codeCacheMxBean==null && poolName.endsWith("Code Cache")) {
    				codeCacheMxBean = memoryPoolMXBean;
    			} 
    		}
        }// static
    
    	
        /**
         * 获取堆内存情况
         * @return 不能获取到返回null
         */
        static public JVMMemoryUsage getHeapMemoryUsage() {
        	if(memoryMXBean!=null) {
        		final MemoryUsage usage =memoryMXBean.getHeapMemoryUsage();
        		if(usage!=null) {
        			return new JVMMemoryUsage(usage);
        		}
        	}
            return null;
        }
    
        /**
         * 获取堆外内存情况
         * @return 不能获取到返回null
         */
        static public JVMMemoryUsage getNonHeapMemoryUsage() {
        	if(memoryMXBean!=null) {
        		final MemoryUsage usage =memoryMXBean.getNonHeapMemoryUsage();
        		if(usage!=null) {
        			return new JVMMemoryUsage(usage);
        		}
        	}
            return null;
        }
        
        /**
         * 获取Eden区内存情况
         * @return 不能获取到返回null
         */
        static public JVMMemoryUsage getEdenSpaceMemoryUsage() {
        	return getMemoryPoolUsage(edenSpaceMxBean);
        }
        
        /**
         * 获取Eden区内存峰值(从启动或上一次重置开始统计),并重置
         * @return 不能获取到返回null
         */
        static public JVMMemoryUsage getAndResetEdenSpaceMemoryPeakUsage() {
        	return getAndResetMemoryPoolPeakUsage(edenSpaceMxBean);
        }
         
        /**
         * 获取Survivor区内存情况
         * @return 不能获取到返回null
         */
        static public JVMMemoryUsage getSurvivorSpaceMemoryUsage() {
        	return getMemoryPoolUsage(survivorSpaceMxBean);
        }
        
        /**
         * 获取Survivor区内存峰值(从启动或上一次重置开始统计),并重置
         * @return 不能获取到返回null
         */
        static public JVMMemoryUsage getAndResetSurvivorSpaceMemoryPeakUsage() {
        	return getAndResetMemoryPoolPeakUsage(survivorSpaceMxBean);
        }
        
        /**
         * 获取老区内存情况
         * @return 不能获取到返回null
         */
        static public JVMMemoryUsage getOldGenMemoryUsage() {
        	return getMemoryPoolUsage(oldGenMxBean);
        }
        
        /**
         * 获取老区内存峰值(从启动或上一次重置开始统计),并重置
         * @return 不能获取到返回null
         */
        static public JVMMemoryUsage getAndResetOldGenMemoryPeakUsage() {
        	return getAndResetMemoryPoolPeakUsage(oldGenMxBean);
        }
        
        /**
         * 获取永久区/方法区内存情况
         * @return 不能获取到返回null
         */
        static public JVMMemoryUsage getPermGenMemoryUsage() {
        	return getMemoryPoolUsage(permGenMxBean);
        }
    
        /**
         * 获取永久区/方法区内存峰值(从启动或上一次重置开始统计),并重置
         * @return 不能获取到返回null
         */
        static public JVMMemoryUsage getAndResetPermGenMemoryPeakUsage() {
        	return getAndResetMemoryPoolPeakUsage(permGenMxBean);
        }
        
        /**
         * 获取CodeCache区内存情况
         * @return 不能获取到返回null
         */
        static public JVMMemoryUsage getCodeCacheMemoryUsage() {
        	return getMemoryPoolUsage(codeCacheMxBean);
        }
        
        /**
         * 获取CodeCache区内存峰值(从启动或上一次重置开始统计),并重置
         * @return 不能获取到返回null
         */
        static public JVMMemoryUsage getAndResetCodeCacheMemoryPeakUsage() {
        	return getAndResetMemoryPoolPeakUsage(codeCacheMxBean);
        }
       
        static private JVMMemoryUsage getMemoryPoolUsage(MemoryPoolMXBean memoryPoolMXBean) {
        	if(memoryPoolMXBean!=null) {
    			final MemoryUsage usage = memoryPoolMXBean.getUsage();
    			if(usage!=null) {
    				return new JVMMemoryUsage(usage);
    			}
        	}
    		return null;
    	}
        
        static private JVMMemoryUsage getAndResetMemoryPoolPeakUsage(MemoryPoolMXBean memoryPoolMXBean) {
        	if(memoryPoolMXBean!=null) {
    			final MemoryUsage usage = memoryPoolMXBean.getPeakUsage();
    			if(usage!=null) {
    				memoryPoolMXBean.resetPeakUsage();
    				return new JVMMemoryUsage(usage);
    			}
        	}
    		return null;
    	}
    
        public static void main(String[] args) {
        	List<List<Long>> listRoot = new ArrayList<List<Long>>();
        	for(;;) {
        		System.out.println("=======================================================================");
    	        System.out.println("getHeapMemoryUsage: " + JVMMemoryUtils.getHeapMemoryUsage());
    	        System.out.println("getNonHeapMemoryUsage: " + JVMMemoryUtils.getNonHeapMemoryUsage());
    	        System.out.println("getEdenSpaceMemoryUsage: " + JVMMemoryUtils.getEdenSpaceMemoryUsage());
    	        System.out.println("getAndResetEdenSpaceMemoryPeakUsage: " + JVMMemoryUtils.getAndResetEdenSpaceMemoryPeakUsage());
    	        System.out.println("getSurvivorSpaceMemoryUsage: " + JVMMemoryUtils.getSurvivorSpaceMemoryUsage());
    	        System.out.println("getAndResetSurvivorSpaceMemoryPeakUsage: " + JVMMemoryUtils.getAndResetSurvivorSpaceMemoryPeakUsage());
    	        System.out.println("getOldGenMemoryUsage: " + JVMMemoryUtils.getOldGenMemoryUsage());
    	        System.out.println("getAndResetOldGenMemoryPeakUsage: " + JVMMemoryUtils.getAndResetOldGenMemoryPeakUsage());
    	        System.out.println("getPermGenMemoryUsage: " + JVMMemoryUtils.getPermGenMemoryUsage());
    	        System.out.println("getAndResetPermGenMemoryPeakUsage: " + JVMMemoryUtils.getAndResetPermGenMemoryPeakUsage());
    	        System.out.println("getCodeCacheMemoryUsage: " + JVMMemoryUtils.getCodeCacheMemoryUsage());
    	        System.out.println("getAndResetCodeCacheMemoryPeakUsage: " + JVMMemoryUtils.getAndResetCodeCacheMemoryPeakUsage());
    	        List<Long> list = new ArrayList<Long>(10000);
    	        listRoot.add(list);
    	        try {	        	
    				Thread.sleep(3000);
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    	        
    	        if(list.size() > 1) {
    	        	list.remove(0);
    	        }
    	        Runtime.getRuntime().gc();
        	}
        }
    }

     

    package com.tjy.util;
    
    import java.lang.management.ManagementFactory;
    import java.lang.management.ThreadMXBean;
    
    /**
     * 类描述:JVM 线程信息工具类
     * 
     **/
    public class JVMThreadUtils {
        static private ThreadMXBean threadMXBean;
    
        static {
            threadMXBean = ManagementFactory.getThreadMXBean();
        }
    
        /**
         * Daemon线程总量
         * @return
         */
        static public int getDaemonThreadCount() {
            return threadMXBean.getDaemonThreadCount();
        }
    
        /**
         * 当前线程总量
         * @return
         */
        static public int getThreadCount() {
            return threadMXBean.getThreadCount();
        }
        
        /**
         * 获取线程数量峰值(从启动或resetPeakThreadCount()方法重置开始统计)
         * @return
         */
        static public int getPeakThreadCount() {
            return threadMXBean.getPeakThreadCount();
        }
        
        /**
         * 获取线程数量峰值(从启动或resetPeakThreadCount()方法重置开始统计),并重置
         * @return
         * @Throws java.lang.SecurityException - if a security manager exists and the caller does not have ManagementPermission("control").
         */
        static public int getAndResetPeakThreadCount() {
        	int count = threadMXBean.getPeakThreadCount();
        	resetPeakThreadCount();
            return count;
        }
        
        /**
         * 重置线程数量峰值
         * @Throws java.lang.SecurityException - if a security manager exists and the caller does not have ManagementPermission("control").
         */
        static public void resetPeakThreadCount() {
            threadMXBean.resetPeakThreadCount();
        }
        
        /**
         * 死锁线程总量
         * @return
         * @Throws IllegalStateException 没有权限或JVM不支持的操作
         */
        static public int getDeadLockedThreadCount() {
            try {
                long[] deadLockedThreadIds = threadMXBean.findDeadlockedThreads();
                if (deadLockedThreadIds == null) {
                    return 0;
                }
                return deadLockedThreadIds.length;
            } catch (Exception e) {
                throw new IllegalStateException(e.getMessage(), e);
            }
        }
        
        public static void main(String[] args) {
        	for(;;) {
        		System.out.println("=======================================================================");
    	        System.out.println("getDaemonThreadCount: " + JVMThreadUtils.getDaemonThreadCount());
    	        System.out.println("getNonHeapMemoryUsage: " + JVMThreadUtils.getThreadCount());
    	        System.out.println("getPeakThreadCountAndReset: " + JVMThreadUtils.getAndResetPeakThreadCount());
    	        System.out.println("getDeadLockedThreadCount: " + JVMThreadUtils.getDeadLockedThreadCount());
    	        try {	        	
    				Thread.sleep(5000);
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
        	}
        }
    }
    package com.tjy.task.impl.app;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Map;
    import java.util.Map.Entry;
    
    import com.tjy.util.JVMGCUtils;
    import com.tjy.util.JVMInfoUtils;
    import com.tjy.util.JVMMemoryUtils;
    import com.tjy.util.JVMMemoryUtils.JVMMemoryUsage;
    import com.tjy.util.JVMThreadUtils;
    
    /**
     * 
     * 应用状态监控,包括应用类型,版本,所在的tomcat名以及数据库连接等信息(代码有删减)
     * 
     * 
     */
    public class ApplicationMonitorTask extends AbstractMonitorTask<ApplicationMonitorMessage> {
    
    	@Override
    	protected ApplicationMonitorMessage doRun() {
    		return this.createMessage();
    	}
    
    	private ApplicationMonitorMessage createMessage() {
    		ApplicationMonitorMessage message = new ApplicationMonitorMessage();
    		// APP
    		message.setVersion(ErlangMonitorConfigManager.getConfig().getAppVersion());
    		// JVM
    		setJVMInfo(message);
    		// DB
    		setDBInfo(message);
    		return message;
    	}
    
    	private void setJVMInfo(ApplicationMonitorMessage message) {
    		try {
    			message.setPid(Integer.parseInt(JVMInfoUtils.getPID()));
    		} catch (Exception e) {
    		}
    		message.setJavaVersion(JVMInfoUtils.getJavaVersion());
    		message.setRunTime(JVMInfoUtils.getJVMUpTimeMs());
    		message.setLoadedClassCount(JVMInfoUtils.getJVMLoadedClassCount());
    		message.setUnloadedClassCount(JVMInfoUtils.getJVMUnLoadedClassCount());
    		JVMMemoryUsage heapMemoryUsage = JVMMemoryUtils.getHeapMemoryUsage();
    		if (heapMemoryUsage != null) {
    			message.setHeapTotal(heapMemoryUsage.getMax());
    			message.setHeapUsed(heapMemoryUsage.getUsed());
    			message.setHeapUsedPercent(heapMemoryUsage.getUsedPercent());
    		}
    		JVMMemoryUsage nonHeapMemoryUsage = JVMMemoryUtils.getNonHeapMemoryUsage();
    		if (nonHeapMemoryUsage != null) {
    			message.setNonHeapTotal(nonHeapMemoryUsage.getMax());
    			message.setNonHeapUsed(nonHeapMemoryUsage.getUsed());
    			message.setNonHeapUsedPercent(nonHeapMemoryUsage.getUsedPercent());
    		}
    		JVMMemoryUsage edenMemoryUsage = JVMMemoryUtils.getEdenSpaceMemoryUsage();
    		if (edenMemoryUsage != null) {
    			message.setEdenTotal(edenMemoryUsage.getMax());
    			message.setEdenUsed(edenMemoryUsage.getUsed());
    			message.setEdenUsedPercent(edenMemoryUsage.getUsedPercent());
    		}
    		JVMMemoryUsage edenPeakMemoryUsage = JVMMemoryUtils.getAndResetEdenSpaceMemoryPeakUsage();
    		if (edenPeakMemoryUsage != null) {
    			message.setEdenPeakUsedPercent(edenPeakMemoryUsage.getUsedPercent());
    		}
    		JVMMemoryUsage survivorMemoryUsage = JVMMemoryUtils.getSurvivorSpaceMemoryUsage();
    		if (survivorMemoryUsage != null) {
    			message.setSurvivorTotal(survivorMemoryUsage.getMax());
    			message.setSurvivorUsed(survivorMemoryUsage.getUsed());
    			message.setSurvivorUsedPercent(survivorMemoryUsage.getUsedPercent());
    		}
    		JVMMemoryUsage survivorPeakMemoryUsage = JVMMemoryUtils.getAndResetSurvivorSpaceMemoryPeakUsage();
    		if (survivorPeakMemoryUsage != null) {
    			message.setSurvivorPeakUsedPercent(survivorPeakMemoryUsage.getUsedPercent());
    		}
    		JVMMemoryUsage oldGenMemoryUsage = JVMMemoryUtils.getOldGenMemoryUsage();
    		if (oldGenMemoryUsage != null) {
    			message.setOldTotal(oldGenMemoryUsage.getMax());
    			message.setOldUsed(oldGenMemoryUsage.getUsed());
    			message.setOldUsedPercent(oldGenMemoryUsage.getUsedPercent());
    		}
    		JVMMemoryUsage oldGenPeakMemoryUsage = JVMMemoryUtils.getAndResetOldGenMemoryPeakUsage();
    		if (oldGenPeakMemoryUsage != null) {
    			message.setOldPeakUsedPercent(oldGenPeakMemoryUsage.getUsedPercent());
    		}
    		JVMMemoryUsage permGenMemoryUsage = JVMMemoryUtils.getPermGenMemoryUsage();
    		if (permGenMemoryUsage != null) {
    			message.setPermTotal(permGenMemoryUsage.getMax());
    			message.setPermUsed(permGenMemoryUsage.getUsed());
    			message.setPermUsedPercent(permGenMemoryUsage.getUsedPercent());
    		}
    		JVMMemoryUsage permGenPeakMemoryUsage = JVMMemoryUtils.getAndResetPermGenMemoryPeakUsage();
    		if (permGenPeakMemoryUsage != null) {
    			message.setPermPeakUsedPercent(permGenPeakMemoryUsage.getUsedPercent());
    		}
    		JVMMemoryUsage codeCacheGenMemoryUsage = JVMMemoryUtils.getCodeCacheMemoryUsage();
    		if (codeCacheGenMemoryUsage != null) {
    			message.setCodeCacheTotal(codeCacheGenMemoryUsage.getMax());
    			message.setCodeCacheUsed(codeCacheGenMemoryUsage.getUsed());
    			message.setCodeCacheUsedPercent(codeCacheGenMemoryUsage.getUsedPercent());
    		}
    		JVMMemoryUsage codeCacheGenPeakMemoryUsage = JVMMemoryUtils.getAndResetCodeCacheMemoryPeakUsage();
    		if (codeCacheGenPeakMemoryUsage != null) {
    			message.setCodeCachePeakUsedPercent(codeCacheGenPeakMemoryUsage.getUsedPercent());
    		}
    
    		message.setYgcName(JVMGCUtils.getYoungGCName());
    		message.setYgc(JVMGCUtils.getYoungGCCollectionCount());
    		message.setYgcTime(JVMGCUtils.getYoungGCCollectionTime());
    		message.setFgcName(JVMGCUtils.getFullGCName());
    		message.setFgc(JVMGCUtils.getFullGCCollectionCount());
    		message.setFgcTime(JVMGCUtils.getFullGCCollectionTime());
    
    		message.setThreadCount(JVMThreadUtils.getThreadCount());
    		message.setThreadPeakCount(JVMThreadUtils.getAndResetPeakThreadCount());
    		message.setUserThreadCount(message.getThreadCount() - JVMThreadUtils.getDaemonThreadCount());
    		message.setDeadLockedThreadCount(JVMThreadUtils.getDeadLockedThreadCount());
    	}
    
    }
    

     

    【参考文档】

              《JVM监控》

    展开全文
  • vmmap 观察jvm内存 监控jvm jvm线程
  • vjtop监控jvm

    2018-12-29 10:19:44
    vjtop监控jvm,可以获取占用cpu最高的代码 可以实时观察jvm内存占用情况
  • visualvm监控jvm及远程jvm监控方法
  • LR监控JVM代码

    2018-07-23 14:03:15
    LR监控JVM代码,复制代码到action中,通过control中可视化图表,可以时时监控JVM
  • JConsole监控JVM

    2012-06-11 11:18:34
    JConsole监控JVM
  • 普罗米修斯+grafana监控jvm

    千次阅读 2021-06-15 18:10:42
    普罗米修斯+grafana监控jvm 1.1 首先搭建普罗米修斯 1.2 搭建grafana yum -y install https://dl.grafana.com/oss/release/grafana-7.5.4-1.x86_64.rpm service grafana-server start 1.3 拉去监控jvm的开源产品并...

    普罗米修斯+grafana监控jvm

    1.1 首先搭建普罗米修斯
    请自寻百度
    1.2 搭建grafana

    yum -y install https://dl.grafana.com/oss/release/grafana-7.5.4-1.x86_64.rpm
    service grafana-server start
    

    1.3 拉去监控jvm的开源产品并监控和启动
    地址发送自行选择

    https://repo1.maven.org/maven2/io/prometheus/jmx/jmx_prometheus_javaagent/0.15.0/
    

    1.3.1 一起启动java包和监控:我这边把文件单独创建了一个文件夹方便寻找

    在这里插入图片描述

    java -javaagent:./jmx_prometheus_javaagent-0.14.0.jar=8586:./jmx_exporter_config.yaml -jar -Xms4g -Xmx4g 自己的包.jar 2&>>xixi.txt & # 启动并挂在到后台
    

    其中有2个文件需要直接去写如图所示

    [root@iZ2ze9po4ho3yqhv4crcibZ jmx_prometheus_javaagent]# vim 		
    jmx_exporter_config.yaml
    lowercaseOutputLabelNames: true
    lowercaseOutputName: true
    whitelistObjectNames: ["java.lang:type=OperatingSystem"]
    blacklistObjectNames: []
    rules:
    - pattern: 'java.lang<type=OperatingSystem><>	(committed_virtual_memory|free_physical_memory|free_swap_space|tota		l_physical_memory|total_swap_space)_size:'
    name: os_$1_bytes
    type: GAUGE
    attrNameSnakeCase: true
    - pattern: 'java.lang<type=OperatingSystem><>((?!process_cpu_time)\w+):'
    name: os_$1
    type: GAUGE
    attrNameSnakeCase: true
    

    添加普罗米修斯的配置文件
    在这里插入图片描述

    在这里插入图片描述

    1.4 验证
    IP+3000用户名admin密码admin
    进入之后点击+>进口》写入8563进行加载然后下一步就ok了

    在这里插入图片描述
    验证结果:在这里插入图片描述

    展开全文
  • 主要介绍了idea中安装VisualVM监控jvm的教程,本文通过图文并茂的形式给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
  • 通过在应用中埋点来暴露 JVM 数据,使用 ARMS Prometheus 监控抓取 JVM 数据,并借助 ARMS Prometheus Grafana 大盘来展示 JVM 数据,即可实现通过 ARMS Prometheus 监控 JVM 的目的。 前提条件 下载Demo 工程 ...

    通过在应用中埋点来暴露 JVM 数据,使用 ARMS Prometheus 监控抓取 JVM 数据,并借助 ARMS Prometheus Grafana 大盘来展示 JVM 数据,即可实现通过 ARMS Prometheus 监控 JVM 的目的。

    前提条件

    背景信息

    本教程的操作流程如图所示。


    How it works

    步骤一:详情操作:https://help.aliyun.com/document_detail/139661.html

     

    执行结果

    配置完毕后的 ARMS Prometheus Grafana JVM 大盘如图所示。
    ARMS Prometheus Grafana Dashboard for JVM

    展开全文
  • Jprofiler监控JVM性能

    千次阅读 2016-07-28 14:27:27
    Jprofiler监控JVM性能 Jprofiler简介 Jprofiler是一个重量级的JVM监控工具,提供对JVM精确监控,其中堆遍历、CPU剖析、线程剖析看成定位当前系统瓶颈的得力工具。可以统计压测过程中JVM的监控数据,定位性能问题。 ...

    Jprofiler监控JVM性能

     

    软件测试技术交流群 :

    1、QQ交流群:群号 429183023

    2、添加JeongJinWin,或者扫描头像二维码

     

    1. Jprofiler简介

      Jprofiler是一个重量级的JVM监控工具,提供对JVM精确监控,其中堆遍历、CPU剖析、线程剖析看成定位当前系统瓶颈的得力工具。可以统计压测过程中JVM的监控数据,定位性能问题。

    2. Jprofiler本地安装

      Jprofiler下载地址:http://pan.baidu.com/s/1bJI4P4

      里面存放了Jprofiler7和Jprofiler8(均为64位版本),可自行选择版本。

       

      1. Jprofiler本地安装:

        请一定勾选Native libraries for profiling agent下的选项,这些是相应平台下远程服务器下应当部署的Jprofiler库。(可自行选择,例如你远程监控的服务器是linux的,请勾选Liunx x86***.如果不理解,可全部勾选)

        勾选之后在本地jprofiler的路径下会有以下文件价,文件价中是相应远程服务器上Jprofiler库文件。因为我这种部署方法不会在远程服务器上再安装Jprofiler,所以这些库文件必须进行下载。

         

      2. 远程服务器Jprofiler配置

        1)、进入本机Jprofiler的bin目录下,根据自己的远程服务器系统版本找到相应的需要的Jprofiler服务端。例如我要监控的远程机器系统是linux X64的,我需要将linux-x64这个文件夹放到远程服务器端。

        2)、在服务器端app目录下新建路径jprofiler/bin,将linux-x64文件夹copy到/app/jprofiler/bin目录下

    3. 设置本地Jprofiler

      1)、新建一个session:Session -> Integration Wizard -> New Server integration.

      2)、选择部署服务的服务器,比如远程是Jetty7,则选择Jetty 7.x

      3)、选择本地或者远程服务器,如果要监控远程服务器,应当点选On a remote computer 并且选择相应的服务器系统版本。Linux获取版本信息命令

      "cat /proc/version"

      4)、选择要监控的服务器的JVM. 例如远程安装的JDK1.7,则JVM Vendor选择Oracle、Version选择1.7.0,Mode选择默认,如果JVM为64位,需要勾选64-bit JVM.

       

       

      5)、选择Startup immediately,connect later with the Jprofiler GUI,表示先确定,然后之后进行连接。

       

      6)、远程机器的IP地址

      7)、之后需要配置remote installation directory,即远程服务器上jprofile安装的路径,之前我们已经在远程机器上安装了Jprofiler,所以这里填写我们之前的安装路径/app/jprofiler。

      注意:这个路径是跟jprofiler启动时调用的库有关,所以一定要记住。

      8)、下载相应的启动文件到本地,本人是jetty服务器,则将服务器上的start.jar文件下载至本地,例如如果是linux服务器上的tomcat,那么将服务器上tomcat的启动文件startup.sh下载至本地。

      session配置完成后会生成一个startup_jprofiler.sh启动文件。这个文件要部署到远程服务器容器启动路径下。

      9)、填写监控端口,默认为8849。

      10)、然后接下来两部默认即可,点击finish

      11)、会在之前本地的start.jar目录下生成一个start_jetty_jprofiler.sh文件,将此文件拷贝到远程jetty目录下(与start.jar同目录)。Stop原先的jetty服务,重新使用start_jetty_jprofiler.sh开启Jetty服务"./ start_jetty_jprofiler.sh start "即可。

      介绍:如果是tomcat服务器,则步骤如下

      1.将新生成启动文件startup_jprofiler.sh上传到远程服务器tomcat启动路径下

      2.使用startup_jprofiler.sh启动容器,并从启动日志看是否出错。

       

    4. Jprofiler分析

      1)、内存视图。JProfiler的内存视图部分可以提供动态的内存使用状况更新视图和显示关于内存分配状况信息的视图。所有的视图都有几个聚集层并且能够显示现有存在的对象和作为垃圾回收的对象。

      2)、堆遍历器。在JProfiler的堆遍历器(Heap Walker)中,你可以对堆的状况进行快照。

      3)、CPU视图。主要用于获取当前线程处理时间,用于查找当前方法热点。

      Hot Spots

      显示消耗时间最多的方法的列表。对每个热点都能够显示回溯树。该热点可以按照方法请求,JDBC,JMS和JNDI服务请求以及按照URL请求来进行计算。

       

      以上介绍的Jprofiler部分常用的JVM监控数据分析过程,想要了解更多可查看网上的另外CSDN博客技术介绍:http://blog.csdn.net/chendc201/article/details/22897999

    展开全文
  • JVM内存监控:VisualVM远程监控JVM

    千次阅读 2015-06-12 15:21:57
    简介 VisualVM是一个集成多个JDK命令行工具的可视化工具。可以作为Java应用程序性能分析和运行监控的工具。开发人员可以利用它来监控、分析线程信息...VisualVM远程监控JVM有两种方式,JMX连接和jstatd连接。配置过程中
  • zabbix监控jvm内存

    2019-09-11 14:49:00
    在本地我们可以通过jconsole或者jvisualvm进行监控jvm内存情况 不过正是环境一般都是部署在linux上,且不是桌面版,这个时候想监控,可以通过zabbix集成jmx实现 jvisualvm使用方式,参考...
  • VisualVM远程监控jvm状态 最近程序出现jvm异常问题,java VisualVM是一个比较好的jvm观察工具使用方法如下 ![创建远程连接主机](https://img-blog.csdnimg.cn/20191022150321715.png?x-oss-process=image/watermark...
  • zabbix3.2监控JVM状态

    千次阅读 2017-06-02 22:32:30
    zabbix3.2监控JVM状态,JMX监控数据的获取由专门的代理程序来实现,即Zabbix-Java-Gateway来负责数据的采集,Zabbix-Java-Gateway和JMX的Java程序之间通信获取数据
  • 在此留一下一篇还算比较使用的方式去监控jvm情况,也方便后续自己查看。 一、如何配置visualvm监控 其实有很多中工具可以分析jvm的内存情况,本文采用的是jdk内置的监控工具visualvm,默认目录在C:\Program Files\...
  • snmp监控 jvm

    千次阅读 2014-03-19 16:58:39
    snmp监控 jvm 我只用过TOMCAT,以此记录 一、原理:JAVA在设计之初已实现通过SNMP协议来提供查询JAVA运行程序情况,经过对被监控的主机一番配置后,JAVA会启动一个UDP协议监听的端口(大于1024,须自定义)用于提供...
  • 监控JVM内存?

    2015-07-13 21:32:35
    java程序运行时,总是想看看jvm运行的怎么样,那么监控JVM的工具有哪些呢?列举如下:本地(带图形环境): jvisualvm ——https://visualvm.java.net/zh_CN/gettingstarted.html JProfiler ——-JProfiler使用详细...
  • 点击进入_更多_Java千百问1、如何监控jvm的...了解jvm内存优化看这里:java内存如何优化我们通常使用Jdk工具来监控jvm的运行情况,当然目前有很多第三方产品是通过jdk提供的api来组织数据进行监控的。具体来说有如下
  • VisualVM远程监控JVM设置

    千次阅读 2014-05-16 21:50:52
    VisualVM远程监控JVM设置 配置 jstatd 的 security policy 文件 jstatd是一个监控 JVM 从创建到销毁过程中资源占用情况并提供远程监控接口的 RMI ( Remote Method Invocation ,远程方法调用)服务器程序,它是...
  • 使用visualvm 远程监控 JVM

    千次阅读 2018-11-14 14:21:21
    使用visualvm 远程监控 JVM #!/bin/bash java -Djava.rmi.server.hostname=10.153.14.8 \  -Dcom.sun.management.jmxremote \  -Dcom.sun.management.jmxremote.port=8888 \  -Dcom.sun.management.jmxremot...
  • 不会监控 JVM 的资源和性能?jstat 了解一下。
  • Hadoop YARN学习监控JVM和实时监控Ganglia、Ambari(5)1.0 监控ResourceManager进程Java虚拟机中堆空间的特定部分。 jstat工具,在JDK的bin目录,可以显示大量JVM统计信息。 1.1 JVM分析 一个Java虚拟机(JVM)进程被...
  • Zabbix监控JVM(微服务进程)

    千次阅读 2018-06-06 15:13:39
    老的方法感觉效果不好,又写了一个模板和...Zabbix监控JVM(微服务进程) 1、ZabbixServer端配置 Zabbix服务器需安装java,编译需添加启动参数--enable-java 本次安装的编译参数为: ./configure --prefi...
  • 1、如何监控jvm的运行情况 了解jvm内存模型看这里:java内存模型是什么样的  了解jvm内存管理看这里:jvm是如何管理内存的  了解jvm垃圾回收机制看这里:java垃圾回收机制是什么  了解jvm内存优化看这里:java...
  • 插件功能: 根据网上网上文档,自定义插件监控jvm对象,主要包括各个区域使用率,GC时间,用于对jvm参数调优效果进行监控对比。实现步骤: A,被监控主机 1.1 被监控主机部署监控脚本,获取指定tomcat的jvm运行参数;...
  • 使用JConsole远程监控JVM

    千次阅读 2012-09-15 14:16:59
    虽然可以使用LoadRunner编写脚本的方式并采用自定义数据项来监控JVM的内存消耗.但是终归还是第三方工具.所以这次采用JDK中自带的JConsole来监控JVM内存情况. 服务器环境:CentOS 6.2 + JDK1.6 + Tomcat6.0 首先在$...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 109,623
精华内容 43,849
关键字:

监控jvm