查看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. package com.amgkaka.performance;  
  2.   
  3. /** *//** 
  4.  * 监视信息的JavaBean类. 
  5.  * @author  amg 
  6.  * @version 1.0  
  7.  * Creation date: 2008-4-25 - 上午10:37:00 
  8.  */  
  9. public class MonitorInfoBean {  
  10.     /** *//** 可使用内存. */  
  11.     private long totalMemory;  
  12.       
  13.     /** *//** 剩余内存. */  
  14.     private long freeMemory;  
  15.       
  16.     /** *//** 最大可使用内存. */  
  17.     private long maxMemory;  
  18.       
  19.     /** *//** 操作系统. */  
  20.     private String osName;  
  21.       
  22.     /** *//** 总的物理内存. */  
  23.     private long totalMemorySize;  
  24.       
  25.     /** *//** 剩余的物理内存. */  
  26.     private long freePhysicalMemorySize;  
  27.       
  28.     /** *//** 已使用的物理内存. */  
  29.     private long usedMemory;  
  30.       
  31.     /** *//** 线程总数. */  
  32.     private int totalThread;  
  33.       
  34.     /** *//** cpu使用率. */  
  35.     private double cpuRatio;  
  36.   
  37.     public long getFreeMemory() {  
  38.         return freeMemory;  
  39.     }  
  40.   
  41.     public void setFreeMemory(long freeMemory) {  
  42.         this.freeMemory = freeMemory;  
  43.     }  
  44.   
  45.     public long getFreePhysicalMemorySize() {  
  46.         return freePhysicalMemorySize;  
  47.     }  
  48.   
  49.     public void setFreePhysicalMemorySize(long freePhysicalMemorySize) {  
  50.         this.freePhysicalMemorySize = freePhysicalMemorySize;  
  51.     }  
  52.   
  53.     public long getMaxMemory() {  
  54.         return maxMemory;  
  55.     }  
  56.   
  57.     public void setMaxMemory(long maxMemory) {  
  58.         this.maxMemory = maxMemory;  
  59.     }  
  60.   
  61.     public String getOsName() {  
  62.         return osName;  
  63.     }  
  64.   
  65.     public void setOsName(String osName) {  
  66.         this.osName = osName;  
  67.     }  
  68.   
  69.     public long getTotalMemory() {  
  70.         return totalMemory;  
  71.     }  
  72.   
  73.     public void setTotalMemory(long totalMemory) {  
  74.         this.totalMemory = totalMemory;  
  75.     }  
  76.   
  77.     public long getTotalMemorySize() {  
  78.         return totalMemorySize;  
  79.     }  
  80.   
  81.     public void setTotalMemorySize(long totalMemorySize) {  
  82.         this.totalMemorySize = totalMemorySize;  
  83.     }  
  84.   
  85.     public int getTotalThread() {  
  86.         return totalThread;  
  87.     }  
  88.   
  89.     public void setTotalThread(int totalThread) {  
  90.         this.totalThread = totalThread;  
  91.     }  
  92.   
  93.     public long getUsedMemory() {  
  94.         return usedMemory;  
  95.     }  
  96.   
  97.     public void setUsedMemory(long usedMemory) {  
  98.         this.usedMemory = usedMemory;  
  99.     }  
  100.   
  101.     public double getCpuRatio() {  
  102.         return cpuRatio;  
  103.     }  
  104.   
  105.     public void setCpuRatio(double cpuRatio) {  
  106.         this.cpuRatio = cpuRatio;  
  107.     }  
  108. }  

 

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

Java代码  收藏代码
  1. package com.amgkaka.performance;  
  2.   
  3. /** *//** 
  4.  * 获取系统信息的业务逻辑类接口. 
  5.  * @author amg * @version 1.0  
  6.  * Creation date: 2008-3-11 - 上午10:06:06 
  7.  */  
  8. public interface IMonitorService {  
  9.     /** *//** 
  10.      * 获得当前的监控对象. 
  11.      * @return 返回构造好的监控对象 
  12.      * @throws Exception 
  13.      * @author amgkaka 
  14.      * Creation date: 2008-4-25 - 上午10:45:08 
  15.      */  
  16.     public MonitorInfoBean getMonitorInfoBean() throws Exception;  
  17.   
  18. }  

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

Java代码  收藏代码
  1. package com.amgkaka.performance;  
  2.   
  3. import java.io.InputStreamReader;  
  4. import java.io.LineNumberReader;  
  5.   
  6. import sun.management.ManagementFactory;  
  7.   
  8. import com.sun.management.OperatingSystemMXBean;  
  9.   
  10. /** *//** 
  11.  * 获取系统信息的业务逻辑实现类. 
  12.  * @author amg * @version 1.0 Creation date: 2008-3-11 - 上午10:06:06 
  13.  */  
  14. public class MonitorServiceImpl implements IMonitorService {  
  15.     //可以设置长些，防止读到运行此次系统检查时的cpu占用率，就不准了  
  16.     private static final int CPUTIME = 5000;  
  17.   
  18.     private static final int PERCENT = 100;  
  19.   
  20.     private static final int FAULTLENGTH = 10;  
  21.   
  22.     /** *//** 
  23.      * 获得当前的监控对象. 
  24.      * @return 返回构造好的监控对象 
  25.      * @throws Exception 
  26.      * @author amg     * Creation date: 2008-4-25 - 上午10:45:08 
  27.      */  
  28.     public MonitorInfoBean getMonitorInfoBean() throws Exception {  
  29.         int kb = 1024;  
  30.           
  31.         // 可使用内存  
  32.         long totalMemory = Runtime.getRuntime().totalMemory() / kb;  
  33.         // 剩余内存  
  34.         long freeMemory = Runtime.getRuntime().freeMemory() / kb;  
  35.         // 最大可使用内存  
  36.         long maxMemory = Runtime.getRuntime().maxMemory() / kb;  
  37.   
  38.         OperatingSystemMXBean osmxb = (OperatingSystemMXBean) ManagementFactory  
  39.                 .getOperatingSystemMXBean();  
  40.   
  41.         // 操作系统  
  42.         String osName = System.getProperty("os.name");  
  43.         // 总的物理内存  
  44.         long totalMemorySize = osmxb.getTotalPhysicalMemorySize() / kb;  
  45.         // 剩余的物理内存  
  46.         long freePhysicalMemorySize = osmxb.getFreePhysicalMemorySize() / kb;  
  47.         // 已使用的物理内存  
  48.         long usedMemory = (osmxb.getTotalPhysicalMemorySize() - osmxb  
  49.                 .getFreePhysicalMemorySize())  
  50.                 / kb;  
  51.   
  52.         // 获得线程总数  
  53.         ThreadGroup parentThread;  
  54.         for (parentThread = Thread.currentThread().getThreadGroup(); parentThread  
  55.                 .getParent() != null; parentThread = parentThread.getParent())  
  56.             ;  
  57.         int totalThread = parentThread.activeCount();  
  58.   
  59.         double cpuRatio = 0;  
  60.         if (osName.toLowerCase().startsWith("windows")) {  
  61.             cpuRatio = this.getCpuRatioForWindows();  
  62.         }  
  63.           
  64.         // 构造返回对象  
  65.         MonitorInfoBean infoBean = new MonitorInfoBean();  
  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.         return infoBean;  
  76.     }  
  77.   
  78.     /** *//** 
  79.      * 获得CPU使用率. 
  80.      * @return 返回cpu使用率 
  81.      * @author amg     * Creation date: 2008-4-25 - 下午06:05:11 
  82.      */  
  83.     private double getCpuRatioForWindows() {  
  84.         try {  
  85.             String procCmd = System.getenv("windir")  
  86.                     + "\\system32\\wbem\\wmic.exe process get Caption,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.                 long idletime = c1[0] - c0[0];  
  94.                 long busytime = c1[1] - c0[1];  
  95.                 return Double.valueOf(  
  96.                         PERCENT * (busytime) / (busytime + idletime))  
  97.                         .doubleValue();  
  98.             } else {  
  99.                 return 0.0;  
  100.             }  
  101.         } catch (Exception ex) {  
  102.             ex.printStackTrace();  
  103.             return 0.0;  
  104.         }  
  105.     }  
  106.   
  107.     /** *//** 
  108.      * 读取CPU信息. 
  109.      * @param proc 
  110.      * @return 
  111.      * @author amg     * Creation date: 2008-4-25 - 下午06:10:14 
  112.      */  
  113.     private long[] readCpu(final Process proc) {  
  114.         long[] retn = new long[2];  
  115.         try {  
  116.             proc.getOutputStream().close();  
  117.             InputStreamReader ir = new InputStreamReader(proc.getInputStream());  
  118.             LineNumberReader input = new LineNumberReader(ir);  
  119.             String line = input.readLine();  
  120.             if (line == null || line.length() < FAULTLENGTH) {  
  121.                 return null;  
  122.             }  
  123.             int capidx = line.indexOf("Caption");  
  124.             int cmdidx = line.indexOf("CommandLine");  
  125.             int rocidx = line.indexOf("ReadOperationCount");  
  126.             int umtidx = line.indexOf("UserModeTime");  
  127.             int kmtidx = line.indexOf("KernelModeTime");  
  128.             int wocidx = line.indexOf("WriteOperationCount");  
  129.             long idletime = 0;  
  130.             long kneltime = 0;  
  131.             long usertime = 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.                 String caption = Bytes.substring(line, capidx, cmdidx - 1)  
  139.                         .trim();  
  140.                 String cmd = 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("System Idle Process")  
  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.             return retn;  
  166.         } catch (Exception ex) {  
  167.             ex.printStackTrace();  
  168.         } finally {  
  169.             try {  
  170.                 proc.getInputStream().close();  
  171.             } catch (Exception e) {  
  172.                 e.printStackTrace();  
  173.             }  
  174.         }  
  175.         return null;  
  176.     }  
  177.       
  178.     /** *//** 
  179.      * 测试方法. 
  180.      * @param args 
  181.      * @throws Exception 
  182.      * @author amg     * Creation date: 2008-4-30 - 下午04:47:29 
  183.      */  
  184.     public static void main(String[] args) throws Exception {  
  185.         IMonitorService service = new MonitorServiceImpl();  
  186.         MonitorInfoBean monitorInfo = 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的工具类，该类的代码如下所示：

Java代码  收藏代码
  1. package com.amgkaka.performance;  
  2.   
  3. /** *//** 
  4.  * byte操作类. 
  5.  * @author amg * @version 1.0  
  6.  * Creation date: 2008-4-30 - 下午04:57:23 
  7.  */  
  8. public class Bytes {  
  9.     /** *//** 
  10.      * 由于String.subString对汉字处理存在问题（把一个汉字视为一个字节)，因此在 
  11.      * 包含汉字的字符串时存在隐患，现调整如下： 
  12.      * @param src 要截取的字符串 
  13.      * @param start_idx 开始坐标（包括该坐标) 
  14.      * @param end_idx   截止坐标（包括该坐标） 
  15.      * @return 
  16.      */  
  17.     public static String substring(String src, int start_idx, int end_idx){  
  18.         byte[] b = src.getBytes();  
  19.         String tgt = "";  
  20.         for(int i=start_idx; i<=end_idx; i++){  
  21.             tgt +=(char)b[i];  
  22.         }  
  23.         return tgt;  
  24.     }  
  25. }  

 

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


posted @ 2013-11-08 17:12  cuker919  阅读(955)  评论(0)  编辑  收藏  举报