用java取得linux系统cpu、内存的实时信息

  1. import java.io.BufferedReader;   
  2. import java.io.File;   
  3. import java.io.FileInputStream;   
  4. import java.io.IOException;   
  5. import java.io.InputStreamReader;   
  6. import java.net.InetAddress;   
  7. import java.util.StringTokenizer;   
  8.   
  9. import org.apache.log4j.Logger;   
  10.   
  11. /**  
  12.  * 取得linux系统下的cpu、内存信息  
  13.  *   
  14.  * 

     

  15.  *   
  16.  * @author leo  
  17.  *         

     
  18.  * @date 2008  
  19.  */  
  20. public final class LinuxSystemTool implements Runnable{   
  21.     private Logger log = Logger.getLogger(LinuxSystemTool.class);   
  22.     private Config config=Config.getInstance();   
  23.     /**  
  24.      * get memory by used info  
  25.      *   
  26.      * @return int[] result  
  27.      *         result.length==4;int[0]=MemTotal;int[1]=MemFree;int[2]=SwapTotal;int[3]=SwapFree;  
  28.      * @throws IOException  
  29.      * @throws InterruptedException  
  30.      */  
  31.     public void run() {   
  32.         // TODO Auto-generated method stub   
  33.   
  34.         while (true) {   
  35.                
  36.             try {   
  37.                 exec();   
  38.                 Thread.sleep(config.getThreadTime());   
  39.             } catch (Exception e) {   
  40.                 // TODO Auto-generated catch block   
  41.                 log.error("Performance Monitoring error:"+e.getMessage());   
  42.                 e.printStackTrace();   
  43.             }   
  44.         }   
  45.     }   
  46.     public void exec() throws Exception {   
  47. //      ServerStatus ss = new ServerStatus();   
  48.   
  49.         InetAddress inet = InetAddress.getLocalHost();   
  50.         System.out.println("Performance Monitoring ip:"+inet.toString());   
  51.            
  52.         String ip=inet.toString().substring(inet.toString().indexOf("/")+1);   
  53.         log.info("Performance Monitoring ip:"+ip);   
  54.            
  55.         int[] memInfo = LinuxSystemTool.getMemInfo();   
  56.         System.out.println("MemTotal:" + memInfo[0]);   
  57.         System.out.println("MemFree:" + memInfo[1]);   
  58.            
  59.         SnmpUtil util=new SnmpUtil();   
  60.         util.setCPU(getCpuInfo());   
  61. //      util.setDISK(1);   
  62.         util.setMEM(memInfo[0]/memInfo[1]);   
  63.         util.setIP(ip);   
  64.   
  65.     }   
  66.     public static int[] getMemInfo() throws IOException, InterruptedException {   
  67.         File file = new File("/proc/meminfo");   
  68.         BufferedReader br = new BufferedReader(new InputStreamReader(   
  69.                 new FileInputStream(file)));   
  70.         int[] result = new int[4];   
  71.         String str = null;   
  72.         StringTokenizer token = null;   
  73.         while ((str = br.readLine()) != null) {   
  74.             token = new StringTokenizer(str);   
  75.             if (!token.hasMoreTokens())   
  76.                 continue;   
  77.   
  78.             str = token.nextToken();   
  79.             if (!token.hasMoreTokens())   
  80.                 continue;   
  81.   
  82.             if (str.equalsIgnoreCase("MemTotal:"))   
  83.                 result[0] = Integer.parseInt(token.nextToken());   
  84.             else if (str.equalsIgnoreCase("MemFree:"))   
  85.                 result[1] = Integer.parseInt(token.nextToken());   
  86.             else if (str.equalsIgnoreCase("SwapTotal:"))   
  87.                 result[2] = Integer.parseInt(token.nextToken());   
  88.             else if (str.equalsIgnoreCase("SwapFree:"))   
  89.                 result[3] = Integer.parseInt(token.nextToken());   
  90.         }   
  91.   
  92.         return result;   
  93.     }   
  94.   
  95.     /**  
  96.      * get memory by used info  
  97.      *   
  98.      * @return float efficiency  
  99.      * @throws IOException  
  100.      * @throws InterruptedException  
  101.      */  
  102.     public static float getCpuInfo() throws IOException, InterruptedException {   
  103.         File file = new File("/proc/stat");   
  104.         BufferedReader br = new BufferedReader(new InputStreamReader(   
  105.                 new FileInputStream(file)));   
  106.         StringTokenizer token = new StringTokenizer(br.readLine());   
  107.         token.nextToken();   
  108.         int user1 = Integer.parseInt(token.nextToken());   
  109.         int nice1 = Integer.parseInt(token.nextToken());   
  110.         int sys1 = Integer.parseInt(token.nextToken());   
  111.         int idle1 = Integer.parseInt(token.nextToken());   
  112.   
  113.         Thread.sleep(1000);   
  114.   
  115.         br = new BufferedReader(   
  116.                 new InputStreamReader(new FileInputStream(file)));   
  117.         token = new StringTokenizer(br.readLine());   
  118.         token.nextToken();   
  119.         int user2 = Integer.parseInt(token.nextToken());   
  120.         int nice2 = Integer.parseInt(token.nextToken());   
  121.         int sys2 = Integer.parseInt(token.nextToken());   
  122.         int idle2 = Integer.parseInt(token.nextToken());   
  123.   
  124.         return (float) ((user2 + sys2 + nice2) - (user1 + sys1 + nice1))   
  125.                 / (float) ((user2 + nice2 + sys2 + idle2) - (user1 + nice1   
  126.                         + sys1 + idle1));   
  127.     }   
  128.   
  129.     /**  
  130.      * 测试类  
  131.      *   
  132.      * 

     

  133.      *   
  134.      * @author  
  135.      * 

     
  136.      * @date  
  137.      */  
  138.   
  139.     public static void main(String[] args) throws Exception {   
  140.         int[] memInfo = LinuxSystemTool.getMemInfo();   
  141.         System.out.println("MemTotal:" + memInfo[0]);   
  142.         System.out.println("MemFree:" + memInfo[1]);   
  143.         System.out.println("SwapTotal:" + memInfo[2]);   
  144.         System.out.println("SwapFree:" + memInfo[3]);   
  145.   
  146.         System.out.println("CPU利用率:" + LinuxSystemTool.getCpuInfo());   
  147.     }   
  148. }  
  149. CPU

     

    在文件"/proc/stat"里面就包含了CPU的信息。每一个CPU的每一tick用在什么地方都在这个文件里面记着。后面的数字含义分别是: user、nice、sys、idle、iowait。有些版本的kernel没有iowait这一项。这些数值表示从开机到现在,CPU的每tick用在了哪里。例如:

    cpu0 256279030 0 11832528 1637168262

    就是cpu0从开机到现在有 256279030 tick用在了user消耗,11832528用在了sys消耗。所以如果想计算单位时间(例如1s)里面CPU的负载,那只需要计算1秒前后数值的差除以每一秒的tick数量就可以了。gkrellm就是这样实现的:((200 * (v2 - v1) / CPU_TICKS_PER_SECOND) + 1) /2

    例如,第一次读取/proc/stat,user的值是256279030;一秒以后再读一次,值是256289030,那么CPU在这一秒的user消耗就是:((200 * (256289030 - 256279030) / CPU_TICKS_PER_SECOND) + 1) /2 = ((10000 * 200 / 1000000) + 1) / 2 = 1%了。

     

    2、内存消耗

     

    文件"/proc/meminfo"里面包含的就是内存的信息,还包括了swap的信息。例如:

     

     

    $ cat /proc/meminfo

    total:    used:    free: shared: buffers: cached:
    Mem: 1057009664 851668992 205340672        0 67616768 367820800
    Swap: 2146787328 164429824 1982357504
    MemTotal:      1032236 kB
    MemFree:        200528 kB
    MemShared:           0 kB
    ……

    不过从gkrellm的源代码看,有些版本没有前面那两行统计的信息,只能够根据下面的Key: Value这种各式的数据收集。

     

    3、磁盘空间

     

    从gkrellm的源代码看,这个是一个很复杂的数据。磁盘分区的数据有可能分布在:/proc/mounts、/proc/diskstats、 /proc/partitions等等。而且如果想要检查某几个特定的路径,还需要通过mount、df等命令的帮助。为了减少麻烦,这个数据我就直接用 statfs函数直接获得了。

     

    int statfs(const char *path, struct statfs *buf);

    这个函数只需要输入需要检查的路径名称,就可以返回这个路径所在的分区的空间使用情况:

    总空间:buf.f_bsize * buf.f_blocks

    空余空间:buf.f_bsize * buf.f_bavail

     

    4、磁盘I/O

     

    磁盘I/O的数据也同样比较复杂,有些版本看/proc/diskstats,有些版本看/proc/partitions,还有些版本至今我也不知道在那里看……不过可以看到数据的版本也像CPU那样,需要隔一段时间取值,两次取值的差就是流量。

     

    5、网络流量

     

    网络流量也是五花八门,不过基本上都可以在/proc/net/dev里面获得。同样也是需要两次取值取其差作为流量值。

你可能感兴趣的:(linux)