最近做個專案，就是要取得cpu佔有率等等的系統資訊，一開始以為要用動態連結庫了，但後來發現可以像下面這樣做，不去呼叫jni，這樣省去了很多看新技術的時間o(∩_∩)o...

在Java中，可以獲得總的實體記憶體、剩餘的實體記憶體、已使用的實體記憶體等資訊，下面例子可以取得這些資訊，並且獲得在Windows下的記憶體使用率。
首先編寫一個MonitorInfoBean類，用來裝載監控的一些資訊，包括實體記憶體、剩餘的實體記憶體、已使用的實體記憶體、記憶體使用率等欄位，該類的程式碼如下：

1. packagecom.amgkaka.performance;
2. /***//**
3. *監視資訊的JavaBean類.
4. *@authoramg
5. *@version1.0
6. *Creationdate:2008-4-25-上午10:37:00
7. */
8. publicclassMonitorInfoBean{
9. /***//**可使用記憶體.*/
10. privatelongtotalMemory;
11. /***//**剩餘記憶體.*/
12. privatelongfreeMemory;
13. /***//**最大可使用記憶體.*/
14. privatelongmaxMemory;
15. /***//**作業系統.*/
16. privateStringosName;
17. /***//**總的實體記憶體.*/
18. privatelongtotalMemorySize;
19. /***//**剩餘的實體記憶體.*/
20. private
    longfreePhysicalMemorySize;
21. /***//**已使用的實體記憶體.*/
22. privatelongusedMemory;
23. /***//**執行緒總數.*/
24. privateinttotalThread;
25. /***//**cpu使用率.*/
26. privatedoublecpuRatio;
27. publiclonggetFreeMemory(){
28. returnfreeMemory;
29. }
30. publicvoidsetFreeMemory(longfreeMemory){
31. this.freeMemory=freeMemory;
32. }
33. publiclonggetFreePhysicalMemorySize(){
34. returnfreePhysicalMemorySize;
35. }
36. publicvoidsetFreePhysicalMemorySize(longfreePhysicalMemorySize){
37. this.freePhysicalMemorySize=freePhysicalMemorySize;
38. }
39. publiclonggetMaxMemory(){
40. returnmaxMemory;
41. }
42. publicvoidsetMaxMemory(longmaxMemory){
43. this.maxMemory=maxMemory;
44. }
45. publicStringgetOsName(){
46. returnosName;
47. }
48. publicvoidsetOsName(StringosName){
49. this.osName=osName;
50. }
51. publiclonggetTotalMemory(){
52. returntotalMemory;
53. }
54. publicvoidsetTotalMemory(longtotalMemory){
55. this.totalMemory=totalMemory;
56. }
57. publiclonggetTotalMemorySize(){
58. returntotalMemorySize;
59. }
60. publicvoidsetTotalMemorySize(longtotalMemorySize){
61. this.totalMemorySize=totalMemorySize;
62. }
63. publicintgetTotalThread(){
64. returntotalThread;
65. }
66. publicvoidsetTotalThread(inttotalThread){
67. this.totalThread=totalThread;
68. }
69. publiclonggetUsedMemory(){
70. returnusedMemory;
71. }
72. publicvoidsetUsedMemory(longusedMemory){
73. this.usedMemory=usedMemory;
74. }
75. publicdoublegetCpuRatio(){
76. returncpuRatio;
77. }
78. publicvoidsetCpuRatio(doublecpuRatio){
79. this.cpuRatio=cpuRatio;
80. }
81. }

接著編寫一個獲得當前的監控資訊的介面，該類的程式碼如下所示：

1. packagecom.amgkaka.performance;
2. /***//**
3. *獲取系統資訊的業務邏輯類介面.
4. *@authoramg*@version1.0
5. *Creationdate:2008-3-11-上午10:06:06
6. */
7. publicinterfaceIMonitorService{
8. /***//**
9. *獲得當前的監控物件.
10. *@return返回構造好的監控物件
11. *@throwsException
12. *@authoramgkaka
13. *Creationdate:2008-4-25-上午10:45:08
14. */
15. publicMonitorInfoBeangetMonitorInfoBean()throwsException;
16. }

該類的實現類MonitorServiceImpl如下所示：

1. packagecom.amgkaka.performance;
2. importjava.io.InputStreamReader;
3. importjava.io.LineNumberReader;
4. importsun.management.ManagementFactory;
5. importcom.sun.management.OperatingSystemMXBean;
6. /***//**
7. *獲取系統資訊的業務邏輯實現類.
8. *@authoramg*@version1.0Creationdate:2008-3-11-上午10:06:06
9. */
10. publicclassMonitorServiceImplimplementsIMonitorService{
11. //可以設定長些，防止讀到執行此次系統檢查時的cpu佔用率，就不準了
12. privatestaticfinalintCPUTIME=5000;
13. privatestaticfinalintPERCENT=100;
14. privatestaticfinalintFAULTLENGTH=10;
15. /***//**
16. *獲得當前的監控物件.
17. *@return返回構造好的監控物件
18. *@throwsException
19. *@authoramg*Creationdate:2008-4-25-上午10:45:08
20. */
21. publicMonitorInfoBeangetMonitorInfoBean()throwsException{
22. intkb=1024;
23. //可使用記憶體
24. longtotalMemory=Runtime.getRuntime().totalMemory()/kb;
25. //剩餘記憶體
26. longfreeMemory=Runtime.getRuntime().freeMemory()/kb;
27. //最大可使用記憶體
28. longmaxMemory=Runtime.getRuntime().maxMemory()/kb;
29. OperatingSystemMXBeanosmxb=(OperatingSystemMXBean)ManagementFactory
30. .getOperatingSystemMXBean();
31. //作業系統
32. StringosName=System.getProperty("os.name");
33. //總的實體記憶體
34. longtotalMemorySize=osmxb.getTotalPhysicalMemorySize()/kb;
35. //剩餘的實體記憶體
36. longfreePhysicalMemorySize=osmxb.getFreePhysicalMemorySize()/kb;
37. //已使用的實體記憶體
38. longusedMemory=(osmxb.getTotalPhysicalMemorySize()-osmxb
39. .getFreePhysicalMemorySize())
40. /kb;
41. //獲得執行緒總數
42. ThreadGroupparentThread;
43. for(parentThread=Thread.currentThread().getThreadGroup();parentThread
44. .getParent()!=null;parentThread=parentThread.getParent())
45. ;
46. inttotalThread=parentThread.activeCount();
47. doublecpuRatio=0;
48. if(osName.toLowerCase().startsWith("windows")){
49. cpuRatio=this.getCpuRatioForWindows();
50. }
51. //構造返回物件
52. MonitorInfoBeaninfoBean=newMonitorInfoBean();
53. infoBean.setFreeMemory(freeMemory);
54. infoBean.setFreePhysicalMemorySize(freePhysicalMemorySize);
55. infoBean.setMaxMemory(maxMemory);
56. infoBean.setOsName(osName);
57. infoBean.setTotalMemory(totalMemory);
58. infoBean.setTotalMemorySize(totalMemorySize);
59. infoBean.setTotalThread(totalThread);
60. infoBean.setUsedMemory(usedMemory);
61. infoBean.setCpuRatio(cpuRatio);
62. returninfoBean;
63. }
64. /***//**
65. *獲得CPU使用率.
66. *@return返回cpu使用率
67. *@authoramg*Creationdate:2008-4-25-下午06:05:11
68. */
69. privatedoublegetCpuRatioForWindows(){
70. try{
71. StringprocCmd=System.getenv("windir")
72. +"\\system32\\wbem\\wmic.exeprocessgetCaption,CommandLine,"
73. +"KernelModeTime,ReadOperationCount,ThreadCount,UserModeTime,WriteOperationCount";
74. //取程序資訊
75. long[]c0=readCpu(Runtime.getRuntime().exec(procCmd));
76. Thread.sleep(CPUTIME);
77. long[]c1=readCpu(Runtime.getRuntime().exec(procCmd));
78. if(c0!=null&&c1!=null){
79. longidletime=c1[0]-c0[0];
80. longbusytime=c1[1]-c0[1];
81. returnDouble.valueOf(
82. PERCENT*(busytime)/(busytime+idletime))
83. .doubleValue();
84. }else{
85. return0.0;
86. }
87. }catch(Exceptionex){
88. ex.printStackTrace();
89. return0.0;
90. }
91. }
92. /***//**
93. *讀取CPU資訊.
94. *@paramproc
95. *@return
96. *@authoramg*Creationdate:2008-4-25-下午06:10:14
97. */
98. privatelong[]readCpu(finalProcessproc){
99. long[]retn=newlong[2];
100. try{
101. proc.getOutputStream().close();
102. InputStreamReaderir=newInputStreamReader(proc.getInputStream());
103. LineNumberReaderinput=newLineNumberReader(ir);
104. Stringline=input.readLine();
105. if(line==null||line.length()<FAULTLENGTH){
106. returnnull;
107. }
108. intcapidx=line.indexOf("Caption");
109. intcmdidx=line.indexOf("CommandLine");
110. introcidx=line.indexOf("ReadOperationCount");
111. intumtidx=line.indexOf("UserModeTime");
112. intkmtidx=line.indexOf("KernelModeTime");
113. intwocidx=line.indexOf("WriteOperationCount");
114. longidletime=0;
115. longkneltime=0;
116. longusertime=0;
117. while((line=input.readLine())!=null){
118. if(line.length()<wocidx){
119. continue;
120. }
121. //欄位出現順序：Caption,CommandLine,KernelModeTime,ReadOperationCount,
122. //ThreadCount,UserModeTime,WriteOperation
123. Stringcaption=Bytes.substring(line,capidx,cmdidx-1)
124. .trim();
125. Stringcmd=Bytes.substring(line,cmdidx,kmtidx-1).trim();
126. if(cmd.indexOf("wmic.exe")>=0){
127. continue;
128. }
129. //log.info("line="+line);
130. if(caption.equals("SystemIdleProcess")
131. ||caption.equals("System")){
132. idletime+=Long.valueOf(
133. Bytes.substring(line,kmtidx,rocidx-1).trim())
134. .longValue();
135. idletime+=Long.valueOf(
136. Bytes.substring(line,umtidx,wocidx-1).trim())
137. .longValue();
138. continue;
139. }
140. kneltime+=Long.valueOf(
141. Bytes.substring(line,kmtidx,rocidx-1).trim())
142. .longValue();
143. usertime+=Long.valueOf(
144. Bytes.substring(line,umtidx,wocidx-1).trim())
145. .longValue();
146. }
147. retn[0]=idletime;
148. retn[1]=kneltime+usertime;
149. returnretn;
150. }catch(Exceptionex){
151. ex.printStackTrace();
152. }finally{
153. try{
154. proc.getInputStream().close();
155. }catch(Exceptione){
156. e.printStackTrace();
157. }
158. }
159. returnnull;
160. }
161. /***//**
162. *測試方法.
163. *@paramargs
164. *@throwsException
165. *@authoramg*Creationdate:2008-4-30-下午04:47:29
166. */
167. publicstaticvoidmain(String[]args)throwsException{
168. IMonitorServiceservice=newMonitorServiceImpl();
169. MonitorInfoBeanmonitorInfo=service.getMonitorInfoBean();
170. System.out.println("cpu佔有率="+monitorInfo.getCpuRatio());
171. System.out.println("可使用記憶體="+monitorInfo.getTotalMemory());
172. System.out.println("剩餘記憶體="+monitorInfo.getFreeMemory());
173. System.out.println("最大可使用記憶體="+monitorInfo.getMaxMemory());
174. System.out.println("作業系統="+monitorInfo.getOsName());
175. System.out.println("總的實體記憶體="+monitorInfo.getTotalMemorySize()+"kb");
176. System.out.println("剩餘的實體記憶體="+monitorInfo.getFreeMemory()+"kb");
177. System.out.println("已使用的實體記憶體="+monitorInfo.getUsedMemory()+"kb");
178. System.out.println("執行緒總數="+monitorInfo.getTotalThread()+"kb");
179. }
180. }

該實現類中需要用到一個自己編寫byte的工具類，該類的程式碼如下所示：

1. packagecom.amgkaka.performance;
2. /***//**
3. *byte操作類.
4. *@authoramg*@version1.0
5. *Creationdate:2008-4-30-下午04:57:23
6. */
7. publicclassBytes{
8. /***//**
9. *由於String.subString對漢字處理存在問題（把一個漢字視為一個位元組)，因此在
10. *包含漢字的字串時存在隱患，現調整如下：
11. *@paramsrc要擷取的字串
12. *@paramstart_idx開始座標（包括該座標)
13. *@paramend_idx截止座標（包括該座標）
14. *@return
15. */
16. publicstaticStringsubstring(Stringsrc,intstart_idx,intend_idx){
17. byte[]b=src.getBytes();
18. Stringtgt="";
19. for(inti=start_idx;i<=end_idx;i++){
20. tgt+=(char)b[i];
21. }
22. returntgt;
23. }
24. }

執行下MonitorBeanImpl類，讀者將會看到當前的記憶體、cpu利用率等資訊。