java 获得CPU 内存信息

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

 

 

1. Java代码 
2. import java.io.BufferedReader;   
3. import java.io.File;   
4. import java.io.FileInputStream;   
5. import java.io.IOException;   
6. import java.io.InputStreamReader;   
7. import java.util.StringTokenizer;   
8.   
9. /**  
12. * 取得linux系统下的cpu、内存信息  
13. *   
14. * */  
15. public final class LinuxSystemTool   
16. {   
17.    /**  
18.    * get memory by used info  
19.    *   
20.    * @return int[] result  
21.    * result.length==4;int[0]=MemTotal;int[1]=MemFree;int[2]=SwapTotal;int[3]=SwapFree;  
22.    * @throws IOException  
23.    * @throws InterruptedException  
24.    */  
25.    public static int[] getMemInfo() throws IOException, InterruptedException   
26.    {   
27.       File file = new File("/proc/meminfo");   
28.       BufferedReader br = new BufferedReader(new InputStreamReader(   
29.       new FileInputStream(file)));   
30.       int[] result = new int[4];   
31.       String str = null;   
32.       StringTokenizer token = null;   
33.       while((str = br.readLine()) != null)   
34.       {   
35.          token = new StringTokenizer(str);   
36.          if(!token.hasMoreTokens())   
37.             continue;   
38.       
39.          str = token.nextToken();   
40.          if(!token.hasMoreTokens())   
41.             continue;   
42.       
43.          if(str.equalsIgnoreCase("MemTotal:"))   
44.             result[0] = Integer.parseInt(token.nextToken());   
45.          else if(str.equalsIgnoreCase("MemFree:"))   
46.             result[1] = Integer.parseInt(token.nextToken());   
47.          else if(str.equalsIgnoreCase("SwapTotal:"))   
48.             result[2] = Integer.parseInt(token.nextToken());   
49.          else if(str.equalsIgnoreCase("SwapFree:"))   
50.             result[3] = Integer.parseInt(token.nextToken());   
51.       }   
52.       
53.       return result;   
54.    }   
55.   
56.    /**  
57.    * get memory by used info  
58.    *   
59.    * @return float efficiency  
60.    * @throws IOException  
61.    * @throws InterruptedException  
62.    */  
63.    public static float getCpuInfo() throws IOException, InterruptedException   
64.    {   
65.       File file = new File("/proc/stat");   
66.       BufferedReader br = new BufferedReader(new InputStreamReader(   
67.       new FileInputStream(file)));   
68.       StringTokenizer token = new StringTokenizer(br.readLine());   
69.       token.nextToken();   
70.       int user1 = Integer.parseInt(token.nextToken());   
71.       int nice1 = Integer.parseInt(token.nextToken());   
72.       int sys1 = Integer.parseInt(token.nextToken());   
73.       int idle1 = Integer.parseInt(token.nextToken());   
74.       
75.       Thread.sleep(1000);   
76.   
77.       br = new BufferedReader(   
78.       new InputStreamReader(new FileInputStream(file)));   
79.       token = new StringTokenizer(br.readLine());   
80.       token.nextToken();   
81.       int user2 = Integer.parseInt(token.nextToken());   
82.       int nice2 = Integer.parseInt(token.nextToken());   
83.       int sys2 = Integer.parseInt(token.nextToken());   
84.       int idle2 = Integer.parseInt(token.nextToken());   
85.   
86.       return (float)((user2 + sys2 + nice2) - (user1 + sys1 + nice1)) / (float)((user2 + nice2 + sys2 + idle2) - (user1 + nice1 + sys1 + idle1));   
87.    }   
88. }   
89.   
90. /**  
91. * 测试类  
92. *   
93. * <p>@author javer QQ:84831612</p>  
94. * @date 2005  
95. */  
96. public class JaverTest   
97. {   
98.     public static void main(String[] args) throws Exception   
99.     {   
100.         int[] memInfo = LinuxSystemTool.getMemInfo();   
101.         System.out.println("MemTotal：" + memInfo[0]);   
102.         System.out.println("MemFree：" + memInfo[1]);   
103.         System.out.println("SwapTotal：" + memInfo[2]);   
104.         System.out.println("SwapFree：" + memInfo[3]);   
105.   
106.         System.out.println("CPU利用率：" + LinuxSystemTool.getCpuInfo());   
107.     }   
108. }  
110. import java.io.BufferedReader; 
111. import java.io.File; 
112. import java.io.FileInputStream; 
113. import java.io.IOException; 
114. import java.io.InputStreamReader; 
115. import java.util.StringTokenizer; 
117. /** 
120. * 取得linux系统下的cpu、内存信息 
121. * 
122. * */ 
123. public final class LinuxSystemTool 
124. { 
125.    /** 
126.    * get memory by used info 
127.    * 
128.    * @return int[] result 
129.    * result.length==4;int[0]=MemTotal;int[1]=MemFree;int[2]=SwapTotal;int[3]=SwapFree; 
130.    * @throws IOException 
131.    * @throws InterruptedException 
132.    */ 
133.    public static int[] getMemInfo() throws IOException, InterruptedException 
134.    { 
135.       File file = new File("/proc/meminfo"); 
136.       BufferedReader br = new BufferedReader(new InputStreamReader( 
137.       new FileInputStream(file))); 
138.       int[] result = new int[4]; 
139.       String str = null; 
140.       StringTokenizer token = null; 
141.       while((str = br.readLine()) != null) 
142.       { 
143.          token = new StringTokenizer(str); 
144.          if(!token.hasMoreTokens()) 
145.             continue; 
146.    
147.          str = token.nextToken(); 
148.          if(!token.hasMoreTokens()) 
149.             continue; 
150.    
151.          if(str.equalsIgnoreCase("MemTotal:")) 
152.             result[0] = Integer.parseInt(token.nextToken()); 
153.          else if(str.equalsIgnoreCase("MemFree:")) 
154.             result[1] = Integer.parseInt(token.nextToken()); 
155.          else if(str.equalsIgnoreCase("SwapTotal:")) 
156.             result[2] = Integer.parseInt(token.nextToken()); 
157.          else if(str.equalsIgnoreCase("SwapFree:")) 
158.             result[3] = Integer.parseInt(token.nextToken()); 
159.       } 
160.    
161.       return result; 
162.    } 
164.    /** 
165.    * get memory by used info 
166.    * 
167.    * @return float efficiency 
168.    * @throws IOException 
169.    * @throws InterruptedException 
170.    */ 
171.    public static float getCpuInfo() throws IOException, InterruptedException 
172.    { 
173.       File file = new File("/proc/stat"); 
174.       BufferedReader br = new BufferedReader(new InputStreamReader( 
175.       new FileInputStream(file))); 
176.       StringTokenizer token = new StringTokenizer(br.readLine()); 
177.       token.nextToken(); 
178.       int user1 = Integer.parseInt(token.nextToken()); 
179.       int nice1 = Integer.parseInt(token.nextToken()); 
180.       int sys1 = Integer.parseInt(token.nextToken()); 
181.       int idle1 = Integer.parseInt(token.nextToken()); 
182.    
183.       Thread.sleep(1000); 
185.       br = new BufferedReader( 
186.       new InputStreamReader(new FileInputStream(file))); 
187.       token = new StringTokenizer(br.readLine()); 
188.       token.nextToken(); 
189.       int user2 = Integer.parseInt(token.nextToken()); 
190.       int nice2 = Integer.parseInt(token.nextToken()); 
191.       int sys2 = Integer.parseInt(token.nextToken()); 
192.       int idle2 = Integer.parseInt(token.nextToken()); 
194.       return (float)((user2 + sys2 + nice2) - (user1 + sys1 + nice1)) / (float)((user2 + nice2 + sys2 + idle2) - (user1 + nice1 + sys1 + idle1)); 
195.    } 
196. } 
198. /** 
199. * 测试类 
200. * 
201. * <p>@author javer QQ:84831612</p> 
202. * @date 2005 
203. */ 
204. public class JaverTest 
205. { 
206.     public static void main(String[] args) throws Exception 
207.     { 
208.         int[] memInfo = LinuxSystemTool.getMemInfo(); 
209.         System.out.println("MemTotal：" + memInfo[0]); 
210.         System.out.println("MemFree：" + memInfo[1]); 
211.         System.out.println("SwapTotal：" + memInfo[2]); 
212.         System.out.println("SwapFree：" + memInfo[3]); 
214.         System.out.println("CPU利用率：" + LinuxSystemTool.getCpuInfo()); 
215.     } 
216. }