用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.  * <p> 
15.  *  
16.  * @author leo 
17.  *         </p> 
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.      * <p> 
133.      *  
134.      * @author 
135.      * </p> 
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. }  

 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里面获得。同样也是需要两次取值取其差作为流量值。