`
cuker919
  • 浏览: 97598 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类
最新评论

查看TOMCAT内存使用情况（总结）

 
阅读更多

您可以用把下列代码放在一个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，也可以获得当前系统性能信息

http://kakaluyi.iteye.com/blog/211492

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

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

Java代码 收藏代码
  1. packagecom.amgkaka.performance;
  3. /***//**
  4. *监视信息的JavaBean类.
  5. *@authoramg
  6. *@version1.0
  7. *Creationdate:2008-4-25-上午10:37:00
  8. */
  9. publicclassMonitorInfoBean{
  10. /***//**可使用内存.*/
  11. privatelongtotalMemory;
  13. /***//**剩余内存.*/
  14. privatelongfreeMemory;
  16. /***//**最大可使用内存.*/
  17. privatelongmaxMemory;
  19. /***//**操作系统.*/
  20. privateStringosName;
  22. /***//**总的物理内存.*/
  23. privatelongtotalMemorySize;
  25. /***//**剩余的物理内存.*/
  26. privatelongfreePhysicalMemorySize;
  28. /***//**已使用的物理内存.*/
  29. privatelongusedMemory;
  31. /***//**线程总数.*/
  32. privateinttotalThread;
  34. /***//**cpu使用率.*/
  35. privatedoublecpuRatio;
  37. publiclonggetFreeMemory(){
  38. returnfreeMemory;
  39. }
  41. publicvoidsetFreeMemory(longfreeMemory){
  42. this.freeMemory=freeMemory;
  43. }
  45. publiclonggetFreePhysicalMemorySize(){
  46. returnfreePhysicalMemorySize;
  47. }
  49. publicvoidsetFreePhysicalMemorySize(longfreePhysicalMemorySize){
  50. this.freePhysicalMemorySize=freePhysicalMemorySize;
  51. }
  53. publiclonggetMaxMemory(){
  54. returnmaxMemory;
  55. }
  57. publicvoidsetMaxMemory(longmaxMemory){
  58. this.maxMemory=maxMemory;
  59. }
  61. publicStringgetOsName(){
  62. returnosName;
  63. }
  65. publicvoidsetOsName(StringosName){
  66. this.osName=osName;
  67. }
  69. publiclonggetTotalMemory(){
  70. returntotalMemory;
  71. }
  73. publicvoidsetTotalMemory(longtotalMemory){
  74. this.totalMemory=totalMemory;
  75. }
  77. publiclonggetTotalMemorySize(){
  78. returntotalMemorySize;
  79. }
  81. publicvoidsetTotalMemorySize(longtotalMemorySize){
  82. this.totalMemorySize=totalMemorySize;
  83. }
  85. publicintgetTotalThread(){
  86. returntotalThread;
  87. }
  89. publicvoidsetTotalThread(inttotalThread){
  90. this.totalThread=totalThread;
  91. }
  93. publiclonggetUsedMemory(){
  94. returnusedMemory;
  95. }
  97. publicvoidsetUsedMemory(longusedMemory){
  98. this.usedMemory=usedMemory;
  99. }
  101. publicdoublegetCpuRatio(){
  102. returncpuRatio;
  103. }
  105. publicvoidsetCpuRatio(doublecpuRatio){
  106. this.cpuRatio=cpuRatio;
  107. }
  108. }

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

Java代码 收藏代码
  1. packagecom.amgkaka.performance;
  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;
  18. }

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

Java代码 收藏代码
  1. packagecom.amgkaka.performance;
  3. importjava.io.InputStreamReader;
  4. importjava.io.LineNumberReader;
  6. importsun.management.ManagementFactory;
  8. importcom.sun.management.OperatingSystemMXBean;
  10. /***//**
  11. *获取系统信息的业务逻辑实现类.
  12. *@authoramg*@version1.0Creationdate:2008-3-11-上午10:06:06
  13. */
  14. publicclassMonitorServiceImplimplementsIMonitorService{
  15. //可以设置长些，防止读到运行此次系统检查时的cpu占用率，就不准了
  16. privatestaticfinalintCPUTIME=5000;
  18. privatestaticfinalintPERCENT=100;
  20. privatestaticfinalintFAULTLENGTH=10;
  22. /***//**
  23. *获得当前的监控对象.
  24. *@return返回构造好的监控对象
  25. *@throwsException
  26. *@authoramg*Creationdate:2008-4-25-上午10:45:08
  27. */
  28. publicMonitorInfoBeangetMonitorInfoBean()throwsException{
  29. intkb=1024;
  31. //可使用内存
  32. longtotalMemory=Runtime.getRuntime().totalMemory()/kb;
  33. //剩余内存
  34. longfreeMemory=Runtime.getRuntime().freeMemory()/kb;
  35. //最大可使用内存
  36. longmaxMemory=Runtime.getRuntime().maxMemory()/kb;
  38. OperatingSystemMXBeanosmxb=(OperatingSystemMXBean)ManagementFactory
  39. .getOperatingSystemMXBean();
  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;
  52. //获得线程总数
  53. ThreadGroupparentThread;
  54. for(parentThread=Thread.currentThread().getThreadGroup();parentThread
  55. .getParent()!=null;parentThread=parentThread.getParent())
  56. ;
  57. inttotalThread=parentThread.activeCount();
  59. doublecpuRatio=0;
  60. if(osName.toLowerCase().startsWith("windows")){
  61. cpuRatio=this.getCpuRatioForWindows();
  62. }
  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. }
  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. }
  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. }
  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. }
  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());
  189. System.out.println("可使用内存="+monitorInfo.getTotalMemory());
  190. System.out.println("剩余内存="+monitorInfo.getFreeMemory());
  191. System.out.println("最大可使用内存="+monitorInfo.getMaxMemory());
  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的工具类，该类的代码如下所示：

Java代码 收藏代码
  1. packagecom.amgkaka.performance;
  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利用率等信息。


分享到：
| Log4J 在系统运行时更改log4j的配置
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    TOMCAT内存大小调整

    TOMCAT内存大小调整是指在使用Java程序从数据库中查询大量数据或应用服务器（如Tomcat、JBoss、WebLogic）加载jar包时，出现java.lang.OutOfMemoryError异常的解决方法。这种异常主要是由于应用服务器的内存不足引起...

    tomcat内存泄漏备份方法

    总结来说，处理Tomcat内存泄漏涉及对JVM内存管理的深入理解、使用诊断工具、合理配置JVM参数、优化代码以及定期维护。通过正确使用`setenv`文件，可以有效地定制Tomcat的启动参数，以适应特定的应用场景并预防内存...

    eclipse和tomcat的内存配置

    #### 四、Tomcat内存配置 Tomcat是一款免费开源的轻量级Web服务器，常用于部署Java Web应用程序。 **1. 配置步骤** 使用Eclipse的Tomcat插件时，可以在“Window &gt; Preferences &gt; Tomcat &gt; JVM Setting”中添加相应...

    tomcat内存溢出总结

    ### Tomcat内存溢出总结 在生产环境中，Tomcat服务器如果配置不当，很容易出现内存溢出问题。这类问题不仅会影响应用程序的稳定运行，还可能导致服务不可用。本文将基于日常经验及查阅的相关资料，对几种常见的内存...

    Tomcat JVM内存设置方法

    - 可以通过访问`http://&lt;host&gt;:&lt;port&gt;/manager/status`页面查看当前JVM内存使用情况。 #### 六、总结 通过上述步骤，您可以有效地调整Tomcat的JVM内存设置，从而提高应用性能和稳定性。请注意，这些设置需要根据...

    tomcat服务内存扩大.docx

    通常，我们可以通过监控Tomcat的内存使用情况，如通过JMX或VisualVM等工具，来确定合适的内存分配值。同时，优化应用的内存使用，如减少对象创建和及时垃圾回收，也是提高Tomcat性能的重要手段。 总结来说，本文件...

    tomcat内存配置

    ### Tomcat内存配置的重要性 在实际的应用场景中，由于不同的应用场景对资源的需求不同，因此合理设置Tomcat的内存参数至关重要。例如，在高并发环境下，如果不合理地配置内存参数，可能会导致服务器响应变慢、应用...

    一次使用Eclipse Memory Analyzer分析Tomcat内存溢出

    通过本次使用 Eclipse Memory Analyzer (MAT) 分析 Tomcat 内存溢出的过程，我们可以得出以下结论： - 内存管理对于 Java 应用程序至关重要。 - 遇到内存溢出或泄露问题时，MAT 是一款非常强大的工具，可以帮助快速...

    Tomcat内存优化

    ### Tomcat内存优化详解 #### 一、引言 在Java Web应用开发中，Apache Tomcat作为一款轻量级的应用服务器被广泛使用。然而，在实际部署和运行...同时，建议定期监控应用的内存使用情况，以便及时发现问题并采取措施。

    扩大Tomcat内存

    ### 扩大Tomcat内存的方法详解 #### 一、引言 在开发和部署Web应用程序的过程中，Apache Tomcat作为一款广泛使用的开源Java Servlet容器，因其轻量级且易于配置而备受青睐。然而，默认情况下，Tomcat分配给Java...

    tomcat内存溢出总结（2013年）

    - 监控系统资源使用情况，包括CPU、内存和磁盘，确保整体系统健康。 - 在部署大型应用时，考虑使用更强大的硬件或分布式架构来分散负载。 总之，理解和正确配置Tomcat的内存参数是避免内存溢出的关键。同时，定期...

    Tomcat JVM内存优化（Linux环境）

    ### Tomcat JVM内存优化（Linux环境） 在Linux环境下运行Tomcat服务器时，经常会遇到与Java虚拟机（JVM）相关的内存溢出问题。这些问题通常表现为`java.lang.OutOfMemoryError`异常，具体又分为两类：`PermGen ...

Magicbox
Global site tag (gtag.js) - Google Analytics