精华内容
下载资源
问答
  • 需要用到jcraft依赖,如果依赖失效,请前往官方获取jcraft官网,maven地址https://search.maven.org/artifact/com.jcraft/jsch <dependency> <groupId>com.jcraft</groupId> <artifactId&...

    需要用到jcraft依赖,如果依赖失效,请前往官方获取jcraft官网,maven地址https://search.maven.org/artifact/com.jcraft/jsch

            <dependency>
                <groupId>com.jcraft</groupId>
                <artifactId>jsch</artifactId>
                <version>0.1.55</version>
            </dependency>

     一个java类就可以了

    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.util.HashMap;
    import java.util.Map;
    
    import com.jcraft.jsch.Channel;
    import com.jcraft.jsch.ChannelExec;
    import com.jcraft.jsch.JSch;
    import com.jcraft.jsch.JSchException;
    import com.jcraft.jsch.Session;
    
    /**
     * 远程调用Linux shell 命令
     *
     * @author wei.Li by 14-9-2.
     */
    class LinuxStateForShell {
    
    
        public static final String CPU_MEM_SHELL = "top -b -n 1";
        public static final String FILES_SHELL = "df -hl";
        public static final String[] COMMANDS = {CPU_MEM_SHELL, FILES_SHELL};
        public static final String LINE_SEPARATOR = System.getProperty("line.separator");
        private static Session session;
    
        /**
         * 连接到指定的HOST
         *
         * @return isConnect
         * @throws JSchException JSchException
         */
        private static boolean connect(String user, String passwd, String host) {
            JSch jsch = new JSch();
            try {
                session = jsch.getSession(user, host, 22);
                session.setPassword(passwd);
    
                java.util.Properties config = new java.util.Properties();
                config.put("StrictHostKeyChecking", "no");
                session.setConfig(config);
    
                session.connect();
            } catch (JSchException e) {
                e.printStackTrace();
                System.out.println("connect error !");
                return false;
            }
            return true;
        }
    
        /**
         * 远程连接Linux 服务器 执行相关的命令
         *
         * @param commands 执行的脚本
         * @param user     远程连接的用户名
         * @param passwd   远程连接的密码
         * @param host     远程连接的主机IP
         * @return 最终命令返回信息
         */
        public static Map<String, String> runDistanceShell(String[] commands, String user, String passwd, String host) {
            if (!connect(user, passwd, host)) {
                return null;
            }
            Map<String, String> map = new HashMap<>();
            StringBuilder stringBuffer;
    
            BufferedReader reader = null;
            Channel channel = null;
            try {
                for (String command : commands) {
                    stringBuffer = new StringBuilder();
                    channel = session.openChannel("exec");
                    ((ChannelExec) channel).setCommand(command);
    
                    channel.setInputStream(null);
                    ((ChannelExec) channel).setErrStream(System.err);
    
                    channel.connect();
                    InputStream in = channel.getInputStream();
                    reader = new BufferedReader(new InputStreamReader(in));
                    String buf;
                    while ((buf = reader.readLine()) != null) {
    
                        //舍弃PID 进程信息
                        if (buf.contains("PID")) {
                            break;
                        }
                        stringBuffer.append(buf.trim()).append(LINE_SEPARATOR);
                    }
                    //每个命令存储自己返回数据-用于后续对返回数据进行处理
                    map.put(command, stringBuffer.toString());
                }
            } catch (IOException | JSchException e) {
                e.printStackTrace();
            } finally {
                try {
                    if (reader != null) {
                        reader.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (channel != null) {
                    channel.disconnect();
                }
                session.disconnect();
            }
            return map;
        }
    
    
        /**
         * 直接在本地执行 shell
         *
         * @param commands 执行的脚本
         * @return 执行结果信息
         */
        public static Map<String, String> runLocalShell(String[] commands) {
            Runtime runtime = Runtime.getRuntime();
    
            Map<String, String> map = new HashMap<>();
            StringBuilder stringBuffer;
    
            BufferedReader reader;
            Process process;
            for (String command : commands) {
                stringBuffer = new StringBuilder();
                try {
                    process = runtime.exec(command);
                    InputStream inputStream = process.getInputStream();
                    reader = new BufferedReader(new InputStreamReader(inputStream));
                    String buf;
                    while ((buf = reader.readLine()) != null) {
                        //舍弃PID 进程信息
                        if (buf.contains("PID")) {
                            break;
                        }
                        stringBuffer.append(buf.trim()).append(LINE_SEPARATOR);
                    }
    
                } catch (IOException e) {
                    e.printStackTrace();
                    return null;
                }
                //每个命令存储自己返回数据-用于后续对返回数据进行处理
                map.put(command, stringBuffer.toString());
            }
            return map;
        }
    
    
        /**
         * 处理 shell 返回的信息
         * <p>
         * 具体处理过程以服务器返回数据格式为准
         * 不同的Linux 版本返回信息格式不同
         *
         * @param result shell 返回的信息
         * @return 最终处理后的信息
         */
        private static String disposeResultMessage(Map<String, String> result) {
    
            StringBuilder buffer = new StringBuilder();
    
            for (String command : COMMANDS) {
                String commandResult = result.get(command);
                if (null == commandResult) continue;
    
                if (command.equals(CPU_MEM_SHELL)) {
                    String[] strings = commandResult.split(LINE_SEPARATOR);
                    //将返回结果按换行符分割
                    for (String line : strings) {
                        line = line.toUpperCase();//转大写处理
    
                        //处理CPU Cpu(s): 10.8%us,  0.9%sy,  0.0%ni, 87.6%id,  0.7%wa,  0.0%hi,  0.0%si,  0.0%st
                        if (line.startsWith("CPU(S):")) {
                            String cpuStr = "CPU 用户使用占有率:";
                            try {
                                cpuStr += line.split(":")[1].split(",")[0].replace("US", "");
                            } catch (Exception e) {
                                e.printStackTrace();
                                cpuStr += "计算过程出错";
                            }
                            buffer.append(cpuStr).append(LINE_SEPARATOR);
    
                            //处理内存 Mem:  66100704k total, 65323404k used,   777300k free,    89940k buffers
                        } else if (line.startsWith("MEM")) {
                            String memStr = "内存使用情况:";
                            try {
                                memStr += line.split(":")[1]
                                        .replace("TOTAL", "总计")
                                        .replace("USED", "已使用")
                                        .replace("FREE", "空闲")
                                        .replace("BUFFERS", "缓存");
    
                            } catch (Exception e) {
                                e.printStackTrace();
                                memStr += "计算过程出错";
                                buffer.append(memStr).append(LINE_SEPARATOR);
                                continue;
                            }
                            buffer.append(memStr).append(LINE_SEPARATOR);
    
                        }
                    }
                } else if (command.equals(FILES_SHELL)) {
                    //处理系统磁盘状态
                    buffer.append("系统磁盘状态:");
                    try {
                        buffer.append(disposeFilesSystem(commandResult)).append(LINE_SEPARATOR);
                    } catch (Exception e) {
                        e.printStackTrace();
                        buffer.append("计算过程出错").append(LINE_SEPARATOR);
                    }
                }
            }
    
            return buffer.toString();
        }
    
        //处理系统磁盘状态
    
        /**
         * Filesystem            Size  Used Avail Use% Mounted on
         * /dev/sda3             442G  327G   93G  78% /
         * tmpfs                  32G     0   32G   0% /dev/shm
         * /dev/sda1             788M   60M  689M   8% /boot
         * /dev/md0              1.9T  483G  1.4T  26% /ezsonar
         *
         * @param commandResult 处理系统磁盘状态shell执行结果
         * @return 处理后的结果
         */
        private static String disposeFilesSystem(String commandResult) {
            String[] strings = commandResult.split(LINE_SEPARATOR);
    
            // final String PATTERN_TEMPLATE = "([a-zA-Z0-9%_/]*)\\s";
            int size = 0;
            int used = 0;
            for (int i = 0; i < strings.length - 1; i++) {
                if (i == 0) continue;
    
                int temp = 0;
                for (String s : strings[i].split("\\b")) {
                    if (temp == 0) {
                        temp++;
                        continue;
                    }
                    if (!s.trim().isEmpty()) {
                        if (temp == 1) {
                            size += disposeUnit(s);
                            temp++;
                        } else {
                            used += disposeUnit(s);
                            temp = 0;
                        }
                    }
                }
            }
            return new StringBuilder().append("大小 ").append(size).append("G , 已使用").append(used).append("G ,空闲")
                    .append(size - used).append("G").toString();
        }
    
        /**
         * 处理单位转换
         * K/KB/M/T 最终转换为G 处理
         *
         * @param s 带单位的数据字符串
         * @return 以G 为单位处理后的数值
         */
        private static int disposeUnit(String s) {
    
            try {
                s = s.toUpperCase();
                String lastIndex = s.substring(s.length() - 1);
                String num = s.substring(0, s.length() - 1);
                int parseInt = Integer.parseInt(num);
                if (lastIndex.equals("G")) {
                    return parseInt;
                } else if (lastIndex.equals("T")) {
                    return parseInt * 1024;
                } else if (lastIndex.equals("M")) {
                    return parseInt / 1024;
                } else if (lastIndex.equals("K") || lastIndex.equals("KB")) {
                    return parseInt / (1024 * 1024);
                }
            } catch (NumberFormatException e) {
                e.printStackTrace();
                return 0;
            }
            return 0;
        }
    
        public static void main(String[] args) {
            Map<String, String> result = runDistanceShell(COMMANDS, "root", "password", "192.168.12.12");
            System.out.println(disposeResultMessage(result));
        }
    
    }
    

    显示效果如下:

    CPU 用户使用占有率: 14.5%
    内存使用情况:  65972228K 总计, 55482940K 已使用, 10489288K 空闲,  3216072K 缓存
    系统磁盘状态:大小 986G , 已使用25G ,空闲961G

     

    展开全文
  • 利用java获取Linux服务器CPU、内存、磁盘IO、网络带宽使用率 原创 2013年03月30日 21:34:39 标签:

    利用java获取Linux服务器的CPU、内存、磁盘IO、网络带宽使用率

    原创 2013年03月30日 21:34:39

    一、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来表示。

    在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 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”:当前被阻塞的任务的数目。
     
    那么CPU利用率的计算方法:可以使用取两个采样点,计算其差值的办法。
    CPU利用率 = 1- (idle2-idle1)/(cpu2-cpu1)


    java中调用Linux的shell命令使用Process和Runtime
    jdk1.6 API doc:
    public class Runtime
    extends Object
    
    

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

    应用程序不能创建自己的 Runtime 类实例。 

    public abstract class Process
    extends Object
    
    

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

    代码:
    1. <span style=“font-size:14px;”>import java.io.BufferedReader;  
    2. import java.io.IOException;  
    3. import java.io.InputStreamReader;  
    4. import java.io.PrintWriter;  
    5. import java.io.StringWriter;  
    6.   
    7. import org.apache.log4j.Logger;  
    8.   
    9. /** 
    10.  * 采集CPU使用率 
    11.  */  
    12. public class CpuUsage extends ResourceUsage {  
    13.   
    14.     private static Logger log = Logger.getLogger(CpuUsage.class);  
    15.     private static CpuUsage INSTANCE = new CpuUsage();  
    16.       
    17.     private CpuUsage(){  
    18.       
    19.     }  
    20.       
    21.     public static CpuUsage getInstance(){  
    22.         return INSTANCE;  
    23.     }  
    24.       
    25.     /** 
    26.      * Purpose:采集CPU使用率 
    27.      * @param args 
    28.      * @return float,CPU使用率,小于1 
    29.      */  
    30.     @Override  
    31.     public float get() {  
    32.         log.info(”开始收集cpu使用率”);  
    33.         float cpuUsage = 0;  
    34.         Process pro1,pro2;  
    35.         Runtime r = Runtime.getRuntime();  
    36.         try {  
    37.             String command = ”cat /proc/stat”;  
    38.             //第一次采集CPU时间  
    39.             long startTime = System.currentTimeMillis();  
    40.             pro1 = r.exec(command);  
    41.             BufferedReader in1 = new BufferedReader(new InputStreamReader(pro1.getInputStream()));  
    42.             String line = null;  
    43.             long idleCpuTime1 = 0, totalCpuTime1 = 0;   //分别为系统启动后空闲的CPU时间和总的CPU时间  
    44.             while((line=in1.readLine()) != null){     
    45.                 if(line.startsWith(“cpu”)){  
    46.                     line = line.trim();  
    47.                     log.info(line);  
    48.                     String[] temp = line.split(”\\s+”);   
    49.                     idleCpuTime1 = Long.parseLong(temp[4]);  
    50.                     for(String s : temp){  
    51.                         if(!s.equals(“cpu”)){  
    52.                             totalCpuTime1 += Long.parseLong(s);  
    53.                         }  
    54.                     }     
    55.                     log.info(”IdleCpuTime: ” + idleCpuTime1 + “, ” + “TotalCpuTime” + totalCpuTime1);  
    56.                     break;  
    57.                 }                         
    58.             }     
    59.             in1.close();  
    60.             pro1.destroy();  
    61.             try {  
    62.                 Thread.sleep(100);  
    63.             } catch (InterruptedException e) {  
    64.                 StringWriter sw = new StringWriter();  
    65.                 e.printStackTrace(new PrintWriter(sw));  
    66.                 log.error(”CpuUsage休眠时发生InterruptedException. ” + e.getMessage());  
    67.                 log.error(sw.toString());  
    68.             }  
    69.             //第二次采集CPU时间  
    70.             long endTime = System.currentTimeMillis();  
    71.             pro2 = r.exec(command);  
    72.             BufferedReader in2 = new BufferedReader(new InputStreamReader(pro2.getInputStream()));  
    73.             long idleCpuTime2 = 0, totalCpuTime2 = 0;   //分别为系统启动后空闲的CPU时间和总的CPU时间  
    74.             while((line=in2.readLine()) != null){     
    75.                 if(line.startsWith(“cpu”)){  
    76.                     line = line.trim();  
    77.                     log.info(line);  
    78.                     String[] temp = line.split(”\\s+”);   
    79.                     idleCpuTime2 = Long.parseLong(temp[4]);  
    80.                     for(String s : temp){  
    81.                         if(!s.equals(“cpu”)){  
    82.                             totalCpuTime2 += Long.parseLong(s);  
    83.                         }  
    84.                     }  
    85.                     log.info(”IdleCpuTime: ” + idleCpuTime2 + “, ” + “TotalCpuTime” + totalCpuTime2);  
    86.                     break;    
    87.                 }                                 
    88.             }  
    89.             if(idleCpuTime1 != 0 && totalCpuTime1 !=0 && idleCpuTime2 != 0 && totalCpuTime2 !=0){  
    90.                 cpuUsage = 1 - (float)(idleCpuTime2 - idleCpuTime1)/(float)(totalCpuTime2 - totalCpuTime1);  
    91.                 log.info(”本节点CPU使用率为: ” + cpuUsage);  
    92.             }                 
    93.             in2.close();  
    94.             pro2.destroy();  
    95.         } catch (IOException e) {  
    96.             StringWriter sw = new StringWriter();  
    97.             e.printStackTrace(new PrintWriter(sw));  
    98.             log.error(”CpuUsage发生InstantiationException. ” + e.getMessage());  
    99.             log.error(sw.toString());  
    100.         }     
    101.         return cpuUsage;  
    102.     }  
    103.   
    104.     /** 
    105.      * @param args 
    106.      * @throws InterruptedException  
    107.      */  
    108.     public static void main(String[] args) throws InterruptedException {  
    109.         while(true){  
    110.             System.out.println(CpuUsage.getInstance().get());  
    111.             Thread.sleep(5000);       
    112.         }  
    113.     }  
    114. }</span>  
    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);     
            }
        }
    }


    二、内存

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

    代码:
    1. <span style=“font-size:14px;”>import java.io.BufferedReader;  
    2. import java.io.IOException;  
    3. import java.io.InputStreamReader;  
    4. import java.io.PrintWriter;  
    5. import java.io.StringWriter;  
    6.   
    7. import org.apache.log4j.Logger;  
    8.   
    9. /** 
    10.  * 采集内存使用率 
    11.  */  
    12. public class MemUsage extends ResourceUsage{  
    13.   
    14.     private static Logger log = Logger.getLogger(MemUsage.class);  
    15.     private static MemUsage INSTANCE = new MemUsage();  
    16.       
    17.     private MemUsage(){  
    18.       
    19.     }  
    20.       
    21.     public static MemUsage getInstance(){  
    22.         return INSTANCE;  
    23.     }  
    24.       
    25.     /** 
    26.      * Purpose:采集内存使用率 
    27.      * @param args 
    28.      * @return float,内存使用率,小于1 
    29.      */  
    30.     @Override  
    31.     public float get() {  
    32.         log.info(”开始收集memory使用率”);  
    33.         float memUsage = 0.0f;  
    34.         Process pro = null;  
    35.         Runtime r = Runtime.getRuntime();  
    36.         try {  
    37.             String command = ”cat /proc/meminfo”;  
    38.             pro = r.exec(command);  
    39.             BufferedReader in = new BufferedReader(new InputStreamReader(pro.getInputStream()));  
    40.             String line = null;  
    41.             int count = 0;  
    42.             long totalMem = 0, freeMem = 0;  
    43.             while((line=in.readLine()) != null){      
    44.                 log.info(line);   
    45.                 String[] memInfo = line.split(”\\s+”);  
    46.                 if(memInfo[0].startsWith(“MemTotal”)){  
    47.                     totalMem = Long.parseLong(memInfo[1]);  
    48.                 }  
    49.                 if(memInfo[0].startsWith(“MemFree”)){  
    50.                     freeMem = Long.parseLong(memInfo[1]);  
    51.                 }  
    52.                 memUsage = 1- (float)freeMem/(float)totalMem;  
    53.                 log.info(”本节点内存使用率为: ” + memUsage);   
    54.                 if(++count == 2){  
    55.                     break;  
    56.                 }                 
    57.             }  
    58.             in.close();  
    59.             pro.destroy();  
    60.         } catch (IOException e) {  
    61.             StringWriter sw = new StringWriter();  
    62.             e.printStackTrace(new PrintWriter(sw));  
    63.             log.error(”MemUsage发生InstantiationException. ” + e.getMessage());  
    64.             log.error(sw.toString());  
    65.         }     
    66.         return memUsage;  
    67.     }  
    68.       
    69.     /** 
    70.      * @param args 
    71.      * @throws InterruptedException  
    72.      */  
    73.     public static void main(String[] args) throws InterruptedException {  
    74.         while(true){  
    75.             System.out.println(MemUsage.getInstance().get());  
    76.             Thread.sleep(5000);  
    77.         }  
    78.     }  
    79. }</span>  
    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);
            }
        }
    }


    三、磁盘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。 

    代码:
    1. <span style=“font-size:14px;”>import java.io.BufferedReader;  
    2. import java.io.IOException;  
    3. import java.io.InputStreamReader;  
    4. import java.io.PrintWriter;  
    5. import java.io.StringWriter;  
    6.   
    7. import org.apache.log4j.Logger;  
    8.   
    9. /** 
    10.  * 采集磁盘IO使用率 
    11.  */  
    12. public class IoUsage extends ResourceUsage{  
    13.   
    14.     private static Logger log = Logger.getLogger(IoUsage.class);  
    15.     private static IoUsage INSTANCE = new IoUsage();  
    16.       
    17.     private IoUsage(){  
    18.       
    19.     }  
    20.       
    21.     public static IoUsage getInstance(){  
    22.         return INSTANCE;  
    23.     }  
    24.       
    25.     /** 
    26.      * @Purpose:采集磁盘IO使用率 
    27.      * @param args 
    28.      * @return float,磁盘IO使用率,小于1 
    29.      */  
    30.     @Override  
    31.     public float get() {  
    32.         log.info(”开始收集磁盘IO使用率”);  
    33.         float ioUsage = 0.0f;  
    34.         Process pro = null;  
    35.         Runtime r = Runtime.getRuntime();  
    36.         try {  
    37.             String command = ”iostat -d -x”;  
    38.             pro = r.exec(command);  
    39.             BufferedReader in = new BufferedReader(new InputStreamReader(pro.getInputStream()));  
    40.             String line = null;  
    41.             int count =  0;  
    42.             while((line=in.readLine()) != null){          
    43.                 if(++count >= 4){  
    44. //                  log.info(line);  
    45.                     String[] temp = line.split(”\\s+”);  
    46.                     if(temp.length > 1){  
    47.                         float util =  Float.parseFloat(temp[temp.length-1]);  
    48.                         ioUsage = (ioUsage>util)?ioUsage:util;  
    49.                     }  
    50.                 }  
    51.             }  
    52.             if(ioUsage > 0){  
    53.                 log.info(”本节点磁盘IO使用率为: ” + ioUsage);      
    54.                 ioUsage /= 100;   
    55.             }             
    56.             in.close();  
    57.             pro.destroy();  
    58.         } catch (IOException e) {  
    59.             StringWriter sw = new StringWriter();  
    60.             e.printStackTrace(new PrintWriter(sw));  
    61.             log.error(”IoUsage发生InstantiationException. ” + e.getMessage());  
    62.             log.error(sw.toString());  
    63.         }     
    64.         return ioUsage;  
    65.     }  
    66.   
    67.     /** 
    68.      * @param args 
    69.      * @throws InterruptedException  
    70.      */  
    71.     public static void main(String[] args) throws InterruptedException {  
    72.         while(true){  
    73.             System.out.println(IoUsage.getInstance().get());  
    74.             Thread.sleep(5000);  
    75.         }  
    76.     }  
    77.   
    78. }</span>  
    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);
            }
        }
    
    }




    四、网络带宽


    从/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数的变化,即可获得网口传输速率,再除以网口的带宽就得到带宽的使用率

    代码:
    1. <span style=“font-size:14px;”>import java.io.BufferedReader;  
    2. import java.io.IOException;  
    3. import java.io.InputStreamReader;  
    4. import java.io.PrintWriter;  
    5. import java.io.StringWriter;  
    6.   
    7. import org.apache.log4j.Logger;  
    8.   
    9. /** 
    10.  * 采集网络带宽使用率 
    11.  */  
    12. public class NetUsage extends ResourceUsage {  
    13.   
    14.     private static Logger log = Logger.getLogger(NetUsage.class);  
    15.     private static NetUsage INSTANCE = new NetUsage();  
    16.     private final static float TotalBandwidth = 1000;   //网口带宽,Mbps  
    17.       
    18.     private NetUsage(){  
    19.       
    20.     }  
    21.       
    22.     public static NetUsage getInstance(){  
    23.         return INSTANCE;  
    24.     }  
    25.       
    26.     /** 
    27.      * @Purpose:采集网络带宽使用率 
    28.      * @param args 
    29.      * @return float,网络带宽使用率,小于1 
    30.      */  
    31.     @Override  
    32.     public float get() {  
    33.         log.info(”开始收集网络带宽使用率”);  
    34.         float netUsage = 0.0f;  
    35.         Process pro1,pro2;  
    36.         Runtime r = Runtime.getRuntime();  
    37.         try {  
    38.             String command = ”cat /proc/net/dev”;  
    39.             //第一次采集流量数据  
    40.             long startTime = System.currentTimeMillis();  
    41.             pro1 = r.exec(command);  
    42.             BufferedReader in1 = new BufferedReader(new InputStreamReader(pro1.getInputStream()));  
    43.             String line = null;  
    44.             long inSize1 = 0, outSize1 = 0;  
    45.             while((line=in1.readLine()) != null){     
    46.                 line = line.trim();  
    47.                 if(line.startsWith(“eth0”)){  
    48.                     log.info(line);  
    49.                     String[] temp = line.split(”\\s+”);   
    50.                     inSize1 = Long.parseLong(temp[0].substring(5)); //Receive bytes,单位为Byte  
    51.                     outSize1 = Long.parseLong(temp[8]);             //Transmit bytes,单位为Byte  
    52.                     break;  
    53.                 }                 
    54.             }     
    55.             in1.close();  
    56.             pro1.destroy();  
    57.             try {  
    58.                 Thread.sleep(1000);  
    59.             } catch (InterruptedException e) {  
    60.                 StringWriter sw = new StringWriter();  
    61.                 e.printStackTrace(new PrintWriter(sw));  
    62.                 log.error(”NetUsage休眠时发生InterruptedException. ” + e.getMessage());  
    63.                 log.error(sw.toString());  
    64.             }  
    65.             //第二次采集流量数据  
    66.             long endTime = System.currentTimeMillis();  
    67.             pro2 = r.exec(command);  
    68.             BufferedReader in2 = new BufferedReader(new InputStreamReader(pro2.getInputStream()));  
    69.             long inSize2 = 0 ,outSize2 = 0;  
    70.             while((line=in2.readLine()) != null){     
    71.                 line = line.trim();  
    72.                 if(line.startsWith(“eth0”)){  
    73.                     log.info(line);  
    74.                     String[] temp = line.split(”\\s+”);   
    75.                     inSize2 = Long.parseLong(temp[0].substring(5));  
    76.                     outSize2 = Long.parseLong(temp[8]);  
    77.                     break;  
    78.                 }                 
    79.             }  
    80.             if(inSize1 != 0 && outSize1 !=0 && inSize2 != 0 && outSize2 !=0){  
    81.                 float interval = (float)(endTime - startTime)/1000;  
    82.                 //网口传输速度,单位为bps  
    83.                 float curRate = (float)(inSize2 - inSize1 + outSize2 - outSize1)*8/(1000000*interval);  
    84.                 netUsage = curRate/TotalBandwidth;  
    85.                 log.info(”本节点网口速度为: ” + curRate + “Mbps”);  
    86.                 log.info(”本节点网络带宽使用率为: ” + netUsage);  
    87.             }                 
    88.             in2.close();  
    89.             pro2.destroy();  
    90.         } catch (IOException e) {  
    91.             StringWriter sw = new StringWriter();  
    92.             e.printStackTrace(new PrintWriter(sw));  
    93.             log.error(”NetUsage发生InstantiationException. ” + e.getMessage());  
    94.             log.error(sw.toString());  
    95.         }     
    96.         return netUsage;  
    97.     }  
    98.   
    99.     /** 
    100.      * @param args 
    101.      * @throws InterruptedException  
    102.      */  
    103.     public static void main(String[] args) throws InterruptedException {  
    104.         while(true){  
    105.             System.out.println(NetUsage.getInstance().get());  
    106.             Thread.sleep(5000);  
    107.         }  
    108.     }  
    109. }</span>  
    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);
            }
        }
    }

    展开全文
  • java监控linux服务器CPU,内存等信息

    千次阅读 2017-07-18 14:51:56
    最近公司在做爬虫系统,我接到一个需求是获取服务器CPU,内存等信息。一开始我打算通过linux shell获取然后输出到文件,java读取文件获得。后来回想一切皆文件的linux应该本来就有记录在文件中,经过查找资料,找到了...

    最近公司在做爬虫系统,我接到一个需求是获取服务器CPU,内存等信息。一开始我打算通过linux shell获取然后输出到文件,java读取文件获得。后来回想一切皆文件的linux应该本来就有记录在文件中,经过查找资料,找到了解决方法。
    资料参考:http://www.jb51.net/article/75002.htm

    * 取得linux系统下的cpu、内存信息  
    *  
    * */  
    public  final  class LinuxSystemTool  
    {  
    /**  
    * 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  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));  
    }  
    }  

    同理:要获取LINUX的CPU温度(如果文件存在):

    InputStreamReader(new FileInputStream(new File("/proc/acpi/thermal_zone/THM/temperature"))
    展开全文
  • 思路:java执行脚本,拿到返回值,读取返回值,再对返回值进行分析获取想要的值。 传统的jdk查询系统信息不适用,要么是误差大,要么是难以实现。 //代码运行到linux上 //获取 disk使用情况 单位Byte public static ...

    思路:java执行脚本,拿到返回值,读取返回值,再对返回值进行分析获取想要的值。

    传统的jdk查询系统信息不适用,要么是误差大,要么是难以实现。

    //代码运行到linux上

    //获取 disk使用情况 单位Byte
    public static Map<String, Object> getDiskStatus() {
    Map<String, Object> diskMap = new LinkedHashMap<>();
    long total = 0;
    try {
    //java执行脚本
    Runtime rt = Runtime.getRuntime();
    Process p = rt.exec(“df -k”);
    BufferedReader in = null;
    try {
    in = new BufferedReader(new InputStreamReader(p.getInputStream()));
    String str = null;
    String[] strArray = null;
    int line = 0;
    // 一行行读
    while ((str = in.readLine()) != null) {
    line++;
    // 跳过第一行
    if (line == 1) {
    continue;
    }
    int m = 0;
    // 一行以空格分开
    strArray = str.split(" ");
    // 行的遍历
    for (String para : strArray) {
    // 去掉空格的长度==0表示该位置为空
    if (para.trim().length() == 0) {
    continue;
    }

                        ++m;
                        // 第2列
                        if (m == 2) {
                            Long dataCap = Long.valueOf(para) * 1024;
                            total += dataCap;
                            String mounted = strArray[strArray.length - 1];
                            if ("/data".equals(mounted)) {
                                // 数据分区大小
                                diskMap.put("disk_data", dataCap);
                            }
                        }
    
                        if (m == 5) {
                            // 如果该字符串以%
                            if (para.endsWith("%")) {
                                String mounted = strArray[strArray.length - 1];
                                if ("/data".equals(mounted)) {
                                    // 去掉%
                                    String s = para.replace("%", "");
                                    Float percent = Float.valueOf(s);
                                    // 数据分区已使用率
                                    diskMap.put("percent", percent);
                                }
                            }
                        }
                    }
                }
                diskMap.put("total", Long.valueOf(objectFormat(total)));
            } catch (Exception e) {
                LOG.error(e.getMessage());
            } finally {
                in.close();
            }
        } catch (Exception e) {
            LOG.error(e.getMessage());
        }
        return diskMap;
    }
    

    //查询内存占比
    public static Map<String, Float> getMemeryStatus() {
    Map<String, Float> map = new HashMap(10);
    // 从bit转成gb
    float constm = 1024 * 1024 * 1024;
    // 已使用的内存大小
    float usedPhysicalMemorySize = Float.parseFloat(objectFormat(getUsedPhysicalMemorySize() / constm));
    // 总共的内存大小
    float totalPhysicalMemorySize = Float.parseFloat(objectFormat(getTotalPhysicalMemorySize() / constm));
    float percent = Float.parseFloat(objectFormat((usedPhysicalMemorySize / totalPhysicalMemorySize * 100)));
    map.put(“total”, totalPhysicalMemorySize);
    map.put(“use”, usedPhysicalMemorySize);
    map.put(“percent”, percent);
    return map;
    }

    //查询cpu
    public static float getCpuPercent() throws IOException, BashException {
    Runtime runtime = Runtime.getRuntime();
    // 执行top命令,top是动态的,我们只要一次结果
    Process top = runtime.exec(“top -b -n 1”);
    BufferedReader buf = new BufferedReader(new InputStreamReader(top.getInputStream()));
    String str = “”;
    float percent = 0;
    int line = 0;
    // 一行一行读
    while ((str = buf.readLine()) != null) {
    // 跳过第一和第二行
    line++;
    if (line == 1 || line == 2) {
    continue;
    }
    // 切割
    String[] split = str.split(" ");
    int length = split.length;
    percent = Float.parseFloat(split[length - 2]);
    break;
    }
    return percent;
    }

    展开全文
  • //每分钟获取一次服务器CPU、内存使用率(获取30次) for (int i = 0; i ; i++) { String[] data= {ZgxDateUtil.getNowDate("yyyy-MM-dd HH:mm:ss") , String.valueOf(getCpuRate(logAuto)) , String.valueOf...
  • //每分钟获取一次服务器CPU、内存使用率(获取30次) for (int i = 0; i ; i++) { String[] data = {ZgxDateUtil.getNowDate("yyyy-MM-dd HH:mm:ss") , String.valueOf(getCpuRate(logAuto)) , String.valueOf...
  • 代码参考了很多博客,这里就不一一贴出原链接了,感谢!...1.获取cpu使用率: import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.PrintWriter...
  • import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.text.DecimalFormat; import java.util.ArrayList; import java.
  • java获取linux虚拟机的硬件信息–cpu信息、服务器名称、操作系统、ip地址等】 工作中遇到的接口 工具类:SSHToolUtil package com.ph.server.myserver.util; import ch.ethz.ssh2.Connection; import ch.ethz....
  • 1.top命令找到cpu占用最高的进程号 2.top -Hp 5363命令找到cpu...3.获取5363的16进制红框部分14f3:printf %x 5375 4.进入java的bin目录下执行命令: jstack 5363(进程号) |grep -A 200 1ad8(线程号16进制) ...
  • A.java进程---大致流程是找出进程的pid-找到进程下占用资源最大的线程-用jstack打印出进程快照linux:1.top -c找到占用cpu较高的进程,获取到[pid]2.top -Hp [pid],查看该进程对应的线程,找到线程中占用cpu较高的...
  • 1.jps 获取Java进程的PID。 2.jstack pid >> java.txt 导出CPU占用高进程的线程栈。 3.top -H -p PID 查看对应进程的哪个线程占用CPU过高。 4.echo “obase=16; PID” | bc 将线程的P...
  • 正在研究java实现远程监控linux服务器内存,cup,硬盘等信息,或者在远程服务器中部署采集程序,采集内存,CPU,硬盘信。搜集了一些思路正在整理测试中,有经验的朋友可以留言分享经验。 第一种方法 采用java实现...
  • 项目背景:java后端项目,线上Linux 环境,容器部署。问题描述:收到大量ERROR报警,用户反馈服务器响应部分接口变慢。排查过程:先看了下日志,一通排查后,发现一台容器日志各种异常,连接超时,zk超时,rmq超时等...
  • linux服务器监控代码

    2019-12-13 17:30:45
    获取linux服务器内存,cpu,硬盘等信息java代码,sigar实现!
  • top的使用方法top命令主要用于分析Linux服务器当前的实时CPU和内存消耗情况,以及进程的运行情况统计。命令使用:top ,具体top命令的使用方法和以下截图的各个信息的含义,可通过man top命令来查看。其中比较常用的...
  • 笔者今天将新开发的项目部署到新服务器的时候,出现了个“奇怪”的现象。项目启动完毕后,一切正常。...①top查看cpu情况,获取cpu爆表的进程id(pid)②top -H -p 8413 查看导致cpu爆表的线程id(pi...
  • 服务器内存飙升或者cpu负载飙升的时候,可以使用如下步骤排查问题:1、终端输入top命令,键盘大写的情况下按P(cpu负载率从高到低排序)或者M(内存使用率从高到低排序),可以查看导致cpu或者内存飙升的java pid。...
  • 服务器内存飙升或者cpu负载飙升的时候,可以使用如下步骤排查问题: 1、终端输入top命令,键盘大写的情况下按P(cpu负载率从高到低排序)或者M(内存使用率从高到低排序),可以查看导致cpu或者内存飙升的java pid...
  • 笔者今天将新开发的项目部署到新服务器的时候,出现了个“奇怪”的现象。项目启动完毕后,一切正常。在运行其中一个项目的时候,突然出现卡格...①top查看cpu情况,获取cpu爆表的进程id(pid) ②top -H -p 8413 查
  • mcat-siger.sh 查看是否安装siger ...java使用siger 获取服务器硬件信息(CPU 内存 网络 io等) 通过使用第三方开源jar包sigar.jar我们可以获得本地的信息   1.下载sigar.jar sigar官方主页 sigar...
  • libsigar-x86-linux.so sigar-amd64-winnt.dll OSUtil.java public static void main(String[] args) { try { // System信息,从jvm获取 property(); System.out.println("----------------------------------...
  • tomcat在linux服务器中启动特别慢的解决办法 转载 自由早晚乱余生 1. tomcat 启动慢 在线上环境中,我们经常会遇到类似的问题,就是tomcat 启动比较慢,查看内存和cpu,io都是正常的,但是启动很慢,有的时候长达几...
  • 一、java定位进程在服务器中终端输入命令:top可以看到进程ID,为5421的cpu这列100多了。记下这个数字:5421二、定位问题进程对应的线程然后在服务器中终端输入命令:top -Hp 5421作用是查看里程内部线程资源占用...
  • 5421为第二步获取到的进程id 可以看到第一行cpu占用特别高,就是它了。记住,此时第一列PID是线程ID:5463 注意这个ID是十进制,但是java线程堆栈是采用是16进制。那么我们转换一下。 printf "%x\...

空空如也

空空如也

1 2 3 4
收藏数 63
精华内容 25
关键字:

java获取linux服务器cpu

java 订阅
linux 订阅