`

利用java程序实现获取计算机cpu利用率和内存状况

 
阅读更多

很多时候需要监控我们的程序，以随时知道程序运行状况、预警等


以下是网上某博客代码，特点是通过window和linux命令获得CPU使用率。

 

Java代码

利用java程序实现获取计算机cpu利用率和内存使用信息。

创建一个Bean用来存贮要得到的信

 

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

 之后，建立bean的接口

Java代码  收藏代码
  1. /** 
  2.  * @author yans 
  3.  * @date 2011-10-6 下午11:24:31 
  4.  * @description 
  5.  */  
  6. public interface IMonitorService {  
  7.     public MonitorInfoBean getMonitorInfoBean() throws Exception;  
  8. }  

 然后，就是最关键的，得到cpu的利用率，已用内存，可用内存，最大内存等信息。

 

 

Java代码  收藏代码
  1. import java.io.BufferedReader;  
  2. import java.io.File;  
  3. import java.io.IOException;  
  4. import java.io.InputStream;  
  5. import java.io.InputStreamReader;  
  6. import java.io.LineNumberReader;  
  7. import java.lang.management.ManagementFactory;  
  8. import java.util.StringTokenizer;  
  9.   
  10. import com.sun.management.OperatingSystemMXBean;  
  11.   
  12. /** 
  13.  * @author yans 
  14.  * @date 2011-10-6 下午11:24:58 
  15.  * @description 获取系统信息的业务逻辑实现类. 
  16.  */  
  17. public class MonitorServiceImpl implements IMonitorService {  
  18.   
  19.     private static final int CPUTIME = 30;  
  20.   
  21.     private static final int PERCENT = 100;  
  22.   
  23.     private static final int FAULTLENGTH = 10;  
  24.   
  25.     private static final File versionFile = new File("/proc/version");  
  26.     private static String linuxVersion = null;  
  27.   
  28.     /** 
  29.      * 获得当前的监控对象. 
  30.      *  
  31.      * @return 返回构造好的监控对象 
  32.      * @throws Exception 
  33.      * @author yans 
  34.      */  
  35.     public MonitorInfoBean getMonitorInfoBean() throws Exception {  
  36.         int kb = 1024;  
  37.   
  38.         // 可使用内存  
  39.         long totalMemory = Runtime.getRuntime().totalMemory() / kb;  
  40.         // 剩余内存  
  41.         long freeMemory = Runtime.getRuntime().freeMemory() / kb;  
  42.         // 最大可使用内存  
  43.         long maxMemory = Runtime.getRuntime().maxMemory() / kb;  
  44.   
  45.         OperatingSystemMXBean osmxb = (OperatingSystemMXBean) ManagementFactory  
  46.                 .getOperatingSystemMXBean();  
  47.   
  48.         // 操作系统  
  49.         String osName = System.getProperty("os.name");  
  50.         // 总的物理内存  
  51.         long totalMemorySize = osmxb.getTotalPhysicalMemorySize() / kb;  
  52.         // 剩余的物理内存  
  53.         long freePhysicalMemorySize = osmxb.getFreePhysicalMemorySize() / kb;  
  54.         // 已使用的物理内存  
  55.         long usedMemory = (osmxb.getTotalPhysicalMemorySize() - osmxb  
  56.                 .getFreePhysicalMemorySize())  
  57.                 / kb;  
  58.   
  59.         // 获得线程总数  
  60.         ThreadGroup parentThread;  
  61.         for (parentThread = Thread.currentThread().getThreadGroup(); parentThread  
  62.                 .getParent() != null; parentThread = parentThread.getParent())  
  63.             ;  
  64.         int totalThread = parentThread.activeCount();  
  65.   
  66.         double cpuRatio = 0;  
  67.         if (osName.toLowerCase().startsWith("windows")) {  
  68.             cpuRatio = this.getCpuRatioForWindows();  
  69.         } else {  
  70.             cpuRatio = this.getCpuRateForLinux();  
  71.         }  
  72.   
  73.         // 构造返回对象  
  74.         MonitorInfoBean infoBean = new MonitorInfoBean();  
  75.         infoBean.setFreeMemory(freeMemory);  
  76.         infoBean.setFreePhysicalMemorySize(freePhysicalMemorySize);  
  77.         infoBean.setMaxMemory(maxMemory);  
  78.         infoBean.setOsName(osName);  
  79.         infoBean.setTotalMemory(totalMemory);  
  80.         infoBean.setTotalMemorySize(totalMemorySize);  
  81.         infoBean.setTotalThread(totalThread);  
  82.         infoBean.setUsedMemory(usedMemory);  
  83.         infoBean.setCpuRatio(cpuRatio);  
  84.         return infoBean;  
  85.     }  
  86.   
  87.     private static double getCpuRateForLinux() {  
  88.         InputStream is = null;  
  89.         InputStreamReader isr = null;  
  90.         BufferedReader brStat = null;  
  91.         StringTokenizer tokenStat = null;  
  92.         try {  
  93.             System.out.println("Get usage rate of CUP , linux version: "  
  94.                     + linuxVersion);  
  95.   
  96.             Process process = Runtime.getRuntime().exec("top -b -n 1");  
  97.             is = process.getInputStream();  
  98.             isr = new InputStreamReader(is);  
  99.             brStat = new BufferedReader(isr);  
  100.   
  101.             if (linuxVersion.equals("2.4")) {  
  102.                 brStat.readLine();  
  103.                 brStat.readLine();  
  104.                 brStat.readLine();  
  105.                 brStat.readLine();  
  106.   
  107.                 tokenStat = new StringTokenizer(brStat.readLine());  
  108.                 tokenStat.nextToken();  
  109.                 tokenStat.nextToken();  
  110.                 String user = tokenStat.nextToken();  
  111.                 tokenStat.nextToken();  
  112.                 String system = tokenStat.nextToken();  
  113.                 tokenStat.nextToken();  
  114.                 String nice = tokenStat.nextToken();  
  115.   
  116.                 System.out.println(user + " , " + system + " , " + nice);  
  117.   
  118.                 user = user.substring(0, user.indexOf("%"));  
  119.                 system = system.substring(0, system.indexOf("%"));  
  120.                 nice = nice.substring(0, nice.indexOf("%"));  
  121.   
  122.                 float userUsage = new Float(user).floatValue();  
  123.                 float systemUsage = new Float(system).floatValue();  
  124.                 float niceUsage = new Float(nice).floatValue();  
  125.   
  126.                 return (userUsage + systemUsage + niceUsage) / 100;  
  127.             } else {  
  128.                 brStat.readLine();  
  129.                 brStat.readLine();  
  130.   
  131.                 tokenStat = new StringTokenizer(brStat.readLine());  
  132.                 tokenStat.nextToken();  
  133.                 tokenStat.nextToken();  
  134.                 tokenStat.nextToken();  
  135.                 tokenStat.nextToken();  
  136.                 tokenStat.nextToken();  
  137.                 tokenStat.nextToken();  
  138.                 tokenStat.nextToken();  
  139.                 String cpuUsage = tokenStat.nextToken();  
  140.   
  141.                 System.out.println("CPU idle : " + cpuUsage);  
  142.                 Float usage = new Float(cpuUsage.substring(0, cpuUsage  
  143.                         .indexOf("%")));  
  144.   
  145.                 return (1 - usage.floatValue() / 100);  
  146.             }  
  147.   
  148.         } catch (IOException ioe) {  
  149.             System.out.println(ioe.getMessage());  
  150.             freeResource(is, isr, brStat);  
  151.             return 1;  
  152.         } finally {  
  153.             freeResource(is, isr, brStat);  
  154.         }  
  155.   
  156.     }  
  157.   
  158.     private static void freeResource(InputStream is, InputStreamReader isr,  
  159.             BufferedReader br) {  
  160.         try {  
  161.             if (is != null)  
  162.                 is.close();  
  163.             if (isr != null)  
  164.                 isr.close();  
  165.             if (br != null)  
  166.                 br.close();  
  167.         } catch (IOException ioe) {  
  168.             System.out.println(ioe.getMessage());  
  169.         }  
  170.     }  
  171.   
  172.     /** 
  173.      * 获得CPU使用率. 
  174.      *  
  175.      * @return 返回cpu使用率 
  176.      * @author yans 
  177.      */  
  178.     private double getCpuRatioForWindows() {  
  179.         try {  
  180.             String procCmd = System.getenv("windir")  
  181.                     + "\\system32\\wbem\\wmic.exe process get Caption,CommandLine,"  
  182.                     + "KernelModeTime,ReadOperationCount,ThreadCount,UserModeTime,WriteOperationCount";  
  183.             // 取进程信息  
  184.             long[] c0 = readCpu(Runtime.getRuntime().exec(procCmd));  
  185.             Thread.sleep(CPUTIME);  
  186.             long[] c1 = readCpu(Runtime.getRuntime().exec(procCmd));  
  187.             if (c0 != null && c1 != null) {  
  188.                 long idletime = c1[0] - c0[0];  
  189.                 long busytime = c1[1] - c0[1];  
  190.                 return Double.valueOf(  
  191.                         PERCENT * (busytime) / (busytime + idletime))  
  192.                         .doubleValue();  
  193.             } else {  
  194.                 return 0.0;  
  195.             }  
  196.         } catch (Exception ex) {  
  197.             ex.printStackTrace();  
  198.             return 0.0;  
  199.         }  
  200.     }  
  201.   
  202.     /** 
  203.      *  
  204.      * 读取CPU信息. 
  205.      *  
  206.      * @param proc 
  207.      * @return 
  208.      * @author yans 
  209.      */  
  210.     private long[] readCpu(final Process proc) {  
  211.         long[] retn = new long[2];  
  212.         try {  
  213.             proc.getOutputStream().close();  
  214.             InputStreamReader ir = new InputStreamReader(proc.getInputStream());  
  215.             LineNumberReader input = new LineNumberReader(ir);  
  216.             String line = input.readLine();  
  217.             if (line == null || line.length() < FAULTLENGTH) {  
  218.                 return null;  
  219.             }  
  220.             int capidx = line.indexOf("Caption");  
  221.             int cmdidx = line.indexOf("CommandLine");  
  222.             int rocidx = line.indexOf("ReadOperationCount");  
  223.             int umtidx = line.indexOf("UserModeTime");  
  224.             int kmtidx = line.indexOf("KernelModeTime");  
  225.             int wocidx = line.indexOf("WriteOperationCount");  
  226.             long idletime = 0;  
  227.             long kneltime = 0;  
  228.             long usertime = 0;  
  229.             while ((line = input.readLine()) != null) {  
  230.                 if (line.length() < wocidx) {  
  231.                     continue;  
  232.                 }  
  233.                 // 字段出现顺序：Caption,CommandLine,KernelModeTime,ReadOperationCount,  
  234.                 // ThreadCount,UserModeTime,WriteOperation  
  235.                 String caption = Bytes.substring(line, capidx, cmdidx - 1)  
  236.                         .trim();  
  237.                 String cmd = Bytes.substring(line, cmdidx, kmtidx - 1).trim();  
  238.                 if (cmd.indexOf("wmic.exe") >= 0) {  
  239.                     continue;  
  240.                 }  
  241.                 // log.info("line="+line);  
  242.                 if (caption.equals("System Idle Process")  
  243.                         || caption.equals("System")) {  
  244.                     idletime += Long.valueOf(  
  245.                             Bytes.substring(line, kmtidx, rocidx - 1).trim())  
  246.                             .longValue();  
  247.                     idletime += Long.valueOf(  
  248.                             Bytes.substring(line, umtidx, wocidx - 1).trim())  
  249.                             .longValue();  
  250.                     continue;  
  251.                 }  
  252.   
  253.                 kneltime += Long.valueOf(  
  254.                         Bytes.substring(line, kmtidx, rocidx - 1).trim())  
  255.                         .longValue();  
  256.                 usertime += Long.valueOf(  
  257.                         Bytes.substring(line, umtidx, wocidx - 1).trim())  
  258.                         .longValue();  
  259.             }  
  260.             retn[0] = idletime;  
  261.             retn[1] = kneltime + usertime;  
  262.             return retn;  
  263.         } catch (Exception ex) {  
  264.             ex.printStackTrace();  
  265.         } finally {  
  266.             try {  
  267.                 proc.getInputStream().close();  
  268.             } catch (Exception e) {  
  269.                 e.printStackTrace();  
  270.             }  
  271.         }  
  272.         return null;  
  273.     }  
  274.   
  275.     /** 
  276.      * 测试方法. 
  277.      *  
  278.      * @param args 
  279.      * @throws Exception 
  280.      * @author yans 
  281.      */  
  282.     public static void main(String[] args) throws Exception {  
  283.         IMonitorService service = new MonitorServiceImpl();  
  284.         MonitorInfoBean monitorInfo = service.getMonitorInfoBean();  
  285.         System.out.println("cpu占有率=" + monitorInfo.getCpuRatio());  
  286.   
  287.         System.out.println("可使用内存=" + monitorInfo.getTotalMemory());  
  288.         System.out.println("剩余内存=" + monitorInfo.getFreeMemory());  
  289.         System.out.println("最大可使用内存=" + monitorInfo.getMaxMemory());  
  290.   
  291.         System.out.println("操作系统=" + monitorInfo.getOsName());  
  292.         System.out.println("总的物理内存=" + monitorInfo.getTotalMemorySize() + "kb");  
  293.         System.out.println("剩余的物理内存=" + monitorInfo.getFreeMemory() + "kb");  
  294.         System.out.println("已使用的物理内存=" + monitorInfo.getUsedMemory() + "kb");  
  295.         System.out.println("线程总数=" + monitorInfo.getTotalThread() + "kb");  
  296.     }  
  297. }  

 

其中，Bytes类用来处理字符串

Java代码  收藏代码
  1. /** 
  2.  * @author yans 
  3.  * @date 2011-10-6 下午11:26:01 
  4.  * @description 
  5.  */  
  6. public class Bytes {  
  7.     public static String substring(String src, int start_idx, int end_idx) {  
  8.         byte[] b = src.getBytes();  
  9.         String tgt = "";  
  10.         for (int i = start_idx; i <= end_idx; i++) {  
  11.             tgt += (char) b[i];  
  12.         }  
  13.         return tgt;  
  14.     }  
  15. }  
分享到：
| 基于Thrift协议的C#客户端
评论
发表评论

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

相关推荐

    Java获取计算机CPU、内存等信息

    在Java编程中，获取计算机的硬件信息，如CPU使用率和内存使用情况，是一项常见的需求。这主要应用于系统监控、性能分析以及资源管理等方面。Java虽然不像C++或C#那样可以直接调用操作系统API，但它提供了Java ...

    获取cpu使用率和内存使用情况

    在IT领域，实时监控系统资源，尤其是CPU使用率和内存使用情况，对于开发者和系统管理员来说至关重要。这有助于诊断性能瓶颈、优化代码以及确保系统的稳定运行。以下是对标题和描述中涉及的知识点的详细说明： 1. **...

    java获得CPU使用率.doc

    通过上述步骤，我们可以在不使用JNI的情况下，利用Java语言本身的能力获取到系统的CPU使用率及内存使用情况。这种方式不仅简单高效，而且对于开发者的技能要求相对较低，非常适合用于日常的应用程序监控场景。需要...

    WMI获取远程服务器CPU,内存使用率函数源代码

    本文将深入探讨如何利用C#编程语言，通过WMI来获取远程服务器的CPU和内存使用率，以解决Win32_LogicalMemoryConfiguration类可能存在的问题。 首先，我们要了解WMI的工作原理。WMI是基于Common Information Model ...

    获取计算机cpu等信息的jar包.rar

    "获取计算机CPU等信息的jar包.rar"是一个包含SIGAR（System Information Gatherer and Reporter）库的压缩文件，它提供了获取服务器CPU、内存等系统资源信息的工具。SIGAR是由Hypertable项目开发并维护的一个跨平台...

    CPU内存参数监控程序

    CPU利用率是指CPU在一段时间内处于忙碌状态的比例，高利用率可能意味着系统负载过重。负载则是指系统在特定时间内处理的任务数量，如果负载过高，可能导致响应速度变慢。上下文切换是指CPU在不同进程间切换，频繁的...

    java检测程序系统

    Java监控程序系统是一个用于检测计算机系统资源使用情况的工具，它主要关注CPU、内存以及网络接口的性能指标。这个系统基于Java编程语言开发，因此具有跨平台的优势，可以在任何安装了Java环境的系统上运行。在...

    使用Java进行SNMP编程-SNMP4J-代码实例

    通过这些基础知识点的学习，网络管理员可以利用Java语言和SNMP4J库完成服务器监控的工作，比如监控服务器的CPU负载、内存使用情况、磁盘空间以及各种网络接口的状态等。这对于维护服务器的稳定运行和及时发现网络...

    cpu-use_CPU使用率_源码

    在IT领域，CPU使用率是衡量计算机性能的重要指标之一，特别是在服务器管理和系统优化的过程中。本文将深入探讨如何在Windows操作系统中计算每个CPU的核心使用率，以及这个知识点在实际应用中的重要性。 首先，CPU...

    测试缓存和内存使用的小程序

    在IT行业中，缓存和内存管理是至关重要的技术领域，特别是在优化系统性能和资源利用率时。这个名为"测试缓存和内存使用的小程序"的项目提供了深入理解这些概念的实践平台。下面，我们将详细探讨缓存和内存使用，以及...

    基于Java的CPU资源管理器程序源码.rar

    - **数据采集**：程序可能通过Java系统管理接口收集CPU利用率、系统负载等数据。 - **数据处理**：收集到的数据需要进行处理，例如计算平均值、百分比等。 - **图形用户界面（GUI）**：为了直观展示CPU使用情况，...

    Java设计的桌面程序

    6. **系统API调用**: 为了获取PC的监控信息，程序可能需要调用操作系统提供的API，如CPU使用率、内存使用情况、网络状态等。Java的`java.lang.management`包提供了管理接口，允许程序获取和操作JVM及系统的相关信息...

    Java编写的windows任务管理器

    【Java编写的Windows任务管理器】是一款利用Java编程语言实现的、模仿Windows操作系统自带任务管理器功能的应用程序。它提供了一个用户界面，可以查看和管理运行在计算机上的进程，包括查看进程状态、CPU使用率、...

    CPU-Info.rar_cpu_java 硬件

    在硬件信息获取方面，Java提供了一些库和API，例如Java Management Extensions (JMX) 和 sun.misc包，这些可以帮助开发者获取CPU使用率、内存使用情况等硬件信息。通过这些工具，用户可以监控系统的健康状况，分析...

    C#实时监控硬件信息

    - GPU占用率：NVIDIA和AMD提供了各自的SDK，如NVIDIA的NVAPI和AMD的AMDKMT，可以获取GPU利用率信息。对于非专业开发者，也可以使用WMI（Windows Management Instrumentation）查询GPU状态。 3. **风扇转速监控**：...

    查看CUP、内存、硬盘使用情况

    通过Sigar，我们可以获取每个CPU核心的使用时间，以及整体的CPU利用率。此外，还可以监控进程级别的CPU使用，找出消耗CPU资源最多的进程。 2. **内存使用情况**：内存是计算机临时存储数据的地方，内存使用情况直接...

    获取内存使用状态的资源

    内存是计算机执行程序时临时存储数据的重要组件，掌握内存使用状态有助于我们诊断系统性能问题，优化程序运行效率，以及合理分配和管理资源。本文将详细探讨如何获取内存使用状态，并提供多种方法和技术。 首先，...

    监视cpu使用情况

    例如，在Python中，可以使用psutil库来获取当前进程或所有进程的CPU利用率；在Java中，可以使用ManagementFactory类获取JVM的CPU使用情况。 总之，监视CPU使用情况是系统运维和开发中的常规操作，通过多种工具和...

    面向对象程序设计

    （1）cpu 的利用率 （2）内存的可用空间，公共的大小（包括物流内存和虚拟内存） （3）当前进程数。 （4）该系统还应当获取当前的时间和日期从而可以统计出自开机以来上面几个检测分量出现的最大值和最小值。 ...

    java通过sigar开源jar包

    Java通过Sigar开源Jar包获取计算机信息是一种常见的系统监控和管理技术。Sigar（System Information Gatherer and Reporter）是由Hyperic公司开发的一个跨平台、跨语言的库，用于获取操作系统和网络设备的各种性能...

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