`
wbj0110
  • 浏览: 1611437 次
  • 性别: Icon_minigender_1
  • 来自: 上海
文章分类
社区版块
存档分类
最新评论

java获得CPU使用率,内存使用率

    博客分类:
  • Java
阅读更多

 

 

linux下Cpu获取方式之一:

  1、从/proc文件系统获取相关的性能参数
    cpu使用率:    /proc/stat
    内存使用情况:      /proc/meminfo
    网络负载信息:    /proc/net/dev

相应的计算方法:(摘自:什么是proc文件系统,见参考资料)
    (1)   处理器使用率    
    (2)   内存使用率    
    (3)   流入流出数据包    
    (4)   整体网络负载    
     这些数据分别要从/proc/stat、/proc/net/dev、/proc/meminfo三个文件中提取。如里有问题或对要提取的数据不太清楚,可以使用man   proc来查看proc文件系统的联机手册。   
    (1)   处理器使用率    
    这里要从/proc/stat中提取四个数据:用户模式(user)、低优先级的用户模式(nice)、内核模式(system)以及空闲的处理器时间(idle)。它们均位于/proc/stat文件的第一行。CPU的利用率使用如下公式来计算。   
    CPU利用率   =   100   *(user   +   nice   +   system)/(user   +   nice   +   system   +   idle)   
   (2)   内存使用率    
    这里需要从/proc/meminfo文件中提取两个数据,当前内存的使用量(cmem)以及内存总量(amem)。    
    内存使用百分比   =   100   *   (cmem   /   umem)    
    (3)网络利用率    
    为了得到网络利用率的相关数据,需要从/proc/net/dev文件中获得两个数据:从本机输出的数据包数,流入本机的数据包数。它们都位于这个文件的第四行。   
    性能收集程序开始记录下这两个数据的初始值,以后每次获得这个值后均减去这个初始值即为从集群启动开始从本节点通过的数据包。    
    利用上述数据计算出网络的平均负载,方法如下:    
    平均网络负载   =   (输出的数据包+流入的数据包)   /   2
2. 通过/proc文件系统调整相关的内核配置
    允许ip转发   /proc/sys/net/ipv4/ip_forward
    禁止ping    /proc/sys/net/ipv4/icmp_echo_ignore_all
    
    可以在命令行下直接往上述两个“文件”里头写入"1"来实现相关配置,如果写入"0"将取消相关配置。不过在系统重启以后,这些配置将恢复默认设置,所以,如果想让这些修改生效,可以把下面的配置直接写入/etc/profile文件,或者其他随系统启动而执行的程序文件中。
  
echo 1 > /proc/sys/net/ipv4/ip_forward
echo 1 > /proc/sys/net/ipv4/icmp_echo_ignore_all

 

 

这里计算cpu使用率是有问题的,需要使用上一状态的值来计算

正确的计算方法是,等上一个时间:

1、记录某个时刻cpu的使用情况
2、等上一个时间段
3、再记录此刻的cpu使用情况
4、计算总的时间片
把第一次的所有cpu使用情况求和,得到j1
把第二次的所有cpu使用情况求和,得到j2
j2-j1得到这个时间段的所有时间片
即total=j2-j1=第二次的所有列的和-第一次的所有列的和
5、计算idle时间
idle对应第五列的数据,用第二次的减去第一次的即可
idle=第二次的第五列-第一次的第五列
6、计算cpu使用率
rate=(total-idle)/total

 

 

在Linux/Unix下,CPU利用率分为用户态 ,系统态 和空闲态 ,分别表示CPU处于用户态执行的时间,系统内核执行的时间,和空闲系统进程执行的时间。平时所说的CPU利用率是指:CPU执行非系统空闲进程的时间 / CPU总的执行时间 。

 

 

实例源码

 

 

case class ResMonitorInfo(
                           @transient var totalMemory: Long,
                           @transient var freeMemory: Long,
                           @transient var maxMemory: Long,
                           @transient var osName: String,
                           @transient var totalMemorySize: Long,
                           @transient var freePhysicalMemorySize: Long,
                           @transient var usedMemory: Long,
                           @transient var totalThread: Int,
                           var memUsageRatio: Double,
                           var cpuUsageRatio: Double
                         ) extends ResourseInfo {

  override def toString: String = ToStringBuilder.reflectionToString(this, ToStringStyle.MULTI_LINE_STYLE)
}

object ResMonitorInfo extends Logging {
  val crawlerUrlRegex = "Linux version (\\d.\\d).[\\w\\W]*".r

  def getLinuxVersion(input: String): String = {
    input match {
      case crawlerUrlRegex(vesrion) => vesrion
      case _ =>
        logError("Invalid linux version info!")
        ""
    }
  }
}

 

 

 

package com.soledede.cloud.resource;

import java.io.*;
import java.lang.management.ManagementFactory;
import java.util.StringTokenizer;

import com.soledede.cloud.util.JavaLogging;
import com.sun.management.OperatingSystemMXBean;
import org.slf4j.Logger;

/**
 * Created by soledede.weng on 2016/6/2.
 * <p>
 * ResourseTool
 * cpu used , memeory used info
 */
public class ResourseTool {

    private static Logger log = null;

    private static long lastIdleCpuTime = 0;
    private static long lastTotalCpuTime = 0;

    private static String osName = System.getProperty("os.name");

    private static int cpuCores = Runtime.getRuntime().availableProcessors();


    private static final int CPUTIME = 30;


    private static final int FAULTLENGTH = 10;

    private static String linuxVersion = null;


    static {
        log = JavaLogging.log();
        Process process = null;
        InputStream is = null;
        InputStreamReader isr = null;
        BufferedReader brStat = null;
        try {
            process = Runtime.getRuntime().exec("cat /proc/version");
            is = process.getInputStream();
            isr = new InputStreamReader(is);
            brStat = new BufferedReader(isr);
            linuxVersion = ResMonitorInfo.getLinuxVersion(brStat.readLine());
        } catch (IOException e) {
            linuxVersion = "";
        } finally {
            freeResource(is, isr, brStat);
        }

    }


    public static ResMonitorInfo getResMonitorInfo() {


        int kb = 1024;

        // Available memory
        long totalMemory = Runtime.getRuntime().totalMemory() / kb;
        // Free memory
        long freeMemory = Runtime.getRuntime().freeMemory() / kb;
        // Maximal available memory
        long maxMemory = Runtime.getRuntime().maxMemory() / kb;

        OperatingSystemMXBean osmxb = (OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();

        // Operating system (OS)
        String osName = System.getProperty("os.name");
        // Total physical memory
        long totalMemorySize = osmxb.getTotalPhysicalMemorySize() / kb;
        // Free physical memory
        long freePhysicalMemorySize = osmxb.getFreePhysicalMemorySize() / kb;
        // Usage physical memory
        long usedMemory = (osmxb.getTotalPhysicalMemorySize() - osmxb
                .getFreePhysicalMemorySize())
                / kb;
        double memRatio = (double) usedMemory / (double) totalMemorySize;

        // Total thread active counts
        ThreadGroup parentThread;
        int totalThread = 0;
        double cpuRatio = 0;
        try {
            for (parentThread = Thread.currentThread().getThreadGroup(); parentThread.getParent() != null; parentThread = parentThread.getParent())
                ;
            totalThread = parentThread.activeCount();


            if (osName.toLowerCase().startsWith("windows")) {
                cpuRatio = getCpuRatioForWindows();
            } else {
                cpuRatio = getCpuRateForLinux();
            }

        } catch (Exception e) {
            log.error("read cpu or memory info failed!", e.getCause());
        }
        return new ResMonitorInfo(totalMemory, freeMemory, maxMemory,
                osName, totalMemorySize, freePhysicalMemorySize, usedMemory,
                totalThread, memRatio, cpuRatio
        );
    }

    private static double getCpuRateForLinux() {
        InputStream is = null;
        InputStreamReader isr = null;
        BufferedReader brStat = null;
        StringTokenizer tokenStat = null;
        try {
            System.out.println("Get usage rate of CUP , linux version: " + linuxVersion);

            Process process = Runtime.getRuntime().exec("top -b -n 1");
            is = process.getInputStream();
            isr = new InputStreamReader(is);
            brStat = new BufferedReader(isr);

            if (linuxVersion.equals("2.4")) {
                brStat.readLine();
                brStat.readLine();
                brStat.readLine();
                brStat.readLine();

                tokenStat = new StringTokenizer(brStat.readLine());
                tokenStat.nextToken();
                tokenStat.nextToken();
                String user = tokenStat.nextToken();
                tokenStat.nextToken();
                String system = tokenStat.nextToken();
                tokenStat.nextToken();
                String nice = tokenStat.nextToken();

                System.out.println(user + " , " + system + " , " + nice);

                user = user.substring(0, user.indexOf("%"));
                system = system.substring(0, system.indexOf("%"));
                nice = nice.substring(0, nice.indexOf("%"));

                float userUsage = Float.parseFloat(user);
                float systemUsage = Float.parseFloat(system);
                float niceUsage = Float.parseFloat(nice);

                return (userUsage + systemUsage + niceUsage) / 100;
            } else {
                brStat.readLine();
                brStat.readLine();

                tokenStat = new StringTokenizer(brStat.readLine());
                tokenStat.nextToken();
                tokenStat.nextToken();
                tokenStat.nextToken();
                tokenStat.nextToken();
                tokenStat.nextToken();
                tokenStat.nextToken();
                tokenStat.nextToken();
                String cpuIdle = tokenStat.nextToken();


                System.out.println("CPU idle : " + cpuIdle);
                Float idle = new Float(cpuIdle.substring(0, cpuIdle.indexOf("%")));

                return (1 - idle / 100);
            }
        } catch (IOException ioe) {
            System.out.println(ioe.getMessage());
            freeResource(is, isr, brStat);
            return 1;
        } finally {
            freeResource(is, isr, brStat);
        }
    }

    private static void freeResource(InputStream is, InputStreamReader isr, BufferedReader br) {
        try {
            if (is != null)
                is.close();
            if (isr != null)
                isr.close();
            if (br != null)
                br.close();
        } catch (IOException ioe) {
            log.error("close stream failed!", ioe.getMessage());
        }
    }


    /**
     * Get cpu ratio.
     *
     * @return
     */
    private static double getCpuRatioForWindows() {
        try {
            String procCmd = System.getenv("windir")
                    + "\\system32\\wbem\\wmic.exe process get Caption,CommandLine,"
                    + "KernelModeTime,ReadOperationCount,ThreadCount,UserModeTime,WriteOperationCount";
            long[] c0 = readCpu(Runtime.getRuntime().exec(procCmd));
            Thread.sleep(CPUTIME);
            long[] c1 = readCpu(Runtime.getRuntime().exec(procCmd));
            if (c0 != null && c1 != null) {
                long idletime = c1[0] - c0[0];
                long busytime = c1[1] - c0[1];
                return (double) (busytime) / (double) (busytime + idletime);
            } else {
                return 0.0;
            }
        } catch (Exception ex) {
            ex.printStackTrace();
            return 0.0;
        }
    }

    /**
     * @return cpu rate
     */
    private static long[] readCpu(final Process proc) {
        long[] retn = new long[2];
        try {
            proc.getOutputStream().close();
            InputStreamReader ir = new InputStreamReader(proc.getInputStream());
            LineNumberReader input = new LineNumberReader(ir);
            String line = input.readLine();
            if (line == null || line.length() <= FAULTLENGTH) {
                return null;
            }
            int capidx = line.indexOf("Caption");
            int cmdidx = line.indexOf("CommandLine");
            int rocidx = line.indexOf("ReadOperationCount");
            int umtidx = line.indexOf("UserModeTime");
            int kmtidx = line.indexOf("KernelModeTime");
            int wocidx = line.indexOf("WriteOperationCount");
            long idletime = 0;
            long kneltime = 0;
            long usertime = 0;
            while ((line = input.readLine()) != null) {
                if (line.length() < wocidx) {
                    continue;
                }
                // Order field:Caption,CommandLine,KernelModeTime,ReadOperationCount,
                // ThreadCount,UserModeTime,WriteOperation
                String caption = Bytes.substring(line, capidx, cmdidx - 1)
                        .trim();
                String cmd = Bytes.substring(line, cmdidx, kmtidx - 1).trim();
                if (cmd.contains("wmic.exe")) {
                    continue;
                }
                if (caption.equals("System Idle Process") || caption.equals("System")) {
                    String idl = Bytes.substring(line, kmtidx, rocidx - 1).trim();
                    String id2 = Bytes.substring(line, umtidx, wocidx - 1).trim();
                    if (isNumeric(idl))
                        idletime += Long.valueOf(idl);
                    if (isNumeric(id2))
                        idletime += Long.valueOf(id2);
                    continue;
                }

                String knel1 = Bytes.substring(line, kmtidx, rocidx - 1).trim();
                String knel2 = Bytes.substring(line, umtidx, wocidx - 1).trim();
                if (isNumeric(knel1))
                    kneltime += Long.valueOf(knel1);
                if (isNumeric(knel2))
                    usertime += Long.valueOf(knel2);
            }
            retn[0] = idletime;
            retn[1] = kneltime + usertime;
            return retn;
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            try {
                proc.getInputStream().close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    public static MemoryInfo getMemInfo() throws IOException,
            InterruptedException {
        MemoryInfo memInfo = new MemoryInfo();
        if (!osName.toLowerCase().startsWith("windows")) {
            long totalMem = 0;
            long freeMem = 0;


            Process pro = null;
            Runtime r = Runtime.getRuntime();

            String command = "cat /proc/meminfo";
            pro = r.exec(command);

            int count = 0;
            BufferedReader br = new BufferedReader(new InputStreamReader(
                    pro.getInputStream()));
            String line = null;
            while ((line = br.readLine()) != null) {
                String[] memInfos = line.split("\\s+");
                if (memInfos[0].toLowerCase().startsWith("MemTotal".toLowerCase())) {
                    totalMem = Long.valueOf(memInfos[1]).longValue();
                    memInfo.memTotal_$eq(totalMem);
                    count++;
                } else if (memInfos[0].toLowerCase().startsWith(
                        "MemFree".toLowerCase())) {
                    freeMem = Long.valueOf(memInfos[1]).longValue();
                    memInfo.memFree_$eq(freeMem);
                    count++;
                } else if (memInfos[0].toLowerCase().startsWith(
                        "SwapTotal".toLowerCase())) {
                    memInfo.swapFree_$eq(Long.valueOf(memInfos[1]).longValue());
                    count++;
                } else if (memInfos[0].toLowerCase().startsWith(
                        "SwapFree".toLowerCase())) {
                    memInfo.swapFree_$eq(Long.valueOf(memInfos[1]).longValue());
                    count++;
                }
                if (count == 4) {
                    memInfo.memUsage_$eq(1 - (double) freeMem
                            / (double) totalMem);
                    break;
                }

            }
        }
        return memInfo;

    }

    public static CpuInfo getCpuInfo() throws IOException, InterruptedException,
            RuntimeException {
        if (osName.toLowerCase().startsWith("windows")) return new CpuInfo(ResourseTool.cpuCores, 0.0);
        long[] l = getCpuInfoFromLinux();
        if (l == null)
            throw new RuntimeException();
        if (lastIdleCpuTime == 0 || lastTotalCpuTime == 0) {// first fetch
            lastIdleCpuTime = l[0];
            lastTotalCpuTime = l[1];
            Thread.sleep(1000);
            l = getCpuInfoFromLinux();
        }
        /*CpuInfo cpuInfo = new CpuInfo(ResourseTool.cpuCores, (double) 1 - (l[0] - lastIdleCpuTime)
                / (double) (l[1] - lastTotalCpuTime));*/
        double cpuTotal = l[1] - lastTotalCpuTime;
        double cpuIdle = l[0] - lastIdleCpuTime;
        double cpuUsageRate = (cpuTotal - cpuIdle) / cpuTotal;
        CpuInfo cpuInfo = new CpuInfo(ResourseTool.cpuCores, cpuUsageRate);
        lastIdleCpuTime = l[0];
        lastTotalCpuTime = l[1];
        return cpuInfo;
    }


    private static long[] getCpuInfoFromLinux() throws IOException {
        long[] l = new long[2];
        Process pro;
        Runtime r = Runtime.getRuntime();
        String command = "cat /proc/stat";
        pro = r.exec(command);
        BufferedReader in = new BufferedReader(new InputStreamReader(
                pro.getInputStream()));
        String line = null;
        long idleCpuTime = 0, totalCpuTime = 0;
        while ((line = in.readLine()) != null) {
            if (line.toLowerCase().startsWith("cpu")) {
                line = line.trim();
                String[] temp = line.split("\\s+");
                idleCpuTime += Long.valueOf(temp[4]).longValue();
                for (int i = 0; i < temp.length; i++) {
                    if (!temp[i].toLowerCase().startsWith("cpu")) {
                        totalCpuTime += Long.valueOf(temp[i]).longValue();
                    }
                }
            } else if (idleCpuTime != 0L && totalCpuTime != 0L) {
                l[0] = idleCpuTime;
                l[1] = totalCpuTime;
                break;
            }
        }
        in.close();
        pro.destroy();
        return l;
    }

    public static boolean isNumeric(String str) {
        if (str == null || str.equalsIgnoreCase("")) return false;
        for (int i = str.length(); --i >= 0; ) {
            if (!Character.isDigit(str.charAt(i))) {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        //System.out.println(System.getProperty("os.name"));
        // System.out.println(cpuCores);
        ResMonitorInfo monitorInfo = ResourseTool.getResMonitorInfo();
        System.out.print(monitorInfo.toString());
    }

    public static void testssss() {
        System.out.println("come in....");
    }

    public static String testS() {
        return "what's";
    }
}

 

 

 

 

/**
 * Created by soledede.weng on 2016/6/14.
 */
public class Bytes {
    public static String substring(String src, int start_idx, int end_idx) {
        byte[] b = src.getBytes();
        String tgt = "";
        for (int i = start_idx; i <= end_idx; i++) {
            tgt += (char) b[i];
        }
        return tgt;
    }
}

 

 

 

 

 

 

分享到:
评论

相关推荐

    java获得CPU使用率.doc

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

    java管理windows系统内存_java释放内存缓存_java获得CPU使用率_系统内存_硬盘_进程源代码

    "java管理windows系统内存_java释放内存缓存_java获得CPU使用率_系统内存_硬盘_进程源代码" 在Windows操作系统中,内存管理是一个非常重要的方面。Windows实现按需调页的虚拟内存机制,使得应用程序可以使用超过...

    java获得CPU使用率,系统内存,虚拟机内存等情况工具类

    通过jmx可以监控vm内存使用,系统内存使用等 ,特点是通过window和linux命令获得CPU使用率。

    android 获取cpu使用率, 内存 实时数据

    在Android平台上,获取CPU使用率和内存实时数据是开发者进行性能监控、优化应用或实现系统监控功能的关键步骤。本文将详细介绍如何在Android中获取这些关键信息,并提供相关的代码示例。 首先,我们要理解CPU使用率...

    java获取计算机cpu利用率和内存使用

    java 获取计算机cpu利用率和内存使用信息,需要的自己下载测试吧。

    java 绘制CPU使用率图形 源代码

    在Java编程语言中,开发一个绘制CPU使用率图形的程序是一项技术挑战,它涉及到系统监控、图形用户界面(GUI)以及实时数据处理等多方面的知识。这个程序的主要目的是模拟任务管理器的部分功能,显示计算机的CPU使用...

    用java获取CPU占用率

    代码中`getCpuRateForLinux()`方法试图打开并读取`/proc/stat`,然后解析其中的数据来计算CPU的使用率。这一过程通常涉及对`user`, `nice`, `system`, `idle`, 和 `iowait`等字段的解读,这些字段代表了不同类型的...

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

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

    java监控linux cpu使用率

    本文将深入探讨如何使用Java来实现Linux下的CPU使用率监控。通过理解这个主题,开发者可以更好地掌握系统性能,及时发现并解决问题,确保服务的稳定运行。 首先,我们需要了解Linux系统中CPU使用率的基本概念。CPU...

    测量Java应用程序的CPU和内存占用率

    通过JNI,我们可以编写特定于操作系统的C/C++代码来调用系统调用,获取关于CPU使用率和内存占用的数据,然后将这些信息传递回Java应用程序。相比依赖于解析操作系统特定的命令行工具(如Unix的`ps`命令)输出,这种...

    用jni获得cpu和内存使用率

    在Linux环境下,CPU使用率可以通过读取`/proc/stat`文件得到,其中包含了系统和各个进程的CPU时间统计。内存使用率则可以通过读取`/proc/meminfo`文件获取,这个文件提供了内存的总量和已使用的详细信息。在C++代码...

    Android编程实现获取系统内存、CPU使用率及状态栏高度的方法示例

    本文实例讲述了Android编程实现获取系统内存、CPU使用率及状态栏高度的方法。分享给大家供大家参考,具体如下: DeviceInfoManage类用于获取系统的内存,CPU的信息,以及状态栏的高度 import java.io.BufferedReader...

    java(jni)获得CPU、内存使用率 绝对可用

    CPU使用率是指CPU在一段时间内执行非空闲任务的比例,通常以百分比表示。内存使用率则反映了系统分配给进程的内存在当前时刻被占用的程度。在Java中,我们通常使用`java.lang.management`包中的`...

    通过snmp的OID获取对方主机的内存利用率及CPU的使用率

    在本场景中,我们的目标是利用SNMP来获取远程主机的内存利用率和CPU使用率,这对于网络性能监控和故障排查至关重要。 首先,我们需要了解SNMP的基本工作原理。SNMP由三部分组成:管理站(Manager)、代理(Agent)...

    Java实现对系统CPU、内存占用率的控制

    背景:由于使用的业主的云资源,由于使用率低,会不持续的缩减服务器配置。...问题:怎样通过Java程序实现CPU、内存占用超过50%? 方案:详见我的博客:https://blog.csdn.net/taotao_guiwang?spm=1010.2135.3001.5343

    Android获取cpu,内存,磁盘使用率信息

    通过`getRunningAppProcesses()`方法获取所有运行进程,并通过`importance`字段判断进程的重要性,从而推算出CPU使用率。同时,Android还提供了`/proc/stat`系统文件,开发者可以通过读取该文件解析出CPU使用率,但...

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

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

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

    对于CPU使用率的获取,通常我们使用Win32_Processor类。这个类包含了处理器的各种性能指标,如LoadPercentage属性,它表示了处理器当前的负载。以下是一个简单的C#函数示例,用于获取远程服务器的CPU使用率: ```...

    cpu-use_CPU使用率_源码

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

Global site tag (gtag.js) - Google Analytics