[Java学习] Java获取Linux系统cpu使用率

1. import java.io.BufferedReader;
2. import java.io.FileInputStream;
3. import java.io.IOException;
4. import java.io.InputStreamReader;
5. import java.util.ArrayList;
6. import java.util.HashMap;
7. import java.util.List;
8. import java.util.Map;
9. import java.util.StringTokenizer;
10. http://m.nvzi91.cn/gongjingai/29421.ht
11. import org.apache.commons.io.FileSystemUtils;
13. public class OSUtils {
15. /**
16. * 功能：可用磁盘
17. * */
18. public static int disk() {
19. try {
20. long total = FileSystemUtils.freeSpaceKb("/home");
21. double disk = (double) total / 1024 / 1024;
22. return (int) disk;
23. } catch (IOException e) {
24. e.printStackTrace();
25. }
26. return 0;
27. }
29. /**
30. * 功能：获取Linux系统cpu使用率
31. * */
32. public static int cpuUsage() {
33. try {
34. Map<?, ?> map1 = OSUtils.cpuinfo();
35. Thread.sleep(5 * 1000);
36. Map<?, ?> map2 = OSUtils.cpuinfo();
37. http://m.nvzi91.cn/gongjingfeida/29422.html
38. long user1 = Long.parseLong(map1.get("user").toString());
39. long nice1 = Long.parseLong(map1.get("nice").toString());
40. long system1 = Long.parseLong(map1.get("system").toString());
41. long idle1 = Long.parseLong(map1.get("idle").toString());
43. long user2 = Long.parseLong(map2.get("user").toString());
44. long nice2 = Long.parseLong(map2.get("nice").toString());
45. long system2 = Long.parseLong(map2.get("system").toString());
46. long idle2 = Long.parseLong(map2.get("idle").toString());
48. long total1 = user1 + system1 + nice1;
49. long total2 = user2 + system2 + nice2;
50. float total = total2 - total1;
52. long totalIdle1 = user1 + nice1 + system1 + idle1;
53. long totalIdle2 = user2 + nice2 + system2 + idle2;
54. float totalidle = totalIdle2 - totalIdle1;
56. float cpusage = (total / totalidle) * 100;
57. return (int) cpusage;
58. } catch (InterruptedException e) {
59. e.printStackTrace();
60. }
61. return 0;
62. }
64. /**
65. * 功能：CPU使用信息
66. * */
67. public static Map<?, ?> cpuinfo() {
68. InputStreamReader inputs = null;
69. BufferedReader buffer = null;
70. Map<String, Object> map = new HashMap<String, Object>();
71. try {
72. inputs = new InputStreamReader(new FileInputStream("/proc/stat"));
73. buffer = new BufferedReader(inputs);
74. String line = "";
75. while (true) {
76. line = buffer.readLine();
77. if (line == null) {
78. break;
79. }http://m.nvzi91.cn/gongjingmilan/29423.html
80. if (line.startsWith("cpu")) {
81. StringTokenizer tokenizer = new StringTokenizer(line);
82. List<String> temp = new ArrayList<String>();
83. while (tokenizer.hasMoreElements()) {
84. String value = tokenizer.nextToken();
85. temp.add(value);
86. }
87. map.put("user", temp.get(1));
88. map.put("nice", temp.get(2));
89. map.put("system", temp.get(3));
90. map.put("idle", temp.get(4));
91. map.put("iowait", temp.get(5));
92. map.put("irq", temp.get(6));
93. map.put("softirq", temp.get(7));
94. map.put("stealstolen", temp.get(8));
95. break;
96. }
97. }
98. } catch (Exception e) {
99. e.printStackTrace();
100. } finally {
101. try {
102. buffer.close();
103. inputs.close();
104. } catch (Exception e2) {
105. e2.printStackTrace();
106. }
107. }
108. return map;
109. }
111. /**
112. * 功能：内存使用率
113. * */m.nvzi91.cn
114. public static int memoryUsage() {
115. Map<String, Object> map = new HashMap<String, Object>();
116. InputStreamReader inputs = null;
117. BufferedReader buffer = null;
118. try {
119. inputs = new InputStreamReader(new FileInputStream("/proc/meminfo"));
120. buffer = new BufferedReader(inputs);
121. String line = "";
122. while (true) {
123. line = buffer.readLine();
124. if (line == null)
125. break;
126. int beginIndex = 0;
127. int endIndex = line.indexOf(":");
128. if (endIndex != -1) {
129. String key = line.substring(beginIndex, endIndex);
130. beginIndex = endIndex + 1;
131. endIndex = line.length();
132. String memory = line.substring(beginIndex, endIndex);
133. String value = memory.replace("kB", "").trim();
134. map.put(key, value);
135. }
136. }
138. long memTotal = Long.parseLong(map.get("MemTotal").toString());
139. long memFree = Long.parseLong(map.get("MemFree").toString());
140. long memused = memTotal - memFree;
141. long buffers = Long.parseLong(map.get("Buffers").toString());
142. long cached = Long.parseLong(map.get("Cached").toString());
144. double usage = (double) (memused - buffers - cached) / memTotal * 100;
145. return (int) usage;
146. } catch (Exception e) {
147. e.printStackTrace();
148. } finally {
149. try {
150. buffer.close();
151. inputs.close();
152. } catch (Exception e2) {
153. e2.printStackTrace();
154. }
155. }
156. return 0;
157. }
158. }