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
3. import
4. import
5. import
6. import
7. import
8.
9. /**
10.
11.
12. * 取得linux系统下的cpu、内存信息
13. *
14. * */
15. public final class
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
26. {
27. new File("/proc/meminfo");
28. new BufferedReader(new
29. new
30. int[] result = new int[4];
31. null;
32. null;
33. while((str = br.readLine()) != null)
34. {
35. new
36. if(!token.hasMoreTokens())
37. continue;
38.
39. str = token.nextToken();
40. if(!token.hasMoreTokens())
41. continue;
42.
43. if(str.equalsIgnoreCase("MemTotal:"))
44. 0] = Integer.parseInt(token.nextToken());
45. else if(str.equalsIgnoreCase("MemFree:"))
46. 1] = Integer.parseInt(token.nextToken());
47. else if(str.equalsIgnoreCase("SwapTotal:"))
48. 2] = Integer.parseInt(token.nextToken());
49. else if(str.equalsIgnoreCase("SwapFree:"))
50. 3] = Integer.parseInt(token.nextToken());
51. }
52.
53. return
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
64. {
65. new File("/proc/stat");
66. new BufferedReader(new
67. new
68. new
69. token.nextToken();
70. int
71. int
72. int
73. int
74.
75. 1000);
76.
77. new
78. new InputStreamReader(new
79. new
80. token.nextToken();
81. int
82. int
83. int
84. int
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
97. {
98. public static void main(String[] args) throws
99. {
100. int[] memInfo = LinuxSystemTool.getMemInfo();
101. "MemTotal：" + memInfo[0]);
102. "MemFree：" + memInfo[1]);
103. "SwapTotal：" + memInfo[2]);
104. "SwapFree：" + memInfo[3]);
105.
106. "CPU利用率："
107. }
108. }
109.
110. import
111. import
112. import
113. import
114. import
115. import
116.
117. /**
118.
119.
120. * 取得linux系统下的cpu、内存信息
121. *
122. * */
123. public final class
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
134. {
135. new File("/proc/meminfo");
136. new BufferedReader(new
137. new
138. int[] result = new int[4];
139. null;
140. null;
141. while((str = br.readLine()) != null)
142. {
143. new
144. if(!token.hasMoreTokens())
145. continue;
146.
147. str = token.nextToken();
148. if(!token.hasMoreTokens())
149. continue;
150.
151. if(str.equalsIgnoreCase("MemTotal:"))
152. 0] = Integer.parseInt(token.nextToken());
153. else if(str.equalsIgnoreCase("MemFree:"))
154. 1] = Integer.parseInt(token.nextToken());
155. else if(str.equalsIgnoreCase("SwapTotal:"))
156. 2] = Integer.parseInt(token.nextToken());
157. else if(str.equalsIgnoreCase("SwapFree:"))
158. 3] = Integer.parseInt(token.nextToken());
159. }
160.
161. return
162. }
163.
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
172. {
173. new File("/proc/stat");
174. new BufferedReader(new
175. new
176. new
177. token.nextToken();
178. int
179. int
180. int
181. int
182.
183. 1000);
184.
185. new
186. new InputStreamReader(new
187. new
188. token.nextToken();
189. int
190. int
191. int
192. int
193.
194. return (float)((user2 + sys2 + nice2) - (user1 + sys1 + nice1)) / (float)((user2 + nice2 + sys2 + idle2) - (user1 + nice1 + sys1 + idle1));
195. }
196. }
197.
198. /**
199. * 测试类
200. *
201. * <p>@author javer QQ:84831612</p>
202. * @date 2005
203. */
204. public class
205. {
206. public static void main(String[] args) throws
207. {
208. int[] memInfo = LinuxSystemTool.getMemInfo();
209. "MemTotal：" + memInfo[0]);
210. "MemFree：" + memInfo[1]);
211. "SwapTotal：" + memInfo[2]);
212. "SwapFree：" + memInfo[3]);
213.
214. "CPU利用率："
215. }
216. }
