Linux下java获取CPU、内存、磁盘IO、网络带宽使用率
一、CPU
使用proc文件系统，"proc文件系统是一个伪文件系统，它只存在内存当中，而不占用外存空间。它以文件系统的方式为访问系统内核数据的操作提供接口。用户和应用程序可以通过proc得到系统的信息，并可以改变内核的某些参数。"
从/proc文件系统获取cpu使用情况： cat /proc/stat
在Linux的内核中，有一个全 局变量：Jiffies。 Jiffies代表时间。它的单位随硬件平台的不同而不同。系统里定义了一个常数HZ，代表每秒种最小时间间隔的数目。这样jiffies的单位就是 1/HZ。Intel平台jiffies的单位是1/100秒，这就是系统所能分辨的最小时间间隔了。每个CPU时间片，Jiffies都要加1。 CPU的利用率就是用执行用户态+系统态的Jiffies除以总的Jifffies来表示。
[root@localhost LoadBalanceAlg]# cat /proc/stat
cpu 71095 55513 76751 2545622893 303185 4160 47722 0
cpu0 3855 1134 4284 159122519 3882 0 717 0
cpu1 4236 770 5837 159113370 11291 6 865 0
cpu2 4934 1142 5048 158991321 130622 362 2939 0
cpu3 2320 14774 5177 159111528 1417 8 1138 0
cpu4 2694 405 3086 159071174 56284 235 2477 0
cpu5 1701 886 2560 159129034 1316 2 849 0
cpu6 2937 450 2863 159068480 59183 228 2198 0
cpu7 916 316 2426 159130057 1682 1 933 0
cpu8 2543 50 3509 159122844 4467 1 2911 0
cpu9 4761 827 6296 159118849 4490 8 1086 0
cpu10 8517 4236 9148 159102063 9791 173 2382 0
cpu11 22001 29737 14602 159065992 2583 6 1382 0
cpu12 3453 150 3075 159113794 5387 1162 9276 0
cpu13 2120 424 3403 159126526 2608 7 1199 0
cpu14 2637 65 2663 159107796 6704 1914 14503 0
cpu15 1462 142 2763 159127539 1470 39 2859 0
intr 1636622296 1591605869 4 0 4 4 0 0 0 1 0 0 0 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 952 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1005479 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 32763528 0 0 0 0 0 0 0 1697776 0 0 0 0 0 0 0 1556158 2 0 0 0 0 0 0 1598011 0 0 0 0 0 0 0 1287622 0 0 0 0 0 0 0 1522517 0 0 0 0 0 0 0 2467360 0 0 0 0 0 0 0 1116999 0 0 0 0 0 0 0 2 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
ctxt 431778894
btime 1363058934
processes 279394
procs_running 1
procs_blocked 0
CPU 以及CPU0、CPU1、CPU2、CPU3每行的每个参数意思（以第一行为例）为：
参数 解释
user (432661) 从系统启动开始累计到当前时刻，用户态的CPU时间（单位：jiffies） ，不包含 nice值为负进程。1jiffies=0.01秒
nice (13295) 从系统启动开始累计到当前时刻，nice值为负的进程所占用的CPU时间（单位：jiffies）
system (86656) 从系统启动开始累计到当前时刻，核心时间（单位：jiffies）
idle (422145968) 从系统启动开始累计到当前时刻，除硬盘IO等待时间以外其它等待时间（单位：jiffies）
iowait (171474) 从系统启动开始累计到当前时刻，硬盘IO等待时间（单位：jiffies） ，
irq (233) 从系统启动开始累计到当前时刻，硬中断时间（单位：jiffies）
softirq (5346) 从系统启动开始累计到当前时刻，软中断时间（单位：jiffies）
CPU时间=user+system+nice+idle+iowait+irq+softirq
“intr”这行给出中断的信息，第一个为自系统启动以来，发生的所有的中断的次数；然后每个数对应一个特定的中断自系统启动以来所发生的次数。
“ctxt”给出了自系统启动以来CPU发生的上下文交换的次数。
“btime”给出了从系统启动到现在为止的时间，单位为秒。
“processes (total_forks) 自系统启动以来所创建的任务的个数目。
“procs_running”：当前运行队列的任务的数目。
“procs_blocked”：当前被阻塞的任务的数目。
public class Runtimeextends Object
每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。可以通过getRuntime 方法获取当前运行时。
应用程序不能创建自己的 Runtime 类实例。
public abstract class Processextends Object
ProcessBuilder.start() 和Runtime.exec 方法创建一个本机进程，并返回 Process 子类的一个实例，该实例可用来控制进程并获得相关信息。
<span style="font-size:14px;">import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.StringWriter; import org.apache.log4j.Logger; /**
* 采集CPU使用率
*/
public class CpuUsage extends ResourceUsage { private static Logger log = Logger.getLogger(CpuUsage.class);
private static CpuUsage INSTANCE = new CpuUsage(); private CpuUsage(){ } public static CpuUsage getInstance(){
return INSTANCE;
} /**
* Purpose:采集CPU使用率
* @param args
* @return float,CPU使用率,小于1
*/
@Override
public float get() {
log.info("开始收集cpu使用率");
float cpuUsage = 0;
Process pro1,pro2;
Runtime r = Runtime.getRuntime();
try {
String command = "cat /proc/stat";
//第一次采集CPU时间
long startTime = System.currentTimeMillis();
pro1 = r.exec(command);
BufferedReader in1 = new BufferedReader(new InputStreamReader(pro1.getInputStream()));
String line = null;
long idleCpuTime1 = 0, totalCpuTime1 = 0; //分别为系统启动后空闲的CPU时间和总的CPU时间
while((line=in1.readLine()) != null){
if(line.startsWith("cpu")){
line = line.trim();
log.info(line);
String[] temp = line.split("\\s+");
idleCpuTime1 = Long.parseLong(temp[4]);
for(String s : temp){
if(!s.equals("cpu")){
totalCpuTime1 += Long.parseLong(s);
}
}
log.info("IdleCpuTime: " + idleCpuTime1 + ", " + "TotalCpuTime" + totalCpuTime1);
break;
}
}
in1.close();
pro1.destroy();
try {
Thread.sleep(100);
} catch (InterruptedException e) {
StringWriter sw = new StringWriter();
e.printStackTrace(new PrintWriter(sw));
log.error("CpuUsage休眠时发生InterruptedException. " + e.getMessage());
log.error(sw.toString());
}
//第二次采集CPU时间
long endTime = System.currentTimeMillis();
pro2 = r.exec(command);
BufferedReader in2 = new BufferedReader(new InputStreamReader(pro2.getInputStream()));
long idleCpuTime2 = 0, totalCpuTime2 = 0; //分别为系统启动后空闲的CPU时间和总的CPU时间
while((line=in2.readLine()) != null){
if(line.startsWith("cpu")){
line = line.trim();
log.info(line);
String[] temp = line.split("\\s+");
idleCpuTime2 = Long.parseLong(temp[4]);
for(String s : temp){
if(!s.equals("cpu")){
totalCpuTime2 += Long.parseLong(s);
}
}
log.info("IdleCpuTime: " + idleCpuTime2 + ", " + "TotalCpuTime" + totalCpuTime2);
break;
}
}
if(idleCpuTime1 != 0 && totalCpuTime1 !=0 && idleCpuTime2 != 0 && totalCpuTime2 !=0){
cpuUsage = 1 - (float)(idleCpuTime2 - idleCpuTime1)/(float)(totalCpuTime2 - totalCpuTime1);
log.info("本节点CPU使用率为: " + cpuUsage);
}
in2.close();
pro2.destroy();
} catch (IOException e) {
StringWriter sw = new StringWriter();
e.printStackTrace(new PrintWriter(sw));
log.error("CpuUsage发生InstantiationException. " + e.getMessage());
log.error(sw.toString());
}
return cpuUsage;
} /**
* @param args
* @throws InterruptedException
*/
public static void main(String[] args) throws InterruptedException {
while(true){
System.out.println(CpuUsage.getInstance().get());
Thread.sleep(5000);
}
}
}</span>
MemFree: 4109964 kB
Buffers: 35728 kB
Cached: 1877960 kB
SwapCached: 159088 kB
Active: 3184176 kB
Inactive: 672132 kB
HighTotal: 0 kB
HighFree: 0 kB
LowTotal: 8167348 kB
LowFree: 4109964 kB
SwapTotal: 26738680 kB
SwapFree: 26373632 kB
Dirty: 40 kB
Writeback: 0 kB
AnonPages: 1872416 kB
Mapped: 24928 kB
Slab: 107804 kB
PageTables: 34612 kB
NFS_Unstable: 0 kB
Bounce: 0 kB
CommitLimit: 30822352 kB
Committed_AS: 5386080 kB
VmallocTotal: 34359738367 kB
VmallocUsed: 276892 kB
VmallocChunk: 34359460287 kB
HugePages_Total: 0
HugePages_Free: 0
HugePages_Rsvd: 0
Hugepagesize: 2048 kB
<span style="font-size:14px;">import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.StringWriter; import org.apache.log4j.Logger; /**
* 采集内存使用率
*/
public class MemUsage extends ResourceUsage{ private static Logger log = Logger.getLogger(MemUsage.class);
private static MemUsage INSTANCE = new MemUsage(); private MemUsage(){ } public static MemUsage getInstance(){
return INSTANCE;
} /**
* Purpose:采集内存使用率
* @param args
* @return float,内存使用率,小于1
*/
@Override
public float get() {
log.info("开始收集memory使用率");
float memUsage = 0.0f;
Process pro = null;
Runtime r = Runtime.getRuntime();
try {
String command = "cat /proc/meminfo";
pro = r.exec(command);
BufferedReader in = new BufferedReader(new InputStreamReader(pro.getInputStream()));
String line = null;
int count = 0;
long totalMem = 0, freeMem = 0;
while((line=in.readLine()) != null){
log.info(line);
String[] memInfo = line.split("\\s+");
if(memInfo[0].startsWith("MemTotal")){
totalMem = Long.parseLong(memInfo[1]);
}
if(memInfo[0].startsWith("MemFree")){
freeMem = Long.parseLong(memInfo[1]);
}
memUsage = 1- (float)freeMem/(float)totalMem;
log.info("本节点内存使用率为: " + memUsage);
if(++count == 2){
break;
}
}
in.close();
pro.destroy();
} catch (IOException e) {
StringWriter sw = new StringWriter();
e.printStackTrace(new PrintWriter(sw));
log.error("MemUsage发生InstantiationException. " + e.getMessage());
log.error(sw.toString());
}
return memUsage;
} /**
* @param args
* @throws InterruptedException
*/
public static void main(String[] args) throws InterruptedException {
while(true){
System.out.println(MemUsage.getInstance().get());
Thread.sleep(5000);
}
}
}</span>
Linux 2.6.18-238.el5 (localhost.localdomain) 2013Äê03ÔÂ30ÈÕ
Device: rrqm/s wrqm/s r/s w/s rsec/s wsec/s avgrq-sz avgqu-sz await svctm %util
sda 0.09 0.28 0.02 0.03 0.92 2.57 60.71 0.00 63.28 3.33 0.02
sda1 0.00 0.00 0.00 0.00 0.00 0.00 24.40 0.00 2.59 2.53 0.00
sda2 0.09 0.28 0.02 0.03 0.92 2.57 60.76 0.00 63.36 3.34 0.02
sdb 0.03 0.72 0.04 0.53 2.57 10.04 22.09 0.01 17.36 5.12 0.29
sdb1 0.03 0.72 0.04 0.53 2.57 10.04 22.09 0.01 17.36 5.12 0.29
dm-0 0.00 0.00 0.07 1.30 2.63 10.40 9.53 0.03 24.95 2.15 0.29
dm-1 0.00 0.00 0.11 0.28 0.86 2.21 8.00 0.12 300.47 0.16 0.01
<span style="font-size:14px;">import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.StringWriter; import org.apache.log4j.Logger; /**
* 采集磁盘IO使用率
*/
public class IoUsage extends ResourceUsage{ private static Logger log = Logger.getLogger(IoUsage.class);
private static IoUsage INSTANCE = new IoUsage(); private IoUsage(){ } public static IoUsage getInstance(){
return INSTANCE;
} /**
* @Purpose:采集磁盘IO使用率
* @param args
* @return float,磁盘IO使用率,小于1
*/
@Override
public float get() {
log.info("开始收集磁盘IO使用率");
float ioUsage = 0.0f;
Process pro = null;
Runtime r = Runtime.getRuntime();
try {
String command = "iostat -d -x";
pro = r.exec(command);
BufferedReader in = new BufferedReader(new InputStreamReader(pro.getInputStream()));
String line = null;
int count = 0;
while((line=in.readLine()) != null){
if(++count >= 4){
// log.info(line);
String[] temp = line.split("\\s+");
if(temp.length > 1){
float util = Float.parseFloat(temp[temp.length-1]);
ioUsage = (ioUsage>util)?ioUsage:util;
}
}
}
if(ioUsage > 0){
log.info("本节点磁盘IO使用率为: " + ioUsage);
ioUsage /= 100;
}
in.close();
pro.destroy();
} catch (IOException e) {
StringWriter sw = new StringWriter();
e.printStackTrace(new PrintWriter(sw));
log.error("IoUsage发生InstantiationException. " + e.getMessage());
log.error(sw.toString());
}
return ioUsage;
} /**
* @param args
* @throws InterruptedException
*/
public static void main(String[] args) throws InterruptedException {
while(true){
System.out.println(IoUsage.getInstance().get());
Thread.sleep(5000);
}
} }</span>
从/proc文件系统获取网络使用情况： cat /proc/net/dev
Inter-| Receive | Transmit
face |bytes packets errs drop fifo frame compressed multicast|bytes packets errs drop fifo colls carrier compressed
lo:1402131426 15109136 0 0 0 0 0 0 1402131426 15109136 0 0 0 0 0 0
eth0:4546168400 42535979 0 0 0 0 0 44 5610190492 8943999 0 0 0 0 0 0
eth1: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
eth3: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
__tmp945063435: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
bond0:4546168400 42535979 0 0 0 0 0 44 5610190492 8943999 0 0 0 0 0 0
<span style="font-size:14px;">import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.StringWriter; import org.apache.log4j.Logger; /**
* 采集网络带宽使用率
*/
public class NetUsage extends ResourceUsage { private static Logger log = Logger.getLogger(NetUsage.class);
private static NetUsage INSTANCE = new NetUsage();
private final static float TotalBandwidth = 1000; //网口带宽,Mbps private NetUsage(){ } public static NetUsage getInstance(){
return INSTANCE;
} /**
* @Purpose:采集网络带宽使用率
* @param args
* @return float,网络带宽使用率,小于1
*/
@Override
public float get() {
log.info("开始收集网络带宽使用率");
float netUsage = 0.0f;
Process pro1,pro2;
Runtime r = Runtime.getRuntime();
try {
String command = "cat /proc/net/dev";
//第一次采集流量数据
long startTime = System.currentTimeMillis();
pro1 = r.exec(command);
BufferedReader in1 = new BufferedReader(new InputStreamReader(pro1.getInputStream()));
String line = null;
long inSize1 = 0, outSize1 = 0;
while((line=in1.readLine()) != null){
line = line.trim();
if(line.startsWith("eth0")){
log.info(line);
String[] temp = line.split("\\s+");
inSize1 = Long.parseLong(temp[0].substring(5)); //Receive bytes,单位为Byte
outSize1 = Long.parseLong(temp[8]); //Transmit bytes,单位为Byte
break;
}
}
in1.close();
pro1.destroy();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
StringWriter sw = new StringWriter();
e.printStackTrace(new PrintWriter(sw));
log.error("NetUsage休眠时发生InterruptedException. " + e.getMessage());
log.error(sw.toString());
}
//第二次采集流量数据
long endTime = System.currentTimeMillis();
pro2 = r.exec(command);
BufferedReader in2 = new BufferedReader(new InputStreamReader(pro2.getInputStream()));
long inSize2 = 0 ,outSize2 = 0;
while((line=in2.readLine()) != null){
line = line.trim();
if(line.startsWith("eth0")){
log.info(line);
String[] temp = line.split("\\s+");
inSize2 = Long.parseLong(temp[0].substring(5));
outSize2 = Long.parseLong(temp[8]);
break;
}
}
if(inSize1 != 0 && outSize1 !=0 && inSize2 != 0 && outSize2 !=0){
float interval = (float)(endTime - startTime)/1000;
//网口传输速度,单位为bps
float curRate = (float)(inSize2 - inSize1 + outSize2 - outSize1)*8/(1000000*interval);
netUsage = curRate/TotalBandwidth;
log.info("本节点网口速度为: " + curRate + "Mbps");
log.info("本节点网络带宽使用率为: " + netUsage);
}
in2.close();
pro2.destroy();
} catch (IOException e) {
StringWriter sw = new StringWriter();
e.printStackTrace(new PrintWriter(sw));
log.error("NetUsage发生InstantiationException. " + e.getMessage());
log.error(sw.toString());
}
return netUsage;
} /**
* @param args
* @throws InterruptedException
*/
public static void main(String[] args) throws InterruptedException {
while(true){
System.out.println(NetUsage.getInstance().get());
Thread.sleep(5000);
}
}
}</span>
Linux下java获取CPU、内存、磁盘IO、网络带宽使用率的更多相关文章
- Linux下java进程CPU占用率高分析方法
Linux下java进程CPU占用率高分析方法 在工作当中,肯定会遇到由代码所导致的高CPU耗用以及内存溢出的情况.这种情况发生时,我们怎么去找出原因并解决. 一般解决方法是通过top命令找出消耗资源 ...
- Linux下java进程CPU占用率高分析方法（一）
Linux下java进程CPU占用率高分析方法 在工作当中,肯定会遇到由代码所导致的高CPU耗用以及内存溢出的情况.这种情况发生时,我们怎么去找出原因并解决. 一般解决方法是通过top命令找出消耗资源 ...
- (转)Linux下java进程CPU占用率高-分析方法
Linux下java进程CPU占用率高-分析方法 原文:http://itindex.net/detail/47420-linux-java-%E8%BF%9B%E7%A8%8B?utm_source ...
- 【转】Linux 下取进程占用 cpu/内存 最高的前10个进程
# Linux 下 取进程占用 cpu 最高的前10个进程ps aux|head -1;ps aux|grep -v PID|sort -rn -k +3|head # linux 下 取进程占用内存 ...
- linux 下取进程占用 cpu/内存 最高的前10个进程
linux下获取占用CPU资源最多的10个进程,可以使用如下命令组合: ;|head linux下获取占用内存资源最多的10个进程,可以使用如下命令组合: ;|head 命令组合解析(针对CPU的,M ...
- Linux下java进程CPU占用率高-分析方法
今天登陆同事的一台gateway 开始以为hive环境登陆不了了,仔细一看看了下是因为机器很卡,我每次等几秒没登陆就ctrl+c了,看了下是有个java进程cpu:340.4% mem:14.6% ...
- 排查linux下java应用cpu占用过高
用于快速排查Java的CPU性能问题(top us值过高),自动查出运行的Java进程中消耗CPU多的线程,并打印出其线程栈,从而确定导致性能问题的方法调用.目前只支持Linux.原因是Mac.Win ...
- Linux下java进程CPU占用率高分析方法（二）
1. 通过 top 命令查看当前系统CPU使用情况,定位CPU使用率超过100%的进程ID:2. 通过 ps aux | grep PID 命令进一步确定具体的线程信息:3. 通过 ps -mp pi ...
- 方法：Linux 下用JAVA获取CPU、内存、磁盘的系统资源信息
CPU使用率: InputStream is = null; InputStreamReader isr = null; BufferedReader brStat = null; StringTok ...
随机推荐
- Having与Where的区别
where 子句的作用是在对查询结果进行分组前,将不符合where条件的行去掉,即在分组之前过滤数据,where条件中不能包含聚组函数,使用where条件过滤出特定的行. having 子句的作用是筛 ...
- abstract class和interface的区别
1. 引言 2. 概念引入 ●什么是接口? 接口是包含一组虚方法的抽象类型,其中每一种方法都有其名称.参数和返回值.接口方法不能包含任何实现,CLR允许接口可以包含事件.属性.索引 器.静态方法.静态 ...
- 高效PHP开发注意事项
2015年2月26日 17:23:26 http://www.open-open.com/lib/view/open1332904714233.html
- 浅谈mysql集群
一.什么是MySQL集群 MySQL集群是一个无共享的(shared-nothing).分布式节点架构的存储方案,其目的是提供容错性和高性能. 数据更新使用读已提交隔离级别(read-committe ...
- Java for LeetCode 035 Search Insert Position
Given a sorted array and a target value, return the index if the target is found. If not, return the ...
- Java for LeetCode 030 Substring with Concatenation of All Words【HARD】
You are given a string, s, and a list of words, words, that are all of the same length. Find all sta ...
- SimpleDataFormat格式
public class SimpleDateFormat extends DateFormat SimpleDateFormat 是一个以国别敏感的方式格式化和分析数据的具体类. 它允许格式化 (d ...
- css3学习总结9--CSS3过渡
CSS3 过渡 通过 CSS3,我们可以在不使用 Flash 动画或 JavaScript 的情况下,当元素从一种样式变换为另一种样式时为元素添加效果. 过渡属性 属性 描述 CSS transiti ...
- Interger 与 int
int是java提供的8种原始数据类型之一.Java为每个原始类型提供了封装类,Integer是java为int提供的封装类.int的默认值为0,而Integer的默认值为null,即Integer可 ...
- hdu 1195:Open the Lock（暴力BFS广搜）
Open the Lock Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)Tot ...