用java取得linux系統cpu、記憶體的即時資訊

from:http://avery-leo.javaeye.com/blog/298724

原始碼：

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;   
9. import org.apache.log4j.Logger;   
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
34. while (true) {   
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();
49.         InetAddress inet = InetAddress.getLocalHost();   
50.         System.out.println("Performance Monitoring ip:"+inet.toString());   
52.         String ip=inet.toString().substring(inet.toString().indexOf("/")+1);   
53.         log.info("Performance Monitoring ip:"+ip);   
55.         int[] memInfo = LinuxSystemTool.getMemInfo();   
56.         System.out.println("MemTotal：" + memInfo[0]);   
57.         System.out.println("MemFree：" + memInfo[1]);   
59.         SnmpUtil util=new SnmpUtil();   
60.         util.setCPU(getCpuInfo());   
61. //      util.setDISK(1);
62.         util.setMEM(memInfo[0]/memInfo[1]);   
63.         util.setIP(ip);   
65. }   
66. public static int[] getMemInfo() throws IOException, InterruptedException {   
67.         File file = new File("/proc/meminfo");   
68.         BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(file)));   
69.         int[] result = new int[4];   
70.         String str = null;   
71.         StringTokenizer token = null;   
72.         while ((str = br.readLine()) != null) {   
73.             token = new StringTokenizer(str);   
74.             if (!token.hasMoreTokens())   
75.                continue;   
77.             str = token.nextToken();   
78.             if (!token.hasMoreTokens())   
79.                continue;   
81.             if (str.equalsIgnoreCase("MemTotal:"))   
82.                 result[0] = Integer.parseInt(token.nextToken());   
83.             else if (str.equalsIgnoreCase("MemFree:"))   
84.                 result[1] = Integer.parseInt(token.nextToken());   
85.             else if (str.equalsIgnoreCase("SwapTotal:"))   
86.                 result[2] = Integer.parseInt(token.nextToken());   
87.             else if (str.equalsIgnoreCase("SwapFree:"))   
88.                 result[3] = Integer.parseInt(token.nextToken());   
89.          }   
91.          return result;   
92.     }   
94. /**
95.      * get memory by used info
96.      * 
97.      * @return float efficiency
98.      * @throws IOException
99.      * @throws InterruptedException
100.      */
101. public static float getCpuInfo() throws IOException, InterruptedException {   
102.         File file = new File("/proc/stat");   
103.         BufferedReader br = new BufferedReader(new InputStreamReader( new FileInputStream(file)));   
104.         StringTokenizer token = new StringTokenizer(br.readLine());   
105.         token.nextToken();   
106.         long user1 = Long.parseLong(token.nextToken());   
107.         long nice1 = Long.parseLong(token.nextToken());   
108.         long sys1 = Long.parseLong(token.nextToken());   
109.         long idle1 = Long.parseLong(token.nextToken());   
110.         Thread.sleep(1000);   
111.         br = new BufferedReader(new InputStreamReader(new FileInputStream(file)));   
112.         token = new StringTokenizer(br.readLine());   
113.         token.nextToken();   
114.         long user2 = Long.parseLong(token.nextToken());   
115.         long nice2 = Long.parseLong(token.nextToken());   
116.         long sys2 = Long.parseLong(token.nextToken());   
117.         long idle2 =Long.parseLong(token.nextToken());
118.         return (float) ((user2 + sys2 + nice2) - (user1 + sys1 + nice1))   
119.                 / (float) ((user2 + nice2 + sys2 + idle2) - (user1 + nice1+ sys1 + idle1));   
120.     }   
122. /**
123.      * 測試類別
124.      * 
125.      * <p>
126.      * 
127.      * @author
128.      * </p>
129.      * @date
130.      */
132. public static void main(String[] args) throws Exception {   
133.         int[] memInfo = LinuxSystemTool.getMemInfo();   
134.         System.out.println("MemTotal：" + memInfo[0]);   
135.         System.out.println("MemFree：" + memInfo[1]);   
136.         System.out.println("SwapTotal：" + memInfo[2]);   
137.         System.out.println("SwapFree：" + memInfo[3]);   
138.         System.out.println("CPU利用率：" + LinuxSystemTool.getCpuInfo());   
139.     }   
140. } 

註：原文使用int儲存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裡面獲得。同樣也是需要兩次取值取其差作為流量值。