Linux下java获取CPU、内存、磁盘IO、网络带宽使用率

时间 2019-11-08

标签 linux java 获取 cpu 内存磁盘网络带宽使用栏目 Linux 繁體版

原文原文链接

1、CPUhtml

使用proc文件系统，"proc文件系统是一个伪文件系统，它只存在内存当中，而不占用外存空间。它以文件系统的方式为访问系统内核数据的操做提供接口。用户和应用程序能够经过proc获得系统的信息，并能够改变内核的某些参数。"java

从/proc文件系统获取cpu使用状况： cat /proc/statlinux

在Linux的内核中，有一个全局变量：Jiffies。 Jiffies表明时间。它的单位随硬件平台的不一样而不一样。系统里定义了一个常数HZ，表明每秒种最小时间间隔的数目。这样jiffies的单位就是 1/HZ。Intel平台jiffies的单位是1/100秒，这就是系统所能分辨的最小时间间隔了。每一个CPU时间片，Jiffies都要加1。 CPU的利用率就是用执行用户态+系统态的Jiffies除以总的Jifffies来表示。ios

在Linux系统中，CPU利用率的计算来源在/proc/stat文件，这个文件的头几行记录了每一个CPU的用户态，系统态，空闲态等状态下的不一样的Jiffies，经常使用的监控软件就是利用/proc/stat里面的这些数据来计算CPU的利用率的。

包含了全部CPU活动的信息，该文件中的全部值都是从系统启动开始累计到当前时刻。

[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 0shell

输出解释：
CPU 以及CPU0、CPU一、CPU二、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”：当前被阻塞的任务的数目。

那么CPU利用率的计算方法：可使用取两个采样点，计算其差值的办法。

CPU利用率 = 1- (idle2-idle1)/(cpu2-cpu1)

参考： linux下如何获取cpu的利用率

java中调用Linux的shell命令使用Process和Runtime

jdk1.6 API doc:

public class Runtimeextends Object

每一个 Java 应用程序都有一个 Runtime 类实例，使应用程序可以与其运行的环境相链接。能够经过getRuntime 方法获取当前运行时。apache

应用程序不能建立本身的 Runtime 类实例。网络

public abstract class Processextends Object

ProcessBuilder.start() 和Runtime.exec 方法建立一个本机进程，并返回 Process 子类的一个实例，该实例可用来控制进程并得到相关信息。app

代码：

<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>

2、内存

从/proc文件系统获取内存使用状况： cat /proc/meminfo

MemTotal: 8167348 kB
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

内存使用率 = 1 - MemFree/MemTotal

代码：

<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>

3、磁盘IO

使用iostat：

[root@localhost LoadBalanceAlg]# iostat -d -x
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

man iostat:

-d The -d option is exclusive of the -c option and displays only the device utilization report.

-x Display extended statistics. This option is exclusive of the -p and -n, and works with post 2.5 kernels since it needs /proc/diskstats file or a mounted sysfs to get the statistics. This option may also work with older kernels (e.g. 2.4) only if extended statistics are available in /proc/partitions (the kernel needs to be patched for that).

%util Percentage of CPU time during which I/O requests were issued to the device (bandwidth utilization for the device). Device saturation occurs when this value is close to 100%.

一秒中有百分之多少的时间用于I/O操做，或者说一秒中有多少时间I/O队列是非空的。若是%util接近100%,代表I/O请求太多,I/O系统已经满负荷，磁盘可能存在瓶颈,通常%util大于70%,I/O压力就比较大，读取速度有较多的wait。

参考： linux 查看磁盘IO状态操做指南

代码：

<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>

4、网络带宽

从/proc文件系统获取网络使用状况： cat /proc/net/dev

[root@localhost LoadBalanceAlg]# 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

统计一段时间内Receive和Tramsmit的bytes数的变化，便可得到网口传输速率，再除以网口的带宽就获得带宽的使用率

代码：

<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>