精华内容
下载资源
问答
  • java监控系统

    2018-05-15 14:35:41
    java监控系统,跟物联网打交道,公司项目------------------------------
  • java监控工具

    2016-06-23 08:52:53
    java监控工具
  • Java 通过PCF连接WebSphere MQ7.1以上版本获取数据。!!!
  • java 监控线程

    2014-06-27 16:34:49
    java 监控 线程
  • Automon是一个非常灵活的JAVA监控工具,它结合了AOP(AspectJ)以及JDK和其他依赖库的功能特性,以声明方式去监控你的Java代码。它可以与JAMon,JavaSimon,Yammer Metrics,StatsD和像 perf4j,log4j,sl4j这样的...
  • 下面小编就为大家带来一篇Java实现监控多个线程状态的简单实例。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 本文概要: 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监控》

    展开全文
  • 主要介绍了Java线程池运行状态监控实现解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • java监控系统链接和内存使用情况
  • 1.jps:查看当前运行着的java进程(仿linux下的ps),显示进程号  2. jinfo: 查参数jinfo -flagPermSize 2208(进程号) jinfo -flag MaxPermSize 2208(进程号) C:UsersWILL>jinfo Usage: jinfo <option> (to ...
  • java监控linux cpu使用率

    2010-07-15 10:29:17
    java实现linux下的cpu资源使用率监控
  • zabbix自动发现JAVA进程,并进行自动添加监控JAVA 进程的JVM数据,统计分析告警监控。 支持多种中间件,tomcat、weblogic、微服务方式部署JAVA应用监控。 自带发现脚本和监控脚本,以及zabbix导入模板。
  • 主要介绍了SHELL脚本监控JAVA进程,需要的朋友可以参考下
  • java监控开发示例

    2013-06-03 16:51:10
    java实现远程监控WINDOWS,linux案例
  • 今天小编就为大家分享一篇关于Java实现实时监控目录下文件变化的方法,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • 主要介绍了使用Java编写一个简单的Web的监控系统的例子,并且将重要信息转为XML通过网页前端显示,非常之实用,需要的朋友可以参考下
  • 基于JAVA网络远程监控系统软件的实现(源码)。基于JAVA网络远程监控系统软件的实现(源码)。基于JAVA网络远程监控系统软件的实现(源码)。
  • Java 监控线程池所有任务是否执行完毕 场景引入 在最近的工作中遇到一个需要批量生产百万数据并写入数据库的需求,先通过单线程的方式去实现,但是感觉效率一般,然后通过多线程的方式去改进,但是遇到下面的问题:...

    Java 监控线程池所有任务是否执行完毕

    场景引入

    在最近的工作中遇到一个需要批量生产百万数据并写入数据库的需求,先通过单线程的方式去实现,但是感觉效率一般,然后通过多线程的方式去改进,但是遇到下面的问题:

    生成数据的时候,每生成一条数据,就将数据丢入到集合中进行缓存,当集合中的数据量达到 500 的时候,就进行一次数据库写入操作,并清空集合。

    那么当我生成的数据量为 1200 的时候,就会出现最后 200 条没有写入到数据库的问题

    那么要解决这个问题,就要知道线程池的任务什么时候执行完毕,网上找了很多方法如:

    • 方案一 - 直接调用是否终止的方法
    executor.isTerminated()
    
    • 方案二 - 判断活跃线程数
    executor.getActiveCount() == 0
    
    • 方案三 - 设置一个较长的等待时间
    executor.awaitTermination(10000, TimeUnit.SECONDS);
    

    但是都没有达到我的目的(也有可能是我使用的姿势不对)

    最后尝试了下面的方法

    功能实现

    import lombok.extern.slf4j.Slf4j;
    import org.apache.commons.collections.CollectionUtils;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Random;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.ThreadPoolExecutor;
    
    @Slf4j
    public class ThreadPoolTest {
    
        static List<Integer> TEMP_LIST = new ArrayList<>(10);
    
        public static void main(String[] args) {
            ExecutorService executorService = Executors.newFixedThreadPool(3);
            Random random = new Random();
            int count = random.nextInt(100);
            for (int i = 0; i < count; i++) {
                int finalI = i;
                executorService.execute(() -> {
                    addToTemp(finalI * 2, false);
                    try {
                        Thread.sleep(random.nextInt(1000 * 2));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                });
            }
    
            // 监控线程执行情况
            monitor((ThreadPoolExecutor) executorService);
            // 最后一次数据插入
            addToTemp(null, true);
            System.out.println("结束");
        }
        
        /**
         * 添加数据到缓存
         *
         * @Author: Neo
         * @Date: 2019/12/19 21:46
         * @Version: 1.0
         */
        public static synchronized void addToTemp(Integer data, boolean focus) {
            if (null != data) {
                TEMP_LIST.add(data);
            }
    
            if (CollectionUtils.isNotEmpty(TEMP_LIST) && (CollectionUtils.size(TEMP_LIST) >= 10 || focus)) {
                // 模拟数据库写入
                log.info("执行一次插入,数据量:{}", CollectionUtils.size(TEMP_LIST));
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                TEMP_LIST.clear();
            }
        }
        
        /**
         * 监控线程执行情况
         * 一直阻塞到线程任务执行完毕
         *
         * @Author: Neo
         * @Date: 2019/12/19 21:09
         * @Version: 1.0
         */
        public static void monitor(ThreadPoolExecutor executor) {
            
            while (!isTerminated(executor)) {
                try {
                    int queueSize = executor.getQueue().size();
                    int activeCount = executor.getActiveCount();
                    long completedTaskCount = executor.getCompletedTaskCount();
                    long taskCount = executor.getTaskCount();
    
                    log.info("当前排队线程数:{},当前活动线程数:{},执行完成线程数:{},总线程数:{}", queueSize, activeCount, completedTaskCount, taskCount);
    
                    Thread.sleep(1000 * 5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    
        /**
         * 线程池任务是否执行完毕
         *
         * @Author: Neo
         * @Date: 2019/12/19 21:11
         * @Version: 1.0
         */
        public static boolean isTerminated(ThreadPoolExecutor executor) {
            return executor.getQueue().size() == 0 && executor.getActiveCount() == 0;
        }
    }
    
    展开全文
  • Java监控文件夹或文件的变动

    千次阅读 2016-09-08 14:41:49
    Java监控文件夹或文件的变动 很多时候我们需要对文件夹或者文件进行监控,已观察其是否被删除、创建或者修改,然后根据文件的行为进行相应的后续处理,以往的话多数是通过轮询去观察文件夹或者文件的变动,这样...

    Java监控文件夹或文件的变动

    很多时候我们需要对文件夹或者文件进行监控,已观察其是否被删除、创建或者修改,然后根据文件的行为进行相应的后续处理,以往的话多数是通过轮询去观察文件夹或者文件的变动,这样肯定会经过磁盘的I/O的操作,大大的降低了效率,而且不能及时的响应,如果要提升响应速度必定会增加磁盘的占用,不是明智之举。

    以往的文件夹监控流程如下:

    JavaSE 1.7提供了相关的API,去监视文件或者文件夹的变动,主要的API都在java.nio.file下面,其大概流程如下:

    Demo下载

    http://pan.baidu.com/s/1dDpTAAd

     代码 

    监控主类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    package  org.xdemo.superutil.j2se.filewatch;
     
    import  static  java.nio.file.LinkOption.NOFOLLOW_LINKS;
     
    import  java.io.File;
    import  java.io.IOException;
    import  java.nio.file.FileSystems;
    import  java.nio.file.FileVisitResult;
    import  java.nio.file.Files;
    import  java.nio.file.Path;
    import  java.nio.file.Paths;
    import  java.nio.file.SimpleFileVisitor;
    import  java.nio.file.StandardWatchEventKinds;
    import  java.nio.file.WatchEvent;
    import  java.nio.file.WatchEvent.Kind;
    import  java.nio.file.WatchKey;
    import  java.nio.file.WatchService;
    import  java.nio.file.attribute.BasicFileAttributes;
    import  java.util.HashMap;
    import  java.util.Map;
     
    /**
      * 文件夹监控
     
      * @author Goofy <a href="http://www.xdemo.org/">http://www.xdemo.org/</a>
      * @Date 2015年7月3日 上午9:21:33
      */
    public  class  WatchDir {
     
         private  final  WatchService watcher;
         private  final  Map<WatchKey, Path> keys;
         private  final  boolean  subDir;
     
         /**
          * 构造方法
         
          * @param file
          *            文件目录,不可以是文件
          * @param subDir
          * @throws Exception
          */
         public  WatchDir(File file,  boolean  subDir, FileActionCallback callback)  throws  Exception {
             if  (!file.isDirectory())
                 throw  new  Exception(file.getAbsolutePath() +  "is not a directory!" );
     
             this .watcher = FileSystems.getDefault().newWatchService();
             this .keys =  new  HashMap<WatchKey, Path>();
             this .subDir = subDir;
     
             Path dir = Paths.get(file.getAbsolutePath());
     
             if  (subDir) {
                 registerAll(dir);
             else  {
                 register(dir);
             }
             processEvents(callback);
         }
     
         @SuppressWarnings ( "unchecked" )
         static  <T> WatchEvent<T> cast(WatchEvent<?> event) {
             return  (WatchEvent<T>) event;
         }
     
         /**
          * 观察指定的目录
         
          * @param dir
          * @throws IOException
          */
         private  void  register(Path dir)  throws  IOException {
             WatchKey key = dir.register(watcher, StandardWatchEventKinds.ENTRY_CREATE, StandardWatchEventKinds.ENTRY_DELETE, StandardWatchEventKinds.ENTRY_MODIFY);
             keys.put(key, dir);
         }
     
         /**
          * 观察指定的目录,并且包括子目录
          */
         private  void  registerAll( final  Path start)  throws  IOException {
             Files.walkFileTree(start,  new  SimpleFileVisitor<Path>() {
                 @Override
                 public  FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs)  throws  IOException {
                     register(dir);
                     return  FileVisitResult.CONTINUE;
                 }
             });
         }
     
         /**
          * 发生文件变化的回调函数
          */
         @SuppressWarnings ( "rawtypes" )
         void  processEvents(FileActionCallback callback) {
             for  (;;) {
                 WatchKey key;
                 try  {
                     key = watcher.take();
                 catch  (InterruptedException x) {
                     return ;
                 }
                 Path dir = keys.get(key);
                 if  (dir ==  null ) {
                     System.err.println( "操作未识别" );
                     continue ;
                 }
     
                 for  (WatchEvent<?> event : key.pollEvents()) {
                     Kind kind = event.kind();
     
                     // 事件可能丢失或遗弃
                     if  (kind == StandardWatchEventKinds.OVERFLOW) {
                         continue ;
                     }
     
                     // 目录内的变化可能是文件或者目录
                     WatchEvent<Path> ev = cast(event);
                     Path name = ev.context();
                     Path child = dir.resolve(name);
                     File file = child.toFile();
                     if  (kind.name().equals(FileAction.DELETE.getValue())) {
                         callback.delete(file);
                     else  if  (kind.name().equals(FileAction.CREATE.getValue())) {
                         callback.create(file);
                     else  if  (kind.name().equals(FileAction.MODIFY.getValue())) {
                         callback.modify(file);
                     else  {
                         continue ;
                     }
     
                     // if directory is created, and watching recursively, then
                     // register it and its sub-directories
                     if  (subDir && (kind == StandardWatchEventKinds.ENTRY_CREATE)) {
                         try  {
                             if  (Files.isDirectory(child, NOFOLLOW_LINKS)) {
                                 registerAll(child);
                             }
                         catch  (IOException x) {
                             // ignore to keep sample readbale
                         }
                     }
                 }
     
                 boolean  valid = key.reset();
                 if  (!valid) {
                     // 移除不可访问的目录
                     // 因为有可能目录被移除,就会无法访问
                     keys.remove(key);
                     // 如果待监控的目录都不存在了,就中断执行
                     if  (keys.isEmpty()) {
                         break ;
                     }
                 }
             }
         }
     
    }

    文件变更行为枚举

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    package  org.xdemo.superutil.j2se.filewatch;
     
    /**
      * 文件变动行为枚举
      * @author Goofy <a href="http://www.xdemo.org/">http://www.xdemo.org/</a>
      * @Date 2015年7月3日 上午10:40:04
      */
    public  enum  FileAction {
         DELETE( "ENTRY_DELETE" ), CREATE( "ENTRY_CREATE" ), MODIFY( "ENTRY_MODIFY" );
         private  String value;
     
         FileAction(String value) {
             this .value = value;
         }
     
         public  String getValue() {
             return  value;
         }
    }

    文件变动回调方法

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    package  org.xdemo.superutil.j2se.filewatch;
     
    import  java.io.File;
     
    /**
      * 文件操作的回调方法
      * @author Goofy <a href="http://www.xdemo.org/">http://www.xdemo.org/</a>
      * @Date 2015年7月6日 上午11:11:34
      */
    public  abstract  class  FileActionCallback {
     
         public  void  delete(File file) {
         };
     
         public  void  modify(File file) {
         };
     
         public  void  create(File file) {
         };
     
    }

     用法 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    package  org.xdemo.superutil.j2se.filewatch;
     
    import  java.io.File;
     
    /**
     
      * @author Goofy
      * @Date 2015年7月6日 上午11:22:32
      */
    public  class  Usage {
     
         public  static  void  main(String[] args)  throws  Exception {
             final  File file =  new  File( "D:\\upload" );
             new  Thread( new  Runnable() {
                 @Override
                 public  void  run() {
                     try  {
                         new  WatchDir(file,  true new  FileActionCallback() {
                             @Override
                             public  void  create(File file) {
                                 System.out.println( "文件已创建\t"  + file.getAbsolutePath());
                             }
     
                             @Override
                             public  void  delete(File file) {
                                 System.out.println( "文件已删除\t"  + file.getAbsolutePath());
                             }
     
                             @Override
                             public  void  modify(File file) {
                                 System.out.println( "文件已修改\t"  + file.getAbsolutePath());
                             }
                         });
                     catch  (Exception e) {
                         e.printStackTrace();
                     }
                 }
             }).start();
     
             System.out.println( "正在监视文件夹:"  + file.getAbsolutePath() +  "的变化" );
         }
     
    }

     截图 

     说明 

    修改文件名称会产生多个事件

        待修改文件>删除该文件->创建该文件->修改该文件

        对于子文件夹的内容变动,也会引起该子文件夹的修改事件


    展开全文
  • JAVA实时屏幕监控

    2019-04-04 01:36:11
    NULL 博文链接:https://jarg.iteye.com/blog/1504195
  • 此文档讲述如何用java jvisualvm 监控服务器weblogic应用
  • NULL 博文链接:https://xjg396.iteye.com/blog/1559978
  • 本文主要通过java Aop面向切面的思想进行访问程序的监控,话不多说,先上代码。 1.导入包: <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId...

    本文主要通过java Aop面向切面的思想进行访问程序的监控,话不多说,先上代码。

    1.导入包:

     <dependency>
          <groupId>org.aspectj</groupId>
          <artifactId>aspectjweaver</artifactId>
          <version>1.8.13</version>
     </dependency>

    2.定义切面代码:

    package com.meiyibao.aop;
    
    import com.carrotsearch.sizeof.RamUsageEstimator;
    import com.ctrip.framework.apollo.Config;
    import com.ctrip.framework.apollo.spring.annotation.ApolloConfig;
    import com.meiyibao.easycoal.framework.metadata.MybData;
    import com.meiyibao.constants.MybConstants;
    import com.meiyibao.email.EmailUtil;
    import com.meiyibao.util.encryption.ExceptionUtil;
    import com.meiyibao.util.json.JSONHelper;
    import lombok.extern.slf4j.Slf4j;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    import org.springframework.web.bind.MethodArgumentNotValidException;
    import org.springframework.web.context.request.RequestAttributes;
    import org.springframework.web.context.request.RequestContextHolder;
    import org.springframework.web.context.request.ServletRequestAttributes;
    import org.springframework.web.multipart.MultipartFile;
    
    import javax.servlet.http.HttpServletRequest;
    import java.io.File;
    import java.net.SocketTimeoutException;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Objects;
    
    /**
     * 用来处理异常信息的切面
     *
     * @author root
     */
    @Component
    @Aspect
    @Slf4j
    public class ExceptionAop {
    
        @ApolloConfig
        private Config config;
    
        @Autowired
        private EmailUtil emailUtil;
    
        @Around("execution(* com.meiyibao.controller..*.*(..))")//这里可以通过你的项目包名进行配置
        public Object around(ProceedingJoinPoint pj) throws Throwable {
            long starttime=System.currentTimeMillis();
            try {
                log.info("---------------------API请求参数:【"+getMessage(pj, null)+ "】");
                Object obj = pj.proceed();
                long size = RamUsageEstimator.sizeOf(obj);
                if(size<2*1024){
                    //2kb
                    log.info("---------------------API返回值:【" +"类名:{},方法名:{};返回值:{}】",pj.getTarget().getClass().getSimpleName(),pj.getSignature().getName(),JSONHelper.convertToJSON(obj));
                }
                 return obj;
            } catch (MethodArgumentNotValidException e) {
                e.getBindingResult().getGlobalErrors();
                return MybData.error("请求参数验证失败");
            } catch (SocketTimeoutException e) {
                concatError(starttime, getMessage(pj, e));
                return MybData.error(MybConstants.EXCEPTION_TIMEOUT_ERROR);
            } catch (Exception e) {
                concatError(starttime, getMessage(pj, e));
                return MybData.error(MybConstants.EXCEPTION_BUSY);
            }
        }
    
        private void concatError(long starttime, String message) {
            StringBuilder stringBuilder=new StringBuilder( "<h3>接口耗时:</h3>");
            stringBuilder.append("接口花费时间:").append(System.currentTimeMillis()-starttime).append("ms<br/>");
            stringBuilder.append(message);
            sendErrorNotice(stringBuilder.toString());
        }
    
        private String getMessage(ProceedingJoinPoint pj, Exception e) {
            if (e != null) {
                log.error(e.getMessage(), e);
            }
            RequestAttributes ra = RequestContextHolder.getRequestAttributes();
            ServletRequestAttributes sra = (ServletRequestAttributes) ra;
            HttpServletRequest request = sra.getRequest();
            String token = request.getHeader(MybConstants.AUTHORIZATION);
            String userInfo = request.getHeader(MybConstants.HEAD_USER_INFO);
            StringBuilder joiner = new StringBuilder("<h3>链接:</h3>")
                    .append(request.getRequestURI())
                    .append("<br/><h3>token:</h3>")
                    .append((token == null ? "" : token))
                    .append("<br/><h3>user phone info:</h3>")
                    .append((userInfo == null ? "" : userInfo))
                    .append(";<br/><h3>类名:</h3>")
                    .append(pj.getTarget().getClass().getSimpleName())
                    .append(";<br/><h3>方法:</h3>")
                    .append(pj.getSignature().getName())
                    .append(";<br/><h3>参数:</h3>");
            Object[] args = pj.getArgs();
            List<Object> objects=new ArrayList<>();
            for(Object object:args){
                if(object instanceof MultipartFile || object instanceof File ){
                    continue;
                }
                objects.add(object);
            }
            joiner.append(JSONHelper.convertToJSON(objects));
            if (Objects.nonNull(e)) {
                joiner .append(";<br/><h3>message:</h3>")
                        .append(e.getMessage())
                        .append(";<br/><h3>异常:</h3>")
                        .append(ExceptionUtil.getMsg(e));
            }
            return joiner.toString();
        }
        private void sendErrorNotice(String content) {
            log.error(content);
            boolean enable = config.getBooleanProperty("exception.sendemail.enable", false);
    		if (enable) {
                emailUtil.send(content);//发送邮件,具体邮件配置可以参考我的资源中的邮件发送 源码
            }
        }
    
    }
    

     

    展开全文
  • java 监控代码执行

    千次阅读 2018-08-10 18:56:04
    1.打开jdk的VM监控器:C:\Program Files\Java\jdk1.7.0_17\bin\jvisualvm.exe 2.打开cmd,先切换到项目的bin目录,然后执行java -Xms100m test.ThreadsDemo命令   3.在jvisualvm.exe中就可以看到test....
  • Java监控工具介绍,VisualVm Yourkit

    千次阅读 2017-12-19 10:10:06
    Java监控工具介绍,VisualVm ,JProfiler,Perfino,Yourkit,Perf4J,JProbe,Java微基准测试 本文是本人前一段时间做一个简单Java监控工具调研总结,主要包括VisualVm ,JProfiler,Perfino,Yourkit,Perf4J,JProbe,...
  • JAVA监控服务IP和端口是否可用

    千次阅读 2019-11-16 10:09:17
    public static boolean isHostConnectable(String host, int port) { Socket socket = new Socket(); try { socket.connect(new InetSocketAddress(host, port)); } catch (IO...
  • java 监控系统项目分享!

    千次阅读 2017-07-31 21:11:50
    1.需要项目的友友,可以去链接下载! 2.直接上图,下载安装后配置下环境就可运行了! 链接:http://pan.baidu.com/s/1c1MGfPQ 密码:yuv5 3.项目运行,或其他问题都可以找我,就这样吧

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 391,007
精华内容 156,402
关键字:

java监控

java 订阅