JAVA获得CPU和内存的使用情况的两种方法
Java中的JMX监控有哪些常用指标
Java中的JMX监控有哪些常用指标在 Java 应用程序的运行和维护中,JMX(Java Management Extensions)监控是一项非常重要的技术。
通过 JMX,我们可以获取到应用程序内部的各种运行时信息,从而更好地了解应用的性能、健康状况和资源使用情况。
下面我们就来详细探讨一下 Java 中的 JMX 监控中一些常用的指标。
首先,内存相关的指标是至关重要的。
其中,“Heap Memory Usage”(堆内存使用量)是一个关键指标。
它能让我们了解到 Java 堆内存中已使用的空间和剩余的可用空间。
通过监控这个指标,我们可以及时发现是否存在内存泄漏的风险。
如果堆内存的使用量持续增长,而没有得到有效的释放,就可能意味着存在内存泄漏问题,需要进一步排查和解决。
另一个与内存相关的重要指标是“NonHeap Memory Usage”(非堆内存使用量)。
非堆内存主要包括方法区、JVM 内部数据结构等。
监控非堆内存的使用情况,可以帮助我们了解 JVM 自身的资源消耗,以及是否存在由于非堆内存不足而导致的性能问题。
线程相关的指标也是 JMX 监控中的重点。
“Thread Count”(线程数量)可以告诉我们当前应用中活跃的线程总数。
如果线程数量过多,可能会导致系统资源的竞争加剧,从而影响性能。
“Thread Blocked Count”(阻塞线程数量)则反映了当前处于阻塞状态的线程数量。
过多的阻塞线程可能意味着存在资源竞争或者死锁等问题,需要及时进行排查和处理。
“CPU Usage”(CPU 使用率)是评估应用性能的一个关键指标。
它可以让我们了解应用程序在一段时间内占用 CPU 资源的情况。
如果CPU 使用率持续处于高位,可能意味着应用程序存在计算密集型的操作,或者存在性能瓶颈,需要进一步优化算法或者调整架构。
“Class Loading and Unloading”(类的加载和卸载)指标也是值得关注的。
JVM常用指标查询
JVM常⽤指标查询⼀.what‘s going on in Java Application 当系统卡顿,应⽤莫名被杀掉,我们应该怎么排查?在我已知的系统挂掉的情况,只经历过两种:1.内存申请不了(OOM);2.CPU占⽤过⾼ 使⽤top命令即可以观察linux的进程信息,以及CPU占⽤信息,拿到了进程号就可以进⼀步了解进程信息。
netstat -apn | grep35011 即可观察java应⽤所监听的端⼝。
如果机⼦上配置了Java环境,则使⽤jps命令即可看到Java进程号。
通常我最常⽤是jps -ml 可显⽰给主函数传⼊的参数,并显⽰主类的完整包名。
可以查询启动Java进程时候jvm的参数,使⽤jps -v 可以看到⼀些收集器的配置(以上是使⽤CMS),Java堆的内存配置,等等。
注意⾥⾯有⼀个参数,HeapDumpOnOutofMemmoryError,这个参数说明JVM在检测到内存溢出的时候会输出⼀个内存快照,并输出到后⾯这个dumpPath中。
内存溢出有两种情况,⼀种是到达JVM设置的最⼤内存,⽽这个时候并没有到达Linux系统内存瓶颈,这个时候应该是不会把Java杀掉(猜测);另⼀种是造成了Linux系统内存申请问题,则Linux会杀掉这个异常进程(Linux Kernel OOM(Out of memory killer))。
如果想从linux层⾯查看进程,则进⼊⽂件夹;Linux的进程是以⽂件形式记录的,也就是fd的概念。
/proc/{pid}/statuslinux⽇志⽂件说明 (抄过来的)/var/log/message 系统启动后的信息和错误⽇志,是Red Hat Linux中最常⽤的⽇志之⼀/var/log/secure 安全相关的⽇志信息/var/log/maillog 邮件相关的⽇志信息/var/log/cron 定时任务相关的⽇志信息/var/log/spooler UUCP和news设备相关的⽇志信息/var/log/boot.log 守护进程启动和停⽌相关的⽇志消息/var/log/wtmp 该⽇志⽂件永久记录每个⽤户登录、注销及系统的启动、停机的事件 有⼀次查询OOM挂掉的应⽤信息,在阿⾥云监控⾥内存下来的那个时间点,去查message,看到了Linux的OOM kill的⽇志。
Java进程占用内存过高,排查解决方法
Java进程占⽤内存过⾼,排查解决⽅法最近收到邮件报警,说内存使作率达到84%。
如下图:解决⽅法:A:可能是代码原因导致的问题:1、使⽤命令:top 查看当前进程的状态2、从上图可以看到PID:916的java进程占⽤内存较⼤。
定位线程问题(通过命令查看PID 为25894 进程的线程情况),命令:# ps p 916 -L -o pcpu,pmem,pid,tid,time,tname,cmd由此可以看到这PID:916的进程产⽣了很多线程。
接下来就可以通过jstack查看内存使⽤的堆栈。
3、查看内存使⽤的堆栈:在这⾥我们挑选了TID=934的线程进⾏分析,⾸先需要将934这个id转换为16进制。
需输⼊如下命令,printf "%x\n" 97314、将PID为916的堆栈信息打印到jstack.log中,命令:jstack -l 916 > jstack.log5、查看堆栈信息⽂件,命令:vim jstack.log在进⾏搜索TID为2603的相关信息。
如图:6、分析可以看到这个线程状态为:RUNNABLE。
是正在运⾏状态的另外其它的⼤部分线程状态为:WAITING。
通过查看⽂件分析看到⼤量 Java Thread State。
说明它在等待另⼀个条件的发⽣,来把⾃⼰唤醒,或者⼲脆它是调⽤了 sleep(N)。
此时线程状态⼤致为以下⼏种:ng.Thread.State: WAITING (parking):⼀直等那个条件发⽣;ng.Thread.State: TIMED_WAITING (parking或sleeping):定时的,那个条件不到来,也将定时唤醒⾃⼰。
7.代码优化:将⽂件发送给开发。
优化下线程B:可能是其他原因导致的问题:1、使⽤ps命令:ps -ef | grep java | grep -v grep查看当前java进程列表root 83410 May13 ? 00:30:09 /usr/lib/jvm/java/bin/java -Djava.util.logging.config.file=/data/apache-tomcat-9.0.13/conf/logging.properties -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager -Djdk.tls.ephemeralDHKey root 129413 May13 ? 14:41:25 /usr/lib/jvm/java/bin/java -Djava.util.logging.config.file=/data/apache-tomcat-9.0.13/conf/logging.properties -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager -Djdk.tls.ephemeralDHKe root 208510 Mar05 ? 01:57:08 /usr/lib/jvm/java/bin/java -Djava.util.logging.config.file=/data/apache-tomcat-9.0.13/conf/logging.properties -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager -Djdk.tls.ephemeralDHKey root 1280810 Mar08 ? 01:16:03 /usr/lib/jvm/java/bin/java -Djava.util.logging.config.file=/data/apache-tomcat-9.0.13/conf/logging.properties -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager -Djdk.tls.ephemeralDHKe root 1939210 May09 ? 00:36:19 /usr/lib/jvm/java/bin/java -Djava.util.logging.config.file=/data/apache-tomcat-9.0.13/conf/logging.properties -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager -Djdk.tls.ephemeralDHKe root 1983811 May09 ? 05:32:17 /usr/lib/jvm/java/bin/java -Djava.util.logging.config.file=/data/apache-tomcat-9.0.13/conf/logging.properties -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager -Djdk.tls.ephemeralDHKe root 2154310 May27 ? 00:22:03 /usr/lib/jvm/java/bin/java -Djava.util.logging.config.file=/data/apache-tomcat-9.0.13/conf/logging.properties -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager -Djdk.tls.ephemeralDHKe root 2275015 May27 ? 02:28:41 /usr/lib/jvm/java/bin/java -Djava.util.logging.config.file=/data/apache-tomcat-9.0.13/conf/logging.properties -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager -Djdk.tls.ephemeralDHKe 由上图所⽰,可以看到java进程是Tomcat的启动进程,开启多个Tomcat启动进程,并且是同⼀个端⼝。
JAVA获得CPU和内存的使用情况的两种方法
JAVA获得CPU和内存的使用情况的两种方法在Java中,可以使用不同的方法来获取CPU和内存的使用情况。
这些信息对于优化程序性能和资源管理非常重要。
以下是两种常用的方法:1. 使用Java Management Extensions(JMX):Java提供了JMX API来监控和管理Java应用程序。
通过使用JMX,可以获取有关系统资源的详细信息,包括CPU和内存使用情况。
a)获取CPU使用情况:要获取CPU使用情况,可以使用ng.management包中的ThreadMXBean接口。
ThreadMXBean接口提供了许多有用的方法,例如getThreadCpuTime(来获取线程的CPU时间。
可以使用以下代码来获取整个系统的CPU使用情况:```javaimport ng.management.ManagementFactory;import ng.management.ThreadMXBean;public class CPUMonitorpublic static void main(String[] args)ThreadMXBean threadMXBean =ManagementFactory.getThreadMXBean(;long cpuTime = threadMXBean.getCurrentThreadCpuTime(;System.out.println("CPU Time: " + cpuTime);}}```b)获取内存使用情况:要获取内存使用情况,可以使用ng.management包中的MemoryMXBean和MemoryUsage类。
MemoryMXBean提供了获取内存使用情况的方法,而MemoryUsage类用于表示内存使用情况。
以下是一个示例代码:```javaimport ng.management.ManagementFactory;import ng.management.MemoryMXBean;import ng.management.MemoryUsage;public class MemoryMonitorpublic static void main(String[] args)MemoryMXBean memoryMXBean =ManagementFactory.getMemoryMXBean(;MemoryUsage heapMemoryUsage =memoryMXBean.getHeapMemoryUsage(;MemoryUsage nonHeapMemoryUsage =memoryMXBean.getNonHeapMemoryUsage(;System.out.println("Heap Memory Usage: " + heapMemoryUsage);System.out.println("Non-Heap Memory Usage: " + nonHeapMemoryUsage);}}```2. 使用操作系统命令和Java进程的ManagementFactory:Java还提供了一种通过执行操作系统命令并解析结果来获取CPU和内存使用情况的方法。
jvm 内存监控规则
jvm 内存监控规则
JVM内存监控可以帮助我们了解Java应用程序的内存使用情况,以及是否存在内存泄漏等问题。
以下是监控JVM内存的规则:
1. 监控堆内存使用情况,包括堆内存的总量、已使用量、可用量等。
2. 监控非堆内存使用情况,包括非堆内存的总量、已使用量、可用量等。
3. 监控垃圾回收情况,包括垃圾回收的频率、回收时间、回收器的类型等。
4. 监控内存泄漏情况,包括内存泄漏的对象、泄漏的原因等。
5. 监控线程数量,包括当前活动线程的数量。
6. 监控线程状态,例如NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING和TERMINATED等状态。
7. 监控阻塞等待原因,例如等待I/O操作、等待锁、等待唤醒等。
8. 监控线程CPU时间,以确定哪些线程消耗了大量的CPU时间。
9. 监控CPU使用率,以确定是否存在CPU瓶颈。
10. 监控操作系统CPU利用率,以确定是否存在操作系统级别的CPU瓶颈。
11. 监控垃圾回收器类型、垃圾回收的频率和效率等。
此外,还可以使用jstat命令连续获取多行性能数据,并取这几行数据中
OU列(即已占用的老年代内存)的最小值。
然后每隔一段较长的时间重复一次上述操作,来获得多组OU最小值。
如果这些值呈上涨趋势,则说明该
Java程序的老年代内存已使用量在不断上涨,这意味着无法回收的对象在不断增加,因此很有可能存在内存泄漏。
以上信息仅供参考,如需获取更多详细信息,建议咨询专业技术人员或查阅相关技术手册。
javamelody 使用方法
javamelody 使用方法【实用版3篇】目录(篇1)I.javamelody 简介II.如何安装 javamelodyIII.javamelody 的使用方法IV.如何配置 javamelodyV.javamelody 的性能VI.javamelody 的总结正文(篇1)I.javamelody 简介javamelody 是一款用于监控 Java 应用程序性能的开源工具。
它能够收集应用程序的各种指标,如响应时间、错误率等,并提供友好的界面展示这些数据。
II.如何安装 javamelody要安装 javamelody,您需要遵循以下步骤:1.将 javamelody 添加到您的项目的依赖中。
您可以在 Maven 或Gradle 中添加以下依赖:```xmlu003cdependencyu003eu003cgroupIdu003eorg.javamelodyu003c/groupIdu003eu003cartifactIdu003ejavamelody-coreu003c/artifactIdu003eu003cversionu003e1.9u003c/versionu003eu003c/dependencyu003e```III.javamelody 的使用方法要使用 javamelody,您需要执行以下步骤:1.在您的应用程序中添加以下代码:```javaMamelody.METER("my-meter"); // 定义一个度量器,并为其命名Mamelody.监控(MyClass.class); // 监控 MyClass 类的性能指标```2.在您的应用程序启动时启动 javamelody:```bashjava -jar javamelody-1.9.jar --prefix=/path/to/application--stats-url=http://localhost:8080/my-meter --page-title=My Application Performance - javamelody monitoring u0026 // 指定报告地址和标题,并将进程添加到监控队列中```3.查看性能数据:访问 http://localhost:8080/my-meter。
JVM性能调优监控工具jps、jstack、jmap、jhat、jstat、hprof使用详解
JVM性能调优监控工具jps、jstack、jmap、jhat、jstat、hprof使用详解J DK本身提供了很多方便的JVM性能调优监控工具,除了集成式的VisualVM和jConsole外,还有jps、jstack、jmap、jhat、jstat、hprof等小巧的工具,本博客希望能起抛砖引玉之用,让大家能开始对JVM性能调优的常用工具有所了解。
现实企业级Java开发中,有时候我们会碰到下面这些问题:OutOfMemoryError,内存不足内存泄露线程死锁锁争用(Lock Contention)Java 进程消耗CPU过高......这些问题在日常开发中可能被很多人忽视(比如有的人遇到上面的问题只是重启服务器或者调大内存,而不会深究问题根源),但能够理解并解决这些问题是Java程序员进阶的必备要求。
本文将对一些常用的JVM 性能调优监控工具进行介绍,希望能起抛砖引玉之用。
A、jps(Java Virtual Machine Process Status Tool) jps 主要用来输出JVM中运行的进程状态信息。
语法格式如下:jps[options] [hostid]如果不指定hostid就默认为当前主机或服务器。
命令行参数选项说明如下:-q 不输出类名、Jar名和传入main方法的参数-m 输出传入main 方法的参数-l 输出main类或Jar的全限名-v 输出传入JVM的参数比如下面:root@ubuntu:/# jps -m -l2458org.artifactory.standalone.main.Main /usr/local/artifactory-2.2.5/etc/jetty.xml29920 com.sun.tools.hat. Main -port 9998 /tmp/dump.dat3149 org.apache.catalina.startup.Boo tstrap start30972 sun.tools.jps.Jps -m -l8247 org.apache.catalin a.startup.Bootstrap start25687com.sun.tools.hat.Main -port 9999 dump.dat21711 mrf-center.jarB、jstack jstack主要用来查看某个Java进程内的线程堆栈信息。
Java获取Linux和Window系统CPU、内存和磁盘总使用率的情况
本文由我司收集整编,推荐下载,如有疑问,请与我司联系Java 获取Linux 和Window 系统CPU、内存和磁盘总使用率的情况2017/05/08 0 这是一个工具类,获取的内容:CPU 使用率:得到的是当前CPU 的使用情况,这是算出的是两次500 毫秒时间差的CPU 使用率内存使用率:[1 - 剩余的物理内存/(总的物理内存+虚拟内存) ] * 100磁盘总使用率:[1 - 磁盘空余大小/磁盘总大小] * 100下面开始贴代码:使用暂时没有发现什么问题,如果有问题,咱们可以一起讨论package com.util;import java.io.BufferedReader;import java.io.File;import java.io.FileInputStream;import java.io.InputStreamReader;import java.io.LineNumberReader;import ng.management.ManagementFactory;import java.math.BigDecimal;import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;import java.util.StringTokenizer;import org.apache.log4j.Logger;import com.sun.management.OperatingSystemMXBean;public class ComputerMonitorUtil {private static String osName = System.getProperty(“”);private static final int CPUTIME = 500;private static final int PERCENT = 100;private static final int FAULTLENGTH = 10;private static final Logger logger = Logger.getLogger(ComputerMonitorUtil.class);/** * 功能:获取Linux 和Window 系统cpu 使用率* */public static double getCpuUsage() {// 如果是window 系统if (osName.toLowerCase().contains(“windows”)||osName.toLowerCase().contains(“win”)) {try {String procCmd = System.getenv(“windir”)+“//system32//wbem//wmic.exe process getCaption,CommandLine,KernelModeTime,ReadOperationCount,ThreadCount,UserModeTi。
操作系统概念第七版习题答案(中文版)完整版
1.1 在多道程序和分时环境中,多个用户同时共享一个系统,这种情况导致多种平安问题。
a. 列出此类的问题 b.在一个分时机器中,能否确保像在专用机器上一样的平安度?并解释之。
Answer:a.窃取或者复制某用户的程序或数据;没有合理的预算来使用资源〔CPU,内存,磁盘空间,外围设备〕b.应该不行,因为人类设计的任何保护机制都会不可防止的被另外的人所破译,而且很自信的认为程序本身的实现是正确的选项是一件困难的事。
1.2 资源的利用问题在各种各样的操作系统中出现。
试例举在以下的环境中哪种资源必须被严格的管理。
〔a〕大型电脑或迷你电脑系统〔b〕与效劳器相联的工作站〔c〕手持电脑Answer: 〔a〕大型电脑或迷你电脑系统:内存和CPU 资源,外存,网络带宽〔b〕与效劳器相联的工作站:内存和CPU 资源〔c〕手持电脑:功率消耗,内存资源1.3 在什么情况下一个用户使用一个分时系统比使用一台个人计算机或单用户工作站更好?Answer:当另外使用分时系统的用户较少时,任务十分巨大,硬件速度很快,分时系统有意义。
充分利用该系统可以对用户的问题产生影响。
比起个人电脑,问题可以被更快的解决。
还有一种可能发生的情况是在同一时间有许多另外的用户在同一时间使用资源。
当作业足够小,且能在个人计算机上合理的运行时,以及当个人计算机的性能能够充分的运行程序来到达用户的满意时,个人计算机是最好的,。
1.4 在下面举出的三个功能中,哪个功能在以下两种环境下,(a)手持装置(b)实时系统需要操作系统的支持?(a)批处理程序(b)虚拟存储器(c)分时Answer:对于实时系统来说,操作系统需要以一种公平的方式支持虚拟存储器和分时系统。
对于手持系统,操作系统需要提供虚拟存储器,但是不需要提供分时系统。
批处理程序在两种环境中都是非必需的。
1.5 描述对称多处理〔SMP〕和非对称多处理之间的区别。
多处理系统的三个优点和一个缺点?Answer:SMP意味着所以处理器都对等,而且I/O 可以在任何处理器上运行。
jprofile的使用
jprofile的使用JProfile 是一款性能分析工具,旨在帮助开发人员诊断和优化Java应用程序的性能问题。
它可以详细地分析代码的运行情况,包括内存使用、线程执行、方法调用以及各种性能指标。
在本文中,我们将一步一步介绍JProfile 的使用方法,以帮助开发人员更好地理解并应用该工具。
第一步:安装JProfile首先,我们需要下载并安装JProfile 到我们的开发环境中。
可以从JProfile 官方网站上获得最新版本的安装程序。
安装程序提供了针对不同操作系统和Java版本的安装包。
下载合适的安装包后,双击运行安装程序并按照提示进行安装。
第二步:连接应用程序安装完JProfile 后,我们需要将其与我们的应用程序进行连接,以便进行性能分析。
JProfile 支持多种连接方式,包括本地连接和远程连接。
在本地连接模式下,可以直接通过本地启动的应用程序进行连接;而在远程连接模式下,我们可以通过指定IP 地址和端口号来连接运行在其他机器上的应用程序。
第三步:配置性能分析选项一旦成功连接到应用程序,我们可以配置性能分析选项来确定我们感兴趣的分析内容。
JProfile 提供了各种选项来监视不同的性能指标,如CPU使用、内存使用、线程执行和方法调用等。
我们可以根据实际需求,选择并启用适当的选项。
另外,我们还可以指定分析的时间周期和采样间隔,以控制性能分析的精度和效率。
第四步:运行性能分析配置完性能分析选项后,我们可以开始运行应用程序并进行性能分析了。
JProfile 会在分析周期内持续地监视应用程序的运行情况,并收集各种性能指标的数据。
在运行过程中,我们可以通过JProfile 的界面实时地查看监视数据,并对特定代码区域进行详细分析。
第五步:分析性能数据当性能分析运行结束后,我们可以停止应用程序,并开始分析收集到的性能数据。
JProfile 提供了丰富的分析功能,可以帮助我们深入了解代码的执行情况。
例如,我们可以查看内存使用的变化情况,以确定是否存在内存泄漏的问题;我们还可以查看各个线程的执行时间,以找出执行效率低下的线程;此外,还可以查看方法的调用时间和次数,以找出代码中的瓶颈。
Java命令行运行参数说明大全
一、 查看参数列表:
虚拟机参数分为基本和扩展两类,在命令行中输入JAVA_HOME"bin"java 就可得到基本参数列表,在命令行输入JAVA_HOME"bin"java –X 就可得到扩展参数列表。
二、 基本参数说明:
1. -client,-server
当虚拟机报告类找不到或类冲突时可用此参数来诊断来查看虚拟机从装入类的情况。
7. -verbose:gc
在虚拟机发生内存回收时在输出设备显示信息,格式如下:
[Full GC 268K->168K(1984K), 0.0187390 secs]
该参数用来监视虚拟机内存回收的情况。
8. Байду номын сангаасverbose:jni
13.-da[:<packagename>...|:<classname>]
14.-disableassertions[:<packagename>...|:<classname>]
用来设置虚拟机关闭断言处理,packagename和classname的使用方法和-ea相同。
15.-esa | -enablesystemassertions
10.-Xms<size>
设置虚拟机可用内存堆的初始大小,缺省单位为字节,该大小为1024的整数倍并且要大于1MB,可用k(K)或m(M)为单位来设置较大的内存数。初始堆大小为2MB。
例如:-Xms6400K,-Xms256M
11.-Xmx<size>
设置虚拟机内存堆的最大可用大小,缺省单位为字节。该值必须为1024整数倍,并且要大于2MB。可用k(K)或m(M)为单位来设置较大的内存数。缺省堆最大值为64MB。
java获得CPU使用率
java获得CPU使用率,系统内存,虚拟机内存等情况(不用JNI)2009年10月23日星期五16:30在Java中,可以获得总的物理内存、剩余的物理内存、已使用的物理内存等信息,下面例子可以取得这些信息,并且获得在Windows下的内存使用率。
首先编写一个MonitorInfoBean类,用来装载监控的一些信息,包括物理内存、剩余的物理内存、已使用的物理内存、内存使用率等字段,该类的代码如下:package com.hmw.system.monitor;public class MonitorInfoBean {/** 可使用内存. */private long totalMemory;/** 剩余内存. */private long freeMemory;/** 最大可使用内存. */private long maxMemory;/** 操作系统. */private String osName;/** 总的物理内存. */private long totalMemorySize;/** 剩余的物理内存. */private long freePhysicalMemorySize;/** 已使用的物理内存. */private long usedMemory;/** 线程总数. */private int totalThread;/** cpu使用率. */private double cpuRatio;public long getFreeMemory() {return freeMemory;}public void setFreeMemory(long freeMemory) {this.freeMemory = freeMemory;}public long getFreePhysicalMemorySize() {return freePhysicalMemorySize;}public void setFreePhysicalMemorySize(long freePhysicalMemorySize) { this.freePhysicalMemorySize = freePhysicalMemorySize;}public long getMaxMemory() {return maxMemory;}public void setMaxMemory(long maxMemory) {this.maxMemory = maxMemory;}public String getOsName() {return osName;}public void setOsName(String osName) {this.osName = osName;}public long getTotalMemory() {return totalMemory;}public void setTotalMemory(long totalMemory) {this.totalMemory = totalMemory;}public long getTotalMemorySize() {return totalMemorySize;}public void setTotalMemorySize(long totalMemorySize) { this.totalMemorySize = totalMemorySize;}public int getTotalThread() {return totalThread;}public void setTotalThread(int totalThread) {this.totalThread = totalThread;}public long getUsedMemory() {return usedMemory;}public void setUsedMemory(long usedMemory) {edMemory = usedMemory;}public double getCpuRatio() {return cpuRatio;}public void setCpuRatio(double cpuRatio) {this.cpuRatio = cpuRatio;}}接着编写一个获得当前的监控信息的接口,该类的代码如下所示:package com.hmw.system.monitor;/*** 获取系统信息的业务逻辑类接口.*/public interface IMonitorService {/*** 获得当前的监控对象.* @return 返回构造好的监控对象* @throws Exception*/public MonitorInfoBean getMonitorInfoBean() throws Exception; }该类的实现类MonitorServiceImpl如下所示:package com.hmw.system.monitor;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStream;import java.io.InputStreamReader;import java.io.LineNumberReader;import java.util.StringTokenizer;import sun.management.ManagementFactory;import com.sun.management.OperatingSystemMXBean;/**** 获取系统信息的业务逻辑实现类.** @author GuoHuang*/public class MonitorServiceImpl implements IMonitorService { private static final int CPUTIME = 30;private static final int PERCENT = 100;private static final int FAULTLENGTH = 10;private static String linuxVersion = null;/*** 获得当前的监控对象.** @return 返回构造好的监控对象* @throws Exception* @author GuoHuang*/public MonitorInfoBean getMonitorInfoBean() throws Exception { int kb = 1024;// 可使用内存long totalMemory = Runtime.getRuntime().totalMemory() / kb; // 剩余内存long freeMemory = Runtime.getRuntime().freeMemory() / kb;// 最大可使用内存long maxMemory = Runtime.getRuntime().maxMemory() / kb; OperatingSystemMXBean osmxb = (OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();// 操作系统String osName = System.getProperty("");// 总的物理内存long totalMemorySize = osmxb.getTotalPhysicalMemorySize() / kb;// 剩余的物理内存long freePhysicalMemorySize = osmxb.getFreePhysicalMemorySize() / kb;// 已使用的物理内存long usedMemory = (osmxb.getTotalPhysicalMemorySize() - osmxb.getFreePhysicalMemorySize()) / kb;// 获得线程总数ThreadGroup parentThread;for (parentThread = Thread.currentThread().getThreadGroup(); parentThread.getParent() != null; parentThread = parentThread.getParent());int totalThread = parentThread.activeCount();double cpuRatio = 0;if (osName.toLowerCase().startsWith("windows")) {cpuRatio = this.getCpuRatioForWindows();} else {cpuRatio = getCpuRateForLinux();}// 构造返回对象MonitorInfoBean infoBean = new MonitorInfoBean();infoBean.setFreeMemory(freeMemory);infoBean.setFreePhysicalMemorySize(freePhysicalMemorySize); infoBean.setMaxMemory(maxMemory);infoBean.setOsName(osName);infoBean.setTotalMemory(totalMemory);infoBean.setTotalMemorySize(totalMemorySize);infoBean.setTotalThread(totalThread);infoBean.setUsedMemory(usedMemory);infoBean.setCpuRatio(cpuRatio);return infoBean;}private static double getCpuRateForLinux() {InputStream is = null;InputStreamReader isr = null;BufferedReader brStat = null;StringTokenizer tokenStat = null;try {System.out.println("Get usage rate of CUP , linux version: " + linuxVersion); Process process = Runtime.getRuntime().exec("top -b -n 1");is = process.getInputStream();isr = new InputStreamReader(is);brStat = new BufferedReader(isr);if (linuxVersion.equals("2.4")) {brStat.readLine();brStat.readLine();brStat.readLine();brStat.readLine();tokenStat = new StringTokenizer(brStat.readLine()); tokenStat.nextToken();tokenStat.nextToken();String user = tokenStat.nextToken();tokenStat.nextToken();String system = tokenStat.nextToken();tokenStat.nextToken();String nice = tokenStat.nextToken();System.out.println(user + " , " + system + " , " + nice); user = user.substring(0, user.indexOf("%"));system = system.substring(0, system.indexOf("%")); nice = nice.substring(0, nice.indexOf("%"));float userUsage = new Float(user).floatValue();float systemUsage = new Float(system).floatValue(); float niceUsage = new Float(nice).floatValue();return (userUsage + systemUsage + niceUsage) / 100; } else {brStat.readLine();brStat.readLine();tokenStat = new StringTokenizer(brStat.readLine());tokenStat.nextToken();tokenStat.nextToken();tokenStat.nextToken();tokenStat.nextToken();tokenStat.nextToken();tokenStat.nextToken();tokenStat.nextToken();String cpuUsage = tokenStat.nextToken();System.out.println("CPU idle : " + cpuUsage);Float usage = new Float(cpuUsage.substring(0, cpuUsage.indexOf("%")));return (1 - usage.floatValue() / 100);}} catch (IOException ioe) {System.out.println(ioe.getMessage());freeResource(is, isr, brStat);return 1;} finally {freeResource(is, isr, brStat);}}private static void freeResource(InputStream is, InputStreamReader isr, BufferedReader br) {try {if (is != null)is.close();if (isr != null)isr.close();if (br != null)br.close();} catch (IOException ioe) {System.out.println(ioe.getMessage());}}/*** 获得CPU使用率.** @return 返回cpu使用率* @author GuoHuang*/private double getCpuRatioForWindows() {try {String procCmd = System.getenv("windir") + "\\system32\\wbem\\wmic.exe process getCaption,CommandLine,KernelModeTime,ReadOperationCount,ThreadCount,UserModeTime,WriteOperationCount // 取进程信息long[] c0 = readCpu(Runtime.getRuntime().exec(procCmd));Thread.sleep(CPUTIME);long[] c1 = readCpu(Runtime.getRuntime().exec(procCmd));if (c0 != null && c1 != null) {long idletime = c1[0] - c0[0];long busytime = c1[1] - c0[1];return Double.valueOf(PERCENT * (busytime) / (busytime + idletime)).doubleValue();} else {return 0.0;}} catch (Exception ex) {ex.printStackTrace();return 0.0;}}/*** 读取CPU信息.* @param proc* @return* @author GuoHuang*/private long[] readCpu(final Process proc) {long[] retn = new long[2];try {proc.getOutputStream().close();InputStreamReader ir = new InputStreamReader(proc.getInputStream()); LineNumberReader input = new LineNumberReader(ir);String line = input.readLine();if (line == null || line.length() < FAULTLENGTH) {return null;}int capidx = line.indexOf("Caption");int cmdidx = line.indexOf("CommandLine");int rocidx = line.indexOf("ReadOperationCount");int umtidx = line.indexOf("UserModeTime");int kmtidx = line.indexOf("KernelModeTime");int wocidx = line.indexOf("WriteOperationCount");long idletime = 0;long kneltime = 0;long usertime = 0;while ((line = input.readLine()) != null) {if (line.length() < wocidx) {continue;}// 字段出现顺序:Caption,CommandLine,KernelModeTime,ReadOperationCount, // ThreadCount,UserModeTime,WriteOperationString caption = Bytes.substring(line, capidx, cmdidx - 1).trim();String cmd = Bytes.substring(line, cmdidx, kmtidx - 1).trim();if (cmd.indexOf("wmic.exe") >= 0) {continue;}String s1 = Bytes.substring(line, kmtidx, rocidx - 1).trim();String s2 = Bytes.substring(line, umtidx, wocidx - 1).trim();if (caption.equals("System Idle Process") || caption.equals("System")) {if (s1.length() > 0)idletime += Long.valueOf(s1).longValue();if (s2.length() > 0)idletime += Long.valueOf(s2).longValue();continue;}if (s1.length() > 0)kneltime += Long.valueOf(s1).longValue();if (s2.length() > 0)usertime += Long.valueOf(s2).longValue();}retn[0] = idletime;retn[1] = kneltime + usertime; return retn;} catch (Exception ex) {ex.printStackTrace();} finally {try {proc.getInputStream().close(); } catch (Exception e) {e.printStackTrace();}}return null;}/*** 测试方法.** @param args* @throws Exception* @author GuoHuang*/public static void main(String[] args) throws Exception {IMonitorService service = new MonitorServiceImpl();MonitorInfoBean monitorInfo = service.getMonitorInfoBean();System.out.println("cpu占有率=" + monitorInfo.getCpuRatio());System.out.println("可使用内存=" + monitorInfo.getTotalMemory());System.out.println("剩余内存=" + monitorInfo.getFreeMemory());System.out.println("最大可使用内存=" + monitorInfo.getMaxMemory());System.out.println("操作系统=" + monitorInfo.getOsName());System.out.println("总的物理内存=" + monitorInfo.getTotalMemorySize() + "kb");System.out.println("剩余的物理内存=" + monitorInfo.getFreeMemory() + "kb");System.out.println("已使用的物理内存=" + monitorInfo.getUsedMemory() + "kb");System.out.println("线程总数=" + monitorInfo.getTotalThread() + "kb");}}该实现类中需要用到一个自己编写byte的工具类,该类的代码如下所示:package com.hmw.system.monitor;/*** byte操作类.*/public class Bytes {/*** 由于String.subString对汉字处理存在问题(把一个汉字视为一个字节),因此在包含汉字的字符串时存在隐患,现调整如下:** @param src 要截取的字符串* @param start_idx 开始坐标(包括该坐标)* @param end_idx 截止坐标(包括该坐标)* @return*/public static String substring(String src, int start_idx, int end_idx) {byte[] b = src.getBytes();String tgt = "";for (int i = start_idx; i <= end_idx; i++) {tgt += (char) b[i];}return tgt;}}运行下MonitorBeanImpl类,读者将会看到当前的内存、cpu利用率等信息。
在Java应用程序中动态分配CPU资源
Java的线程调度操作在运行时是与平台无关的。
一个多任务系统需要在任务之间实现QoS(Quality of Service)管理时,如果CPU资源的分配基于Java线程的优先级,那么它在不同平台上运行时的效果是很难预测的。
本文利用协调式多任务模型,提出一个与平台无关、并且能在任务间动态分配CPU资源的方案。
现在,由于计算机系统已经从人机交互逐步向机机交互转化,计算机和计算机之间的业务对于时间的要求非常高。
软件系统对于业务的支持已经不仅表现为对不同业务的逻辑和数据(算法+数据结构)支持,而且还表现为对同时处理不同任务的时效性(任务响应速度)支持。
一般,任务响应的速度可以通过算法优化及并行运算分担负载等手段来提高。
但是,用户业务逻辑的复杂度决定了算法优化的发挥空间,硬件规模决定了所能够承担负载的大小。
我们利用Java平台的特点,借鉴协调式多任务思想,使CPU资源能够在任务间动态分配,从而为时间要求强的任务分配更多的CPU运行资源。
这也可以充分利用现有硬件,为用户业务提供最大的保障。
用Java解决问题本着软件系统结构和现实系统结构一致的思想,开发复杂业务服务的程序一般按照计算机任务和现实业务对应的思路,最终形成一个大规模的多任务系统。
由于其跨平台性,Java系统可以随着业务的扩大,平滑地升级到各种硬件平台上。
由于Java自身的发展及其应用场合的不断扩大,用它实现多任务系统已经成为当前的应用方向。
在J2EE(Java2 Enterprise Edition)推出以后,Sun公司已经将Java的重心放在了服务器端(Server Side)系统的构造上。
由于客户/服务器模型固有的多对一的关系,服务器端程序也必然是一个多任务系统。
在Java多任务应用中,动态地将CPU资源在任务间分配有很重要的意义。
比如一个Internet服务商的系统往往有多种任务同时运行,有HTTP、FTP、MAIL等协议的支持,也有商务、娱乐、生活、咨询等业务的服务。
对于LINUX类主机JAVA应用程序占用CPU、内存过高的分析方法介绍
对于L INUX类主机JAVA应用程序占用CPU、内存过高的分析方法介绍作者:丁启良,新炬网络技术专家做为一个IT运维人员,通常在运维过程中会遇到各种各样的问题,系统问题、应用问题、程序问题,而在这当中必然会涉及到性能问题,当用户量过大,或者服务器性能不足以支持大用户量,但同时又得不到扩容的情况下,进行性能分析,并对系统、应用、程序进行优化则显得尤为重要,同时也是节省资源的一种必不可少的手段,目前大多数的运维产品都是基于JAVA语言开发的,下面我给大家介绍一下在linux环境下对JAVA的性能分析手段。
1.应用程序占用资源高问题目前大部分应用程序采用的是JAVA语言开发,在产品上线使用一段时间后,经常会出现某个JAVA程序占用的CPU,内存过高,而且几乎从不释放,导致系统卡顿,用户使用变慢,如果要恢复,则必须杀掉该进程或重启该服务,然后进行此操作时,必定会导致业务中断。
程序主要由代码组成,优化则需要知道是哪段代码占用资源,并且一个应用占用CPU很高,除了确实是计算密集型应用之外,通常原因都是出现了死循环,所以通过优化代码来降低应用程序的资源消耗或者在应用的使用过程中减少死循环则必不可少。
下面我们以4A平台的字符网关服务器为例来进行相应分析。
2.问题分析2.1.CPU过高分析1)使用TOP命令查看CPU、内存使用状态可以发现CPU占用主要分为两部分,一部分为系统内核空间占用CPU百分比,一部分为用户空间占用CPU百分比。
其中CPU状态中标示id 的为空闲CPU百分比。
当空闲CPU百分比越低,说明CPU占用率越高。
2)初步分析可以发现其中主要占用CPU的进程为java子进程jerrySsh服务(用户访问资源使用的监听服务),在用户量不大的情况下,CPU消耗资源很大。
根据研发反馈字符网关设定的最大访问量可达到500/台,目前字符网关的资源使用现状无法满足设定的要求。
分析手段目前针对Linux下java进程占用CPU高的分析手段主要为使用linux命令查出高CPU使用的进程,前分析其是由于进程原因还是系统原因,在分析出为进程消耗过高CPU后列出占用CPU高和占用时间最长的线程并使用jdk自带的jstack工具进行分析CPU使用分析export JAVA_HOME=/usr/apps/java/jdk1.6.0_20/export PATH=$JAVA_HOME/bin:$PATHexport CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar分析过程:1、根据top命令,发现PID为13033的Java进程占用CPU %id 50%以上,占用CPU过高2、找到该进程后,首先显示线程列表,并按照CPU占用高的线程排序:[root@YZ-A-ZFWG-4 ~]# ps -mp 13033 -o THREAD,tid,time | sort –rn显示结果如下:找到了耗时最高的线程28358,占用CPU时间达8分多钟将需要的线程ID转换为16进制格式:[root@YZ-A-ZFWG-4 ~]# printf "%x\n" 283586ec6最后打印线程的堆栈信息:经比对发现占用CPU高的jerrySsh服务中高消耗CPU的代码均为一些等待和读取的语句。
jvm钩子函数
jvm钩子函数JVM钩子函数JVM(Java虚拟机)钩子函数是Java中一种特殊类型的回调函数,它允许开发人员在JVM停止或发生异常时执行一些特定的操作。
这些钩子函数可以用于资源清理、日志记录、数据保存等处理。
本文将介绍JVM钩子函数的概念、使用场景以及一些示例。
一、概述JVM钩子函数实际上是Java中的一个API,它允许我们注册一个回调函数,在JVM停止之前或发生异常时触发执行。
这些钩子函数可以通过Runtime类的addShutdownHook方法注册,它接受一个Thread对象作为参数,该线程对象将在JVM停止时执行。
二、使用场景JVM钩子函数在以下情况下特别有用:1.资源清理:当JVM停止时,我们可以使用钩子函数来关闭数据库连接、释放文件句柄、释放系统资源等。
这样可以保证资源被正确释放,避免资源泄露。
2.日志记录:在JVM停止时,我们可以使用钩子函数来记录一些重要的日志信息,例如程序的运行状态、异常信息等。
这样可以方便后续的故障排查和分析。
3.数据保存:当JVM停止时,我们可以使用钩子函数来保存一些临时数据,例如缓存数据、临时文件等。
这样可以保证数据的完整性和一致性。
4.系统状态监控:当JVM停止时,我们可以使用钩子函数来发送系统状态信息给监控系统,例如CPU使用率、内存使用情况等。
这样可以方便后续的性能分析和优化。
三、示例下面是一个简单的示例,演示了如何使用JVM钩子函数来实现资源清理和日志记录。
```javapublic class MyShutdownHook extends Thread {public void run() {// 在JVM停止时执行的操作cleanup();log();}private void cleanup() {// 资源清理操作System.out.println("Cleaning up resources...");// 关闭数据库连接// 释放文件句柄// 释放系统资源}private void log() {// 日志记录操作System.out.println("Logging...");// 记录程序运行状态// 记录异常信息// 记录其他重要日志}}public class Main {public static void main(String[] args) {// 注册钩子函数Runtime.getRuntime().addShutdownHook(new MyShutdownHook());// 程序正常执行代码// ...}}```在上面的示例中,我们定义了一个MyShutdownHook类,它继承自Thread类,并重写了run方法,在该方法中执行资源清理和日志记录的操作。
(完整版)操作系统概念第七版习题答案(中文版)完整版
1.1 在多道程序和分时环境中,多个用户同时共享一个系统,这种情况导致多种安全问题。
a. 列出此类的问题 b.在一个分时机器中,能否确保像在专用机器上一样的安全度?并解释之。
Answer:a.窃取或者复制某用户的程序或数据;没有合理的预算来使用资源(CPU,内存,磁盘空间,外围设备)b.应该不行,因为人类设计的任何保护机制都会不可避免的被另外的人所破译,而且很自信的认为程序本身的实现是正确的是一件困难的事。
1.2 资源的利用问题在各种各样的操作系统中出现。
试例举在下列的环境中哪种资源必须被严格的管理。
(a)大型电脑或迷你电脑系统(b)与服务器相联的工作站(c)手持电脑Answer: (a)大型电脑或迷你电脑系统:内存和CPU 资源,外存,网络带宽(b)与服务器相联的工作站:内存和CPU 资源(c)手持电脑:功率消耗,内存资源1.3 在什么情况下一个用户使用一个分时系统比使用一台个人计算机或单用户工作站更好?Answer:当另外使用分时系统的用户较少时,任务十分巨大,硬件速度很快,分时系统有意义。
充分利用该系统可以对用户的问题产生影响。
比起个人电脑,问题可以被更快的解决。
还有一种可能发生的情况是在同一时间有许多另外的用户在同一时间使用资源。
当作业足够小,且能在个人计算机上合理的运行时,以及当个人计算机的性能能够充分的运行程序来达到用户的满意时,个人计算机是最好的,。
1.4 在下面举出的三个功能中,哪个功能在下列两种环境下,(a)手持装置(b)实时系统需要操作系统的支持?(a)批处理程序(b)虚拟存储器(c)分时Answer:对于实时系统来说,操作系统需要以一种公平的方式支持虚拟存储器和分时系统。
对于手持系统,操作系统需要提供虚拟存储器,但是不需要提供分时系统。
批处理程序在两种环境中都是非必需的。
1.5 描述对称多处理(SMP)和非对称多处理之间的区别。
多处理系统的三个优点和一个缺点?Answer:SMP意味着所以处理器都对等,而且I/O 可以在任何处理器上运行。
Java获取系统信息(cpu,内存,硬盘,进程等)的相关方法
java获取系统信息(CPU,内存,硬盘,进程)的相关方法一、这是一个获取相关信息的简单的方法import java.io.*;import com.sun.management.OperatingSystemMXBean;import sun.management.ManagementFactory;public class Tst{public static String pt="D:\\abc.txt";public Tst(){}public static void main(String[] args) throws Exception{//free和use和total均为KBlong free=0;long use=0;long total=0;int kb=1024;Runtime rt=Runtime.getRuntime();total=rt.totalMemory();free=rt.freeMemory();use=total-free;System.out.println("系统内存已用的空间为:"+use/kb+" MB");System.out.println("系统内存的空闲空间为:"+free/kb+" MB");System.out.println("系统总内存空间为:"+total/kb+" MB");OperatingSystemMXBean osmxb = (OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();long physicalFree=osmxb.getFreePhysicalMemorySize()/kb;long physicalTotal=osmxb.getTotalPhysicalMemorySize()/kb;long physicalUse=physicalTotal-physicalFree;String os=System.getProperty("");System.out.println("操作系统的版本:"+os);System.out.println("系统物理内存已用的空间为:"+physicalFree+" MB");System.out.println("系统物理内存的空闲空间为:"+physicalUse+" MB");System.out.println("总物理内存:"+physicalTotal+" MB");// 获得线程总数ThreadGroup parentThread;for (parentThread = Thread.currentThread().getThreadGroup(); parentThread.getParent() != null; parentThread = parentThread.getParent());int totalThread = parentThread.activeCount();System.out.println("获得线程总数:"+totalThread);}}二,别的方法技巧1.利用jdk自带的API获取信息:(只支持jdk1.60以上的版本啊)import java.io.InputStreamReader;import java.io.LineNumberReader;import java.util.ArrayList;import java.util.List;import .sun.management.OperatingSystemMXBean; import mytools.java.io.File;import ng.management.ManagementFactory;/*** 获取windows系统信息(CPU,内存,文件系统)* @author libing**/public class WindowsInfoUtil {private static final int CPUTIME = 500;private static final int PERCENT = 100;private static final int FAULTLENGTH = 10;public static void main(String[] args) {System.out.println(getCpuRatioForWindows());System.out.println(getMemery());System.out.println(getDisk());}//获取内存使用率public static String getMemery(){OperatingSystemMXBean osmxb = (OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();// 总的物理内存+虚拟内存long totalvirtualMemory = osmxb.getTotalSwapSpaceSize();// 剩余的物理内存long freePhysicalMemorySize = osmxb.getFreePhysicalMemorySize();Double compare=(Double)(1-freePhysicalMemorySize*1.0/totalvirtualMemory)*100; String str="内存已使用:"+compare.intValue()+"%";return str;}//获取文件系统使用率public static List<String> getDisk() {// 操作系统List<String> list=new ArrayList<String>();for (char c = 'A'; c <= 'Z'; c++) {String dirName = c + ":/";File win = new File(dirName);if(win.exists()){long total=(long)win.getTotalSpace();long free=(long)win.getFreeSpace();Double compare=(Double)(1-free*1.0/total)*100;String str=c+":盘已使用"+compare.intValue()+"%";list.add(str);}}return list;}//获得cpu使用率public static String getCpuRatioForWindows() {try {String procCmd = System.getenv("windir") + "\\system32\\wbem\\wmic.exeprocess getCaption,CommandLine,KernelModeTime,ReadOperationCount,ThreadCount,UserModeT ime,WriteOperationCount";// 取进程信息long[] c0 = readCpu(Runtime.getRuntime().exec(procCmd));Thread.sleep(CPUTIME);long[] c1 = readCpu(Runtime.getRuntime().exec(procCmd));if (c0 != null && c1 != null) {long idletime = c1[0] - c0[0];long busytime = c1[1] - c0[1];return "CPU使用率:"+Double.valueOf(PERCENT * (busytime)*1.0 / (busytime + idletime)).intValue()+"%";} else {return "CPU使用率:"+0+"%";}} catch (Exception ex) {ex.printStackTrace();return "CPU使用率:"+0+"%";}}//读取cpu相关信息private static long[] readCpu(final Process proc) {long[] retn = new long[2];try {proc.getOutputStream().close();InputStreamReader ir = new InputStreamReader(proc.getInputStream());LineNumberReader input = new LineNumberReader(ir);String line = input.readLine();if (line == null || line.length() < FAULTLENGTH) {}int capidx = line.indexOf("Caption");int cmdidx = line.indexOf("CommandLine");int rocidx = line.indexOf("ReadOperationCount");int umtidx = line.indexOf("UserModeTime");int kmtidx = line.indexOf("KernelModeTime");int wocidx = line.indexOf("WriteOperationCount");long idletime = 0;long kneltime = 0;long usertime = 0;while ((line = input.readLine()) != null) {if (line.length() < wocidx) {continue;}// 字段出现顺序:Caption,CommandLine,KernelModeTime,ReadOperationCount,// ThreadCount,UserModeTime,WriteOperationString caption =substring(line, capidx, cmdidx - 1).trim();String cmd = substring(line, cmdidx, kmtidx - 1).trim();if (cmd.indexOf("wmic.exe") >= 0) {continue;}String s1 = substring(line, kmtidx, rocidx - 1).trim();String s2 = substring(line, umtidx, wocidx - 1).trim();if (caption.equals("System Idle Process") || caption.equals("System")) { if (s1.length() > 0)idletime += Long.valueOf(s1).longValue();if (s2.length() > 0)idletime += Long.valueOf(s2).longValue();}if (s1.length() > 0)kneltime += Long.valueOf(s1).longValue();if (s2.length() > 0)usertime += Long.valueOf(s2).longValue();}retn[0] = idletime;retn[1] = kneltime + usertime;return retn;} catch (Exception ex) {ex.printStackTrace();} finally {try {proc.getInputStream().close();} catch (Exception e) {e.printStackTrace();}}return null;}/*** 由于String.subString对汉字处理存在问题(把一个汉字视为一个字节),因此在包含汉字的字符串时存在隐患,现调整如下:* @param src 要截取的字符串* @param start_idx 开始坐标(包括该坐标)* @param end_idx 截止坐标(包括该坐标)* @return*/private static String substring(String src, int start_idx, int end_idx) {byte[] b = src.getBytes();String tgt = "";for (int i = start_idx; i <= end_idx; i++) {tgt += (char) b[i];}return tgt;}}2.利用第三方的jar包:(Hyperic-hq官方网站:)通过Hyperic-hq产品的基础包sigar.jar来实现服务器状态数据的获取。
【Java】+获取Linux服务器的CPU、内存使用率
【Java】+获取Linux服务器的CPU、内存使⽤率package montool;import ch.ethz.ssh2.Connection;import ch.ethz.ssh2.Session;import ch.ethz.ssh2.StreamGobbler;import montool.file.ZgxFileUtil;import ng3.tuple.Pair;import org.apache.log4j.Logger;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStream;import java.io.InputStreamReader;import java.math.BigDecimal;import java.util.ArrayList;import java.util.List;/*** @author* @version 1.0* @time 2019/7/15 20:28* <p>* 类功能说明:* 1、连接服务器* 2、执⾏Linux⽇志查询命令,返回查询后的⽇志字符串(以⾏为单位)*/public class LogAuto {private static Logger log;private Session ssh;private String hostName;private String userName;private String password;private int port;/*** 连接服务器** @param hostname 服务器IP* @param port 端⼝* @param username 账号* @param password 密码*/public LogAuto(String hostname, int port, String username, String password) {this.hostName = hostname;this.port = port;erName = username;this.password = password;this.log = ZgxLoggerUtil.getLoger(LogAuto.class);}/*** 通过Linux命令查询⽇志内容** @param command Linux⽇志查询命令* @return返回根据命令查出的⽇志内容*/public List<String> execCom(String command) {Connection conn = new Connection(this.hostName, this.port);createConnection(conn);List<String> logContent = new ArrayList<String>();try {ssh.execCommand(command);} catch (IOException e) {e.printStackTrace();}//将Terminal屏幕上的⽂字全部打印出来InputStream is = new StreamGobbler(ssh.getStdout());BufferedReader brs = new BufferedReader(new InputStreamReader(is));while (true) {String line = null;try {line = brs.readLine();} catch (IOException e) {e.printStackTrace();}if (line == null) {break;}// System.out.println(line);logContent.add(line);}return logContent;}private void createConnection(Connection connection) {//创建连接try {connection.connect();} catch (IOException e) {e.printStackTrace();}try {connection.authenticateWithPassword(erName, this.password);} catch (IOException e) {e.printStackTrace();}//创建与服务器的会话节点try {setSsh(connection.openSession());} catch (IOException e) {e.printStackTrace();}}private void setSsh(Session ssh) {this.ssh = ssh;}private Session getSsh() {return ssh;}/*** 功能:获取指定服务器在当前时间的内存使⽤率** @param logAuto* @return返回使⽤率(百分⽐)*/public static double getMemoryRate(LogAuto logAuto) {String shell = String.format("%s", "free"); // 多个命令⽤“;”隔开List<String> listResult = logAuto.execCom(shell);// 打印shell命令执⾏后的结果for (int i = 0; i < listResult.size(); i++) {System.out.println(listResult.get(i));}// 提取内存数据(第⼆⾏)List<String> mem = ZgxStringUtil.splitString(listResult.get(1), " ");Integer usedMemory = Integer.valueOf(mem.get(2));Integer allMemory = Integer.valueOf(mem.get(1));(String.format("usedMemory=%s;allMemory=%s", usedMemory, allMemory));// 计算内存使⽤率(已使⽤内存/总内存)double f1 = new BigDecimal((float) usedMemory / allMemory).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue() * 100; (String.format("内存使⽤率=%s%s", f1, "%"));return f1;}private static Pair getCpuData(LogAuto logAuto) {String shell = String.format("%s", "cat /proc/stat"); // 多个命令⽤“;”隔开List<String> listResult = logAuto.execCom(shell);// 打印shell命令执⾏后的结果for (int i = 0; i < listResult.size(); i++) {System.out.println(listResult.get(i));}// 提取CPU数据(第⼀⾏)List<String> mem = ZgxStringUtil.splitString(listResult.get(0), " ");mem.remove(0);Long allTime1 = 0L;for (int i = 0; i < mem.size(); i++) {allTime1 += Long.valueOf(mem.get(i));}System.out.println(String.format("CPU使⽤总时间=%s;idle=%s", allTime1, mem.get(3)));return Pair.of(allTime1, mem.get(3));}/*** 功能:获取指定服务器在当前时间的CPU使⽤率** @param logAuto* @return返回使⽤率(百分⽐)*/public static double getCpuRate(LogAuto logAuto) {Pair cpuData1 = getCpuData(logAuto);try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}Pair cpuData2 = getCpuData(logAuto);// step1 计算两次的cpu总时间Long allTime = Long.valueOf(cpuData2.getLeft().toString()) - Long.valueOf(cpuData1.getLeft().toString());// step2 计算两次的cpu剩余时间Long idle = Long.valueOf(cpuData2.getRight().toString()) - Long.valueOf(cpuData1.getRight().toString());// step3 计算两次的cpu使⽤时间Long used = allTime - idle;// step4 计算cpu使⽤率(cpu使⽤率 = 使⽤时间 / 总时间 * 100%)double f1 = new BigDecimal((float) used / allTime).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue() * 100; (String.format("CPU使⽤率=%s%s", f1, "%"));return f1;}public static void main(String[] args) {LogAuto logAuto = new LogAuto("服务器IP", 端⼝号, "账号", "密码");getMemoryRate(logAuto);getCpuRate(logAuto);String[] header = {"时间,CPU使⽤率,内存使⽤率"};List<String[]> content = new ArrayList<>();// 每分钟获取⼀次服务器CPU、内存使⽤率(获取30次)for (int i = 0; i < 30; i++) {String[] data = {ZgxDateUtil.getNowDate("yyyy-MM-dd HH:mm:ss"), String.valueOf(getCpuRate(logAuto)), String.valueOf(getMemoryRate(logAuto))};content.add(data);ZgxFileUtil.writeCsv("服务器性能数据.csv", header, content);try {Thread.sleep(1000 * 60);} catch (InterruptedException e) {e.printStackTrace();}}}}。
Java获得cpu和内存的使用情况的两种方法
Java获得cpu和内存的使用情况最近做个项目,就是要取得cpu占有率等等的系统信息,一开始以为要用动态链接库了,但后来发现可以像下面这样做,不去调用jni,这样省去了很多看新技术的时间o(∩_∩)o...在Java中,可以获得总的物理内存、剩余的物理内存、已使用的物理内存等信息,下面例子可以取得这些信息,并且获得在Windows下的内存使用率。
首先编写一个MonitorInfoBean类,用来装载监控的一些信息,包括物理内存、剩余的物理内存、已使用的物理内存、内存使用率等字段,该类的代码如下:Java代码接着编写一个获得当前的监控信息的接口,该类的代码如下所示:Java代码该类的实现类MonitorServiceImpl如下所示:Java代码该实现类中需要用到一个自己编写byte的工具类,该类的代码如下所示:Java代码运行下MonitorBeanImpl类,读者将会看到当前的内存、cpu利用率等信息。
这种方式获得效率比较慢,如果在linux下,可以使用下面的方式:public final class LinuxSystemTool implements Runnable{// private Logger log = Logger.getLogger(LinuxSystemTool.class);// private Config config=Config.getInstance();/*** get memory by used info** @return int[] result* result.length==4;int[0]=MemTotal;int[1]=MemFree;int[2]=SwapTotal;int[3]=SwapFree;* @throws IOException* @throws InterruptedException*/public void run() { // TODO Auto-generated method stub}public static int[] getMemInfo() throws IOException, InterruptedException {File file = new File("/proc/meminfo");BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(file)));int[] result = new int[4];String str = null;StringTokenizer token = null;while ((str = br.readLine()) != null) {token = new StringTokenizer(str);if (!token.hasMoreTokens())continue;str = token.nextToken();if (!token.hasMoreTokens())continue;if (str.equalsIgnoreCase("MemTotal:"))result[0] = Integer.parseInt(token.nextToken());else if (str.equalsIgnoreCase("MemFree:"))result[1] = Integer.parseInt(token.nextToken());else if (str.equalsIgnoreCase("SwapTotal:"))result[2] = Integer.parseInt(token.nextToken());else if (str.equalsIgnoreCase("SwapFree:"))result[3] = Integer.parseInt(token.nextToken());}return result;}/*** get memory by used info** @return float efficiency* @throws IOException* @throws InterruptedException*/public static float getCpuInfo() throws IOException, InterruptedException { File file = new File("/proc/stat");BufferedReader br = new BufferedReader(new InputStreamReader( new FileInputStream(file)));StringTokenizer token = new StringTokenizer(br.readLine());token.nextToken();int user1 = Integer.parseInt(token.nextToken());int nice1 = Integer.parseInt(token.nextToken());int sys1 = Integer.parseInt(token.nextToken());int idle1 = Integer.parseInt(token.nextToken());Thread.sleep(1000);br = new BufferedReader(new InputStreamReader(new FileInputStream(file)));token = new StringTokenizer(br.readLine());token.nextToken();int user2 = Integer.parseInt(token.nextToken());int nice2 = Integer.parseInt(token.nextToken());int sys2 = Integer.parseInt(token.nextToken());int idle2 = Integer.parseInt(token.nextToken());return (float) ((user2 + sys2 + nice2) - (user1 + sys1 + nice1)) / (float) ((user2 + nice2 + sys2 + idle2) - (user1 + nice1+ sys1 + idle1));}/*** 测试类** <p>** @author* </p>* @date*/public static void main(String[] args) throws Exception {int[] memInfo = LinuxSystemTool.getMemInfo();System.out.println("MemTotal:" + memInfo[0]);System.out.println("MemFree:" + memInfo[1]);System.out.println("SwapTotal:" + memInfo[2]);System.out.println("SwapFree:" + memInfo[3]);System.out.println("CPU利用率:" + LinuxSystemTool.getCpuInfo());}}。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
.getOperatingSystemMXBean();
// 操作系统 String osName = System.getProperty(""); // 总的物理内存 long totalMemorySize = osmxb.getTotalPhysicalMemorySize() / k b; // 剩余的物理内存 long freePhysicalMemorySize = osmxb.getFreePhysicalMemorySize () / kb; // 已使用的物理内存 long usedMemory = (osmxb.getTotalPhysicalMemorySize() - osmxb
import sun.management.ManagementFactory;
import com.sun.management.OperatingSystemMXBean;
/** *//** * 获取系统信息的业务逻辑实现类. * @author amg * @version 1.0 Creation date: 2008-3-11 - 上午 10:06:06 */
public class MonitorServiceImpl implements IMonitorService { //可以设置长些,防止读到运行此次系统检查时的 cpu 占用率,就不准了 private static final int CPUTIME = 5000;
private static final int PERCENT = 100;
public class MonitorInfoBean { /** *//** 可使用内存. */ private long totalMemory;
/** *//** 剩余内存. */ private long freeMemory;
/** *//** 最大可使用内存. */ private long maxMemory;
mmandLine,"
+ "KernelModeTime,ReadOperationCount,ThreadCount,Use
rModeTime,WriteOperationCount";
// 取进程信息
long[] c0 = readCpu(Runtime.getRuntime().exec(procCmd));
private static final int FAULTLENGTH = 10;
/** *//**
* 获得当前的监控对象.来自* @return 返回构造好的监控对象
* @throws Exception
* @author amg
* Creation date: 2008-4-25 - 上午 10:45:08
}
public long getTotalMemorySize() { return totalMemorySize;
}
public void setTotalMemorySize(long totalMemorySize) { this.totalMemorySize = totalMemorySize;
.getFreePhysicalMemorySize()) / kb;
// 获得线程总数 ThreadGroup parentThread; for (parentThread = Thread.currentThread().getThreadGroup(); par entThread
.getParent() != null; parentThread = parentThread.getPar ent())
; int totalThread = parentThread.activeCount();
double cpuRatio = 0; if (osName.toLowerCase().startsWith("windows")) {
cpuRatio = this.getCpuRatioForWindows(); }
}
public long getFreePhysicalMemorySize() { return freePhysicalMemorySize;
}
public void setFreePhysicalMemorySize(long freePhysicalMemorySiz e) {
this.freePhysicalMemorySize = freePhysicalMemorySize; }
}
public void setUsedMemory(long usedMemory) { edMemory = usedMemory;
}
public double getCpuRatio() { return cpuRatio;
}
public void setCpuRatio(double cpuRatio) { this.cpuRatio = cpuRatio;
public MonitorInfoBean getMonitorInfoBean() throws Exception;
}
该类的实现类 MonitorServiceImpl 如下所示: Java 代码
package com.amgkaka.performance;
import java.io.InputStreamReader; import java.io.LineNumberReader;
infoBean.setTotalThread(totalThread); infoBean.setUsedMemory(usedMemory); infoBean.setCpuRatio(cpuRatio); return infoBean; }
/** *//**
* 获得 CPU 使用率.
* @return 返回 cpu 使用率
}
public int getTotalThread() { return totalThread;
}
public void setTotalThread(int totalThread) { this.totalThread = totalThread;
}
public long getUsedMemory() { return usedMemory;
public interface IMonitorService {
/** *//** * 获得当前的监控对象. * @return 返回构造好的监控对象 * @throws Exception * @author amgkaka * Creation date: 2008-4-25 - 上午 10:45:08 */
/** *//** 操作系统. */ private String osName;
/** *//** 总的物理内存. */ private long totalMemorySize;
/** *//** 剩余的物理内存. */ private long freePhysicalMemorySize;
/** *//** 已使用的物理内存. */ private long usedMemory;
* @author amg
* Creation date: 2008-4-25 - 下午 06:05:11
*/
private double getCpuRatioForWindows() {
try {
String procCmd = System.getenv("windir")
+ "\\system32\\wbem\\wmic.exe process get Caption,Co
public long getMaxMemory() { return maxMemory;
}
public void setMaxMemory(long maxMemory) { this.maxMemory = maxMemory;
}
public String getOsName() { return osName;
// 构造返回对象 MonitorInfoBean infoBean = new MonitorInfoBean(); infoBean.setFreeMemory(freeMemory); infoBean.setFreePhysicalMemorySize(freePhysicalMemorySize); infoBean.setMaxMemory(maxMemory); infoBean.setOsName(osName); infoBean.setTotalMemory(totalMemory); infoBean.setTotalMemorySize(totalMemorySize);
Thread.sleep(CPUTIME);
long[] c1 = readCpu(Runtime.getRuntime().exec(procCmd));
/** *//** 线程总数. */ private int totalThread;
/** *//** cpu 使用率. */ private double cpuRatio;
public long getFreeMemory() { return freeMemory;
}
public void setFreeMemory(long freeMemory) { this.freeMemory = freeMemory;
Java 获得 cpu 和内存的使用情况
最近做个项目,就是要取得 cpu 占有率等等的系统信息,一开始以为要用动态链接库了,但后来发现可以 像下面这样做,不去调用 jni,这样省去了很多看新技术的时间 o(∩_∩)o... 在 Java 中,可以获得总的物理内存、剩余的物理内存、已使用的物理内存等信息,下面例子可以取得这些 信息,并且获得在 Windows 下的内存使用率。