看内存使用量res

转载

新新人类 2024-12-19 09:36:55

文章标签 看内存使用量res java runtime 操作系统 Memory 文章分类 架构后端开发

您可以用把下列代码放在一个JSP文件中,如写入memory.jsp,放到你的TOMCAT下的任何一应用中,就可以看到你的TOMCAT总大可使用多少内存,已经使用了多少.

<%--
 Document : memory
 Created on : 2009-4-9, 1:35:17
 Author : Administrator
 --%><%@page contentType="text/html" pageEncoding="UTF-8"%>
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
 "http://www.w3.org/TR/html4/loose.dtd"> <html> 

 <head> 

 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> 

 <title>JVM memory</title> 

 </head> 

 <body> 

 <% 

 double total = (Runtime.getRuntime().totalMemory()) / (1024.0 * 1024); 

 double max = (Runtime.getRuntime().maxMemory()) / (1024.0 * 1024); 

 double free = (Runtime.getRuntime().freeMemory()) / (1024.0 * 1024); 

 out.println("Java 虚拟机试图使用的最大内存量(当前JVM的最大可用内存)maxMemory(): " + max + "MB<br/>"); 

 out.println("Java 虚拟机中的内存总量(当前JVM占用的内存总数)totalMemory(): " + total + "MB<br/>"); 

 out.println("Java 虚拟机中的空闲内存量(当前JVM空闲内存)freeMemory(): " + free + "MB<br/>"); 

 out.println("因为JVM只有在需要内存时才占用物理内存使用，所以freeMemory()的值一般情况下都很小，<br/>" + 

 "而JVM实际可用内存并不等于freeMemory()，而应该等于 maxMemory()-totalMemory()+freeMemory()。<br/>"); 

 out.println("JVM实际可用内存: " + (max - total + free) + "MB<br/>"); 

 out.println("jspcn"); 

 %> 

 </body> 

</html>

上面的例子基本可以满足性能调试使用，下面的比较详细，需要开发代码，暂时使用上面简单例子。

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

同样也可以进入tomcat管理页面，查看内存使用情况，但是平常在生产环境都禁掉了管理员登录页面。

http://zhumeng8337797.blog.163.com/blog/static/10076891420129223928915/

1. Tomcat6中没有设置任何默认用户，因而需要手动往Tomcat6的conf文件夹下的tomcat-users.xml文件中添加用户。

如：<role rolename="manager"/>
<user username="tomcat" password="tomcat" roles="manager"/>

注：添加完需要重启Tomcat6。

2. 访问http://localhost:8080/manager/status，输入上面添加的用户名和密码。

3. 然后在如下面的JVM下可以看到内存的使用情况。
JVM:Free memory: 2.50 MB Total memory: 15.53 MB Max memory: 63.56 MB

Free memory:当前可用的内存；

Total memory:当前已经分配的JVM内存；

Max memory:当前允许分配的最大JVM内存；

上周的题目有些简单，但是tomcat也需要我们研究一下，因为涉及的知识不多，但是将来这些都是部署时候非常有用的技术。

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

java不用jni，也可以获得当前系统性能信息

最近做个项目，就是要取得cpu占有率等等的系统信息，一开始以为要用动态链接库了，但后来发现可以像下面这样做，不去调用jni，这样省去了很多看新技术的时间o(∩_∩)o...

在Java中，可以获得总的物理内存、剩余的物理内存、已使用的物理内存等信息，下面例子可以取得这些信息，并且获得在Windows下的内存使用率。
首先编写一个MonitorInfoBean类，用来装载监控的一些信息，包括物理内存、剩余的物理内存、已使用的物理内存、内存使用率等字段，该类的代码如下：

1. packagecom.amgkaka.performance;
2. 
3. /***//**
4. *监视信息的JavaBean类.
5. *@authoramg
6. *@version1.0
7. *Creationdate:2008-4-25-上午10:37:00
8. */
9. publicclassMonitorInfoBean{

10. /***//**可使用内存.*/
11. privatelongtotalMemory;
12. 
13. /***//**剩余内存.*/
14. privatelongfreeMemory;
15. 
16. /***//**最大可使用内存.*/
17. privatelongmaxMemory;
18. 
19. /***//**操作系统.*/
20. privateStringosName;
21. 
22. /***//**总的物理内存.*/
23. privatelongtotalMemorySize;
24. 
25. /***//**剩余的物理内存.*/
26. privatelongfreePhysicalMemorySize;
27. 
28. /***//**已使用的物理内存.*/
29. privatelongusedMemory;
30. 
31. /***//**线程总数.*/
32. privateinttotalThread;
33. 
34. /***//**cpu使用率.*/
35. privatedoublecpuRatio;
36. 
37. publiclonggetFreeMemory(){

38. returnfreeMemory;
39. }
40. 
41. publicvoidsetFreeMemory(longfreeMemory){

42. this.freeMemory=freeMemory;
43. }
44. 
45. publiclonggetFreePhysicalMemorySize(){

46. returnfreePhysicalMemorySize;
47. }
48. 
49. publicvoidsetFreePhysicalMemorySize(longfreePhysicalMemorySize){

50. this.freePhysicalMemorySize=freePhysicalMemorySize;
51. }
52. 
53. publiclonggetMaxMemory(){

54. returnmaxMemory;
55. }
56. 
57. publicvoidsetMaxMemory(longmaxMemory){

58. this.maxMemory=maxMemory;
59. }
60. 
61. publicStringgetOsName(){

62. returnosName;
63. }
64. 
65. publicvoidsetOsName(StringosName){

66. this.osName=osName;
67. }
68. 
69. publiclonggetTotalMemory(){

70. returntotalMemory;
71. }
72. 
73. publicvoidsetTotalMemory(longtotalMemory){

74. this.totalMemory=totalMemory;
75. }
76. 
77. publiclonggetTotalMemorySize(){

78. returntotalMemorySize;
79. }
80. 
81. publicvoidsetTotalMemorySize(longtotalMemorySize){

82. this.totalMemorySize=totalMemorySize;
83. }
84. 
85. publicintgetTotalThread(){

86. returntotalThread;
87. }
88. 
89. publicvoidsetTotalThread(inttotalThread){

90. this.totalThread=totalThread;
91. }
92. 
93. publiclonggetUsedMemory(){

94. returnusedMemory;
95. }
96. 
97. publicvoidsetUsedMemory(longusedMemory){

98. this.usedMemory=usedMemory;
99. }
100. 
101. publicdoublegetCpuRatio(){

102. returncpuRatio;
103. }
104. 
105. publicvoidsetCpuRatio(doublecpuRatio){

106. this.cpuRatio=cpuRatio;
107. }
108. }

接着编写一个获得当前的监控信息的接口，该类的代码如下所示：

1. packagecom.amgkaka.performance;
2. 
3. /***//**
4. *获取系统信息的业务逻辑类接口.
5. *@authoramg*@version1.0
6. *Creationdate:2008-3-11-上午10:06:06
7. */
8. publicinterfaceIMonitorService{

9. /***//**
10. *获得当前的监控对象.
11. *@return返回构造好的监控对象
12. *@throwsException
13. *@authoramgkaka
14. *Creationdate:2008-4-25-上午10:45:08
15. */
16. publicMonitorInfoBeangetMonitorInfoBean()throwsException;
17. 
18. }

该类的实现类MonitorServiceImpl如下所示：

1. packagecom.amgkaka.performance;
2. 
3. importjava.io.InputStreamReader;
4. importjava.io.LineNumberReader;
5. 
6. importsun.management.ManagementFactory;
7. 
8. importcom.sun.management.OperatingSystemMXBean;
9. 
10. /***//**
11. *获取系统信息的业务逻辑实现类.
12. *@authoramg*@version1.0Creationdate:2008-3-11-上午10:06:06
13. */
14. publicclassMonitorServiceImplimplementsIMonitorService{

15. //可以设置长些，防止读到运行此次系统检查时的cpu占用率，就不准了
16. privatestaticfinalintCPUTIME=5000;
17. 
18. privatestaticfinalintPERCENT=100;
19. 
20. privatestaticfinalintFAULTLENGTH=10;
21. 
22. /***//**
23. *获得当前的监控对象.
24. *@return返回构造好的监控对象
25. *@throwsException
26. *@authoramg*Creationdate:2008-4-25-上午10:45:08
27. */
28. publicMonitorInfoBeangetMonitorInfoBean()throwsException{

29. intkb=1024;
30. 
31. //可使用内存
32. longtotalMemory=Runtime.getRuntime().totalMemory()/kb;
33. //剩余内存
34. longfreeMemory=Runtime.getRuntime().freeMemory()/kb;
35. //最大可使用内存
36. longmaxMemory=Runtime.getRuntime().maxMemory()/kb;
37. 
38. OperatingSystemMXBeanosmxb=(OperatingSystemMXBean)ManagementFactory
39. .getOperatingSystemMXBean();
40. 
41. //操作系统
42. StringosName=System.getProperty("os.name");
43. //总的物理内存
44. longtotalMemorySize=osmxb.getTotalPhysicalMemorySize()/kb;
45. //剩余的物理内存
46. longfreePhysicalMemorySize=osmxb.getFreePhysicalMemorySize()/kb;
47. //已使用的物理内存
48. longusedMemory=(osmxb.getTotalPhysicalMemorySize()-osmxb
49. .getFreePhysicalMemorySize())
50. /kb;
51. 
52. //获得线程总数
53. ThreadGroupparentThread;
54. for(parentThread=Thread.currentThread().getThreadGroup();parentThread
55. .getParent()!=null;parentThread=parentThread.getParent())
56. ;
57. inttotalThread=parentThread.activeCount();
58. 
59. doublecpuRatio=0;
60. if(osName.toLowerCase().startsWith("windows")){

61. cpuRatio=this.getCpuRatioForWindows();
62. }
63. 
64. //构造返回对象
65. MonitorInfoBeaninfoBean=newMonitorInfoBean();
66. infoBean.setFreeMemory(freeMemory);
67. infoBean.setFreePhysicalMemorySize(freePhysicalMemorySize);
68. infoBean.setMaxMemory(maxMemory);
69. infoBean.setOsName(osName);
70. infoBean.setTotalMemory(totalMemory);
71. infoBean.setTotalMemorySize(totalMemorySize);
72. infoBean.setTotalThread(totalThread);
73. infoBean.setUsedMemory(usedMemory);
74. infoBean.setCpuRatio(cpuRatio);
75. returninfoBean;
76. }
77. 
78. /***//**
79. *获得CPU使用率.
80. *@return返回cpu使用率
81. *@authoramg*Creationdate:2008-4-25-下午06:05:11
82. */
83. privatedoublegetCpuRatioForWindows(){

84. try{

85. StringprocCmd=System.getenv("windir")
86. +"\\system32\\wbem\\wmic.exeprocessgetCaption,CommandLine,"
87. +"KernelModeTime,ReadOperationCount,ThreadCount,UserModeTime,WriteOperationCount";
88. //取进程信息
89. long[]c0=readCpu(Runtime.getRuntime().exec(procCmd));
90. Thread.sleep(CPUTIME);
91. long[]c1=readCpu(Runtime.getRuntime().exec(procCmd));
92. if(c0!=null&&c1!=null){

93. longidletime=c1[0]-c0[0];
94. longbusytime=c1[1]-c0[1];
95. returnDouble.valueOf(
96. PERCENT*(busytime)/(busytime+idletime))
97. .doubleValue();
98. }else{

99. return0.0;
100. }
101. }catch(Exceptionex){

102. ex.printStackTrace();
103. return0.0;
104. }
105. }
106. 
107. /***//**
108. *读取CPU信息.
109. *@paramproc
110. *@return
111. *@authoramg*Creationdate:2008-4-25-下午06:10:14
112. */
113. privatelong[]readCpu(finalProcessproc){

114. long[]retn=newlong[2];
115. try{

116. proc.getOutputStream().close();
117. InputStreamReaderir=newInputStreamReader(proc.getInputStream());
118. LineNumberReaderinput=newLineNumberReader(ir);
119. Stringline=input.readLine();
120. if(line==null||line.length()<FAULTLENGTH){

121. returnnull;
122. }
123. intcapidx=line.indexOf("Caption");
124. intcmdidx=line.indexOf("CommandLine");
125. introcidx=line.indexOf("ReadOperationCount");
126. intumtidx=line.indexOf("UserModeTime");
127. intkmtidx=line.indexOf("KernelModeTime");
128. intwocidx=line.indexOf("WriteOperationCount");
129. longidletime=0;
130. longkneltime=0;
131. longusertime=0;
132. while((line=input.readLine())!=null){

133. if(line.length()<wocidx){

134. continue;
135. }
136. //字段出现顺序：Caption,CommandLine,KernelModeTime,ReadOperationCount,
137. //ThreadCount,UserModeTime,WriteOperation
138. Stringcaption=Bytes.substring(line,capidx,cmdidx-1)
139. .trim();
140. Stringcmd=Bytes.substring(line,cmdidx,kmtidx-1).trim();
141. if(cmd.indexOf("wmic.exe")>=0){

142. continue;
143. }
144. //log.info("line="+line);
145. if(caption.equals("SystemIdleProcess")
146. ||caption.equals("System")){

147. idletime+=Long.valueOf(
148. Bytes.substring(line,kmtidx,rocidx-1).trim())
149. .longValue();
150. idletime+=Long.valueOf(
151. Bytes.substring(line,umtidx,wocidx-1).trim())
152. .longValue();
153. continue;
154. }
155. 
156. kneltime+=Long.valueOf(
157. Bytes.substring(line,kmtidx,rocidx-1).trim())
158. .longValue();
159. usertime+=Long.valueOf(
160. Bytes.substring(line,umtidx,wocidx-1).trim())
161. .longValue();
162. }
163. retn[0]=idletime;
164. retn[1]=kneltime+usertime;
165. returnretn;
166. }catch(Exceptionex){

167. ex.printStackTrace();
168. }finally{

169. try{

170. proc.getInputStream().close();
171. }catch(Exceptione){

172. e.printStackTrace();
173. }
174. }
175. returnnull;
176. }
177. 
178. /***//**
179. *测试方法.
180. *@paramargs
181. *@throwsException
182. *@authoramg*Creationdate:2008-4-30-下午04:47:29
183. */
184. publicstaticvoidmain(String[]args)throwsException{

185. IMonitorServiceservice=newMonitorServiceImpl();
186. MonitorInfoBeanmonitorInfo=service.getMonitorInfoBean();
187. System.out.println("cpu占有率="+monitorInfo.getCpuRatio());
188. 
189. System.out.println("可使用内存="+monitorInfo.getTotalMemory());
190. System.out.println("剩余内存="+monitorInfo.getFreeMemory());
191. System.out.println("最大可使用内存="+monitorInfo.getMaxMemory());
192. 
193. System.out.println("操作系统="+monitorInfo.getOsName());
194. System.out.println("总的物理内存="+monitorInfo.getTotalMemorySize()+"kb");
195. System.out.println("剩余的物理内存="+monitorInfo.getFreeMemory()+"kb");
196. System.out.println("已使用的物理内存="+monitorInfo.getUsedMemory()+"kb");
197. System.out.println("线程总数="+monitorInfo.getTotalThread()+"kb");
198. }
199. }

该实现类中需要用到一个自己编写byte的工具类，该类的代码如下所示：

1. packagecom.amgkaka.performance;
2. 
3. /***//**
4. *byte操作类.
5. *@authoramg*@version1.0
6. *Creationdate:2008-4-30-下午04:57:23
7. */
8. publicclassBytes{

9. /***//**
10. *由于String.subString对汉字处理存在问题（把一个汉字视为一个字节)，因此在
11. *包含汉字的字符串时存在隐患，现调整如下：
12. *@paramsrc要截取的字符串
13. *@paramstart_idx开始坐标（包括该坐标)
14. *@paramend_idx截止坐标（包括该坐标）
15. *@return
16. */
17. publicstaticStringsubstring(Stringsrc,intstart_idx,intend_idx){

18. byte[]b=src.getBytes();
19. Stringtgt="";
20. for(inti=start_idx;i<=end_idx;i++){

21. tgt+=(char)b[i];
22. }
23. returntgt;
24. }
25. }

运行下MonitorBeanImpl类，读者将会看到当前的内存、cpu利用率等信息。

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。