Obtain real-time cpu and memory information in linux using java

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

Source code:

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. * Obtain cpu and memory information in linux
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. Repeated signorecase ("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. * Test class
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 usage:" + linuxsystemtool. getcpuinfo ());
139. }
140. }

Note: The original text uses int to save the CPU Count value, which is inappropriate. Conversion Value overflow may occur on servers that run for a long time.

1. CPU

The file "/proc/stat" contains CPU information. Every CPU tick is used in this file. The following numbers indicate user, nice, sys, idle, and iowait. Some versions of kernel do not include iowait. These values indicate where each tick of the CPU is used from the boot to the present. For example:

Cpu0 256279030 0 11832528 1637168262

That is, 256279030 tick is used for user consumption since CPU 0 is started, and 11832528 is used for sys consumption. So if you want to calculate the CPU load per unit time (for example, 1 s), you only need to calculate the difference between the values before and after 1 second by the number of tick per second. Gkrellm is implemented in this way: (200 * (v2-v1)/CPU_TICKS_PER_SECOND) + 1)/2

For example, if you read/proc/stat for the first time, the user value is 256279030; if you read it again after one second, the value is 256289030, the CPU user consumption in this second is: (200 * (256289030-256279030)/CPU_TICKS_PER_SECOND) + 1)/2 = (10000*200/1000000) + 1) /2 = 1%.

2. memory consumption

The file "/proc/meminfo" contains the memory information and swap information. For example:

$ 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
......

However, from the source code of gkrellm, some versions do not have the statistics of the previous two rows, but can only collect data based on the following types of Key: Value.

3. Disk Space

From the source code of gkrellm, this is a very complex data. Disk partition data may be distributed in:/proc/mounts,/proc/diskstats,/proc/partitions, and so on. In addition, if you want to check a specific path, you also need the help of commands such as mount and df. To reduce the trouble, I can directly use the statfs function to obtain this data.

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

This function only needs to enter the path name to be checked to return the space usage of the partition where the path is located:

Total Space: buf. f_bsize * buf. f_blocks

Free Space: buf. f_bsize * buf. f_bavail

4. Disk I/O

Disk I/O data is also complex. For some versions, see/proc/diskstats, for some versions, see/proc/partitions, and for some versions, I still don't know where to view them ...... However, we can see that the data version is also the same as the CPU, which requires a value every other time. The difference between the two values is the traffic.

5. Network Traffic

Network traffic is also varied, but it can basically be obtained in/proc/net/dev. It also requires two values to take the difference as the traffic value.