如何用Java监控计算机的CPU、内存和磁盘使用情况？

Question

我想用 Java 监视以下系统信息：

• 当前 CPU 使用率**（百分比）
• 可用内存*（可用/总计）

• 可用磁盘空间（可用/总计）

  *请注意，我的意思是整个系统可用的总内存，而不仅仅是 JVM。

我正在寻找一种跨平台解决方案（Linux、Mac 和 Windows），该解决方案不依赖于我自己的代码调用外部程序或使用 JNI。 尽管这些都是可行的选择，但如果有人已经有了更好的解决方案，我宁愿不自己维护特定于操作系统的代码。

如果有一个免费的库可以以可靠的跨平台方式执行此操作，那就太好了（即使它进行外部调用或本身使用本机代码）。

非常感谢任何建议。

澄清一下，我想获取整个系统的当前 CPU 使用情况，而不仅仅是 Java 进程。

SIGAR API 在一个包中提供了我正在寻找的所有功能，因此这是迄今为止我的问题的最佳答案。 然而，由于它是根据 GPL 许可的，我不能将它用于我的原始目的（闭源商业产品）。 Hyperic 可能会授权 SIGAR 用于商业用途，但我还没有研究过。 对于我的 GPL 项目，我将来肯定会考虑 SIGAR。

对于我当前的需求，我倾向于以下内容：

• 对于 CPU 使用情况，OperatingSystemMXBean.getSystemLoadAverage() / OperatingSystemMXBean.getAvailableProcessors()（每个 cpu 的平均负载）
• 对于内存，OperatingSystemMXBean.getTotalPhysicalMemorySize () 和 OperatingSystemMXBean.getFreePhysicalMemorySize()
• 对于磁盘空间，File.getTotalSpace() 和 File.getUsableSpace()

限制：

getSystemLoadAverage() 和磁盘空间查询方法仅在 Java 6 下可用。此外，某些 JMX 功能可能不适用于所有平台（即据报道 getSystemLoadAverage() 在 Windows 上返回 -1）。

虽然最初是根据 GPL 授权的，但它已更改为Apache 2.0，通常可用于闭源商业产品。

Answer 1

沿着我在这篇文章中提到的 。 我建议您使用 SIGAR API。 我在自己的一个应用程序中使用了 SIGAR API，它非常棒。 您会发现它很稳定，得到良好的支持，并且充满了有用的示例。 它是开源的，具有 GPL 2 Apache 2.0 许可证。 一探究竟。 我有一种感觉它会满足你的需求。

使用 Java 和 Sigar API，您可以获得内存、CPU、磁盘、平均负载、网络接口信息和指标、进程表信息、路由信息等。

Answer 2

以下内容应该可以为您提供 CPU 和 RAM。 有关更多详细信息，请参阅 ManagementFactory 。

import java.lang.management.ManagementFactory;
import java.lang.management.OperatingSystemMXBean;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

private static void printUsage() {
  OperatingSystemMXBean operatingSystemMXBean = ManagementFactory.getOperatingSystemMXBean();
  for (Method method : operatingSystemMXBean.getClass().getDeclaredMethods()) {
    method.setAccessible(true);
    if (method.getName().startsWith("get")
        && Modifier.isPublic(method.getModifiers())) {
            Object value;
        try {
            value = method.invoke(operatingSystemMXBean);
        } catch (Exception e) {
            value = e;
        } // try
        System.out.println(method.getName() + " = " + value);
    } // if
  } // for
}

Answer 3

在 JDK 1.7 中，您可以通过 com.sun.management.OperatingSystemMXBean。 这与 java.lang.management.OperatingSystemMXBean 不同。

long getCommittedVirtualMemorySize()
// Returns the amount of virtual memory that is guaranteed to be available to the running process in bytes, or -1 if this operation is not supported.

long getFreePhysicalMemorySize()
// Returns the amount of free physical memory in bytes.

long getFreeSwapSpaceSize()
// Returns the amount of free swap space in bytes.

double getProcessCpuLoad()
// Returns the "recent cpu usage" for the Java Virtual Machine process.

long getProcessCpuTime()
// Returns the CPU time used by the process on which the Java virtual machine is running in nanoseconds.

double getSystemCpuLoad()
// Returns the "recent cpu usage" for the whole system.

long getTotalPhysicalMemorySize()
// Returns the total amount of physical memory in bytes.

long getTotalSwapSpaceSize()
// Returns the total amount of swap space in bytes.

Answer 4

2008 年接受的答案推荐了 SIGAR。 然而，正如 2014 年的评论 (@Alvaro) 所说：

使用Sigar要小心，在x64机器上有问题...
Sigar 1.6.4 崩溃：EXCEPTION_ACCESS_VIOLATION好像是图书馆
自 2010 年以来不再更新

我的建议是使用 https://github.com/oshi/oshi

或者上面提到的答案。

Answer 5

对于磁盘空间，如果您有 Java 6，则可以使用 getTotalSpace 和 Apache Commons IO 来实现这一点。

恐怕我不知道有什么跨平台的方法来获取 CPU 使用率或内存使用率。

Answer 6

其中很多内容已经可以通过 JMX 获得。 在 Java 5 中，JMX 是内置的，并且它们包含带有 JDK 的 JMX 控制台查看器。

您可以使用 JMX 手动监控，或者如果您在自己的运行时需要此信息，则可以从 Java 调用 JMX 命令。

Answer 7

/* YOU CAN TRY THIS TOO */

import java.io.File;
 import java.lang.management.ManagementFactory;
// import java.lang.management.OperatingSystemMXBean;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.lang.management.RuntimeMXBean;
 import java.io.*;
 import java.net.*;
 import java.util.*;
 import java.io.LineNumberReader;
 import java.lang.management.ManagementFactory;
import com.sun.management.OperatingSystemMXBean;
import java.lang.management.ManagementFactory;
import java.util.Random;



 public class Pragati
 {

     public static void printUsage(Runtime runtime)
     {
     long total, free, used;
     int mb = 1024*1024;

     total = runtime.totalMemory();
     free = runtime.freeMemory();
     used = total - free;
     System.out.println("\nTotal Memory: " + total / mb + "MB");
     System.out.println(" Memory Used: " + used / mb + "MB");
     System.out.println(" Memory Free: " + free / mb + "MB");
     System.out.println("Percent Used: " + ((double)used/(double)total)*100 + "%");
     System.out.println("Percent Free: " + ((double)free/(double)total)*100 + "%");
    }
    public static void log(Object message)
         {
            System.out.println(message);
         }

        public static int calcCPU(long cpuStartTime, long elapsedStartTime, int cpuCount)
        {
             long end = System.nanoTime();
             long totalAvailCPUTime = cpuCount * (end-elapsedStartTime);
             long totalUsedCPUTime = ManagementFactory.getThreadMXBean().getCurrentThreadCpuTime()-cpuStartTime;
             //log("Total CPU Time:" + totalUsedCPUTime + " ns.");
             //log("Total Avail CPU Time:" + totalAvailCPUTime + " ns.");
             float per = ((float)totalUsedCPUTime*100)/(float)totalAvailCPUTime;
             log( per);
             return (int)per;
        }

        static boolean isPrime(int n)
        {
     // 2 is the smallest prime
            if (n <= 2)
            {
                return n == 2;
            }
     // even numbers other than 2 are not prime
            if (n % 2 == 0)
            {
                return false;
            }
     // check odd divisors from 3
     // to the square root of n
         for (int i = 3, end = (int)Math.sqrt(n); i <= end; i += 2)
         {
            if (n % i == 0)
         {
         return false;
        }
        }
 return true;
}
    public static void main(String [] args)
    {
            int mb = 1024*1024;
            int gb = 1024*1024*1024;
             /* PHYSICAL MEMORY USAGE */
             System.out.println("\n**** Sizes in Mega Bytes ****\n");
            com.sun.management.OperatingSystemMXBean operatingSystemMXBean = (com.sun.management.OperatingSystemMXBean)ManagementFactory.getOperatingSystemMXBean();
            //RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean();
            //operatingSystemMXBean = (com.sun.management.OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();
            com.sun.management.OperatingSystemMXBean os = (com.sun.management.OperatingSystemMXBean)
            java.lang.management.ManagementFactory.getOperatingSystemMXBean();
            long physicalMemorySize = os.getTotalPhysicalMemorySize();
            System.out.println("PHYSICAL MEMORY DETAILS \n");
            System.out.println("total physical memory : " + physicalMemorySize / mb + "MB ");
            long physicalfreeMemorySize = os.getFreePhysicalMemorySize();
            System.out.println("total free physical memory : " + physicalfreeMemorySize / mb + "MB");
            /* DISC SPACE DETAILS */
            File diskPartition = new File("C:");
            File diskPartition1 = new File("D:");
            File diskPartition2 = new File("E:");
            long totalCapacity = diskPartition.getTotalSpace() / gb;
            long totalCapacity1 = diskPartition1.getTotalSpace() / gb;
            double freePartitionSpace = diskPartition.getFreeSpace() / gb;
            double freePartitionSpace1 = diskPartition1.getFreeSpace() / gb;
            double freePartitionSpace2 = diskPartition2.getFreeSpace() / gb;
            double usablePatitionSpace = diskPartition.getUsableSpace() / gb;
            System.out.println("\n**** Sizes in Giga Bytes ****\n");
            System.out.println("DISC SPACE DETAILS \n");
            //System.out.println("Total C partition size : " + totalCapacity + "GB");
            //System.out.println("Usable Space : " + usablePatitionSpace + "GB");
            System.out.println("Free Space in drive C: : " + freePartitionSpace + "GB");
            System.out.println("Free Space in drive D:  : " + freePartitionSpace1 + "GB");
            System.out.println("Free Space in drive E: " + freePartitionSpace2 + "GB");
            if(freePartitionSpace <= totalCapacity%10 || freePartitionSpace1 <= totalCapacity1%10)
            {
                System.out.println(" !!!alert!!!!");
            }
            else
                System.out.println("no alert");

            Runtime runtime;
            byte[] bytes;
            System.out.println("\n \n**MEMORY DETAILS  ** \n");
            // Print initial memory usage.
            runtime = Runtime.getRuntime();
            printUsage(runtime);

            // Allocate a 1 Megabyte and print memory usage
            bytes = new byte[1024*1024];
            printUsage(runtime);

            bytes = null;
            // Invoke garbage collector to reclaim the allocated memory.
            runtime.gc();

            // Wait 5 seconds to give garbage collector a chance to run
            try {
            Thread.sleep(5000);
            } catch(InterruptedException e) {
            e.printStackTrace();
            return;
            }

            // Total memory will probably be the same as the second printUsage call,
            // but the free memory should be about 1 Megabyte larger if garbage
            // collection kicked in.
            printUsage(runtime);
            for(int i = 0; i < 30; i++)
                     {
                         long start = System.nanoTime();
                        // log(start);
                        //number of available processors;
                         int cpuCount = ManagementFactory.getOperatingSystemMXBean().getAvailableProcessors();
                         Random random = new Random(start);
                         int seed = Math.abs(random.nextInt());
                         log("\n \n CPU USAGE DETAILS \n\n");
                         log("Starting Test with " + cpuCount + " CPUs and random number:" + seed);
                         int primes = 10000;
                         //
                         long startCPUTime = ManagementFactory.getThreadMXBean().getCurrentThreadCpuTime();
                         start = System.nanoTime();
                         while(primes != 0)
                         {
                            if(isPrime(seed))
                            {
                                primes--;
                            }
                            seed++;

                        }
                         float cpuPercent = calcCPU(startCPUTime, start, cpuCount);
                         log("CPU USAGE : " + cpuPercent + " % ");


                         try
                         {
                             Thread.sleep(1000);
                         }
                         catch (InterruptedException e) {}
        }

            try
            {
                Thread.sleep(500);
            }`enter code here`
            catch (Exception ignored) { }
        }
    }

Answer 8

    OperatingSystemMXBean osBean = ManagementFactory.getPlatformMXBean(OperatingSystemMXBean.class);
    System.out.println((osBean.getCpuLoad() * 100) + "%");

import com.sun.management.OperatingSystemMXBean

它仅在第二次调用后开始工作，因此保存 osBean 并将其放入循环中

Answer 9

制作一个批处理文件“Pc.bat”，
typeperf -sc 1 "\mukit\processor(_Total)\%% Processor Time"

您可以使用 MProcess 类，

/*
 *Md. Mukit Hasan
 *CSE-JU,35
 **/
import java.io.*;


  公共类 MProcessor {

public MProcessor() {
    String s;
    try {
        Process ps = Runtime.getRuntime().exec("Pc.bat");
        BufferedReader br = new BufferedReader(new InputStreamReader(ps.getInputStream()));
        while((s = br.readLine()) != null) {
            System.out.println(s);
        }
    }
    catch( Exception ex ) {
        System.out.println(ex.toString());
    }
}

}

然后经过一些字符串操作，您就可以获得 CPU 使用情况。 您可以对其他任务使用相同的流程。

——穆吉特·哈桑

Answer 10

以下代码仅适用于 Linux（也许是 Unix），但它可以在实际项目中运行。

    private double getAverageValueByLinux() throws InterruptedException {
    try {

        long delay = 50;
        List<Double> listValues = new ArrayList<Double>();
        for (int i = 0; i < 100; i++) {
            long cput1 = getCpuT();
            Thread.sleep(delay);
            long cput2 = getCpuT();
            double cpuproc = (1000d * (cput2 - cput1)) / (double) delay;
            listValues.add(cpuproc);
        }
        listValues.remove(0);
        listValues.remove(listValues.size() - 1);
        double sum = 0.0;
        for (Double double1 : listValues) {
            sum += double1;
        }
        return sum / listValues.size();
    } catch (Exception e) {
        e.printStackTrace();
        return 0;
    }

}

private long getCpuT throws FileNotFoundException, IOException {
    BufferedReader reader = new BufferedReader(new FileReader("/proc/stat"));
    String line = reader.readLine();
    Pattern pattern = Pattern.compile("\\D+(\\d+)\\D+(\\d+)\\D+(\\d+)\\D+(\\d+)")
    Matcher m = pattern.matcher(line);

    long cpuUser = 0;
    long cpuSystem = 0;
    if (m.find()) {
        cpuUser = Long.parseLong(m.group(1));
        cpuSystem = Long.parseLong(m.group(3));
    }
    return cpuUser + cpuSystem;
}

Answer 11

这对我来说非常有效，无需任何外部 API，只需原生 Java 隐藏功能:)

import com.sun.management.OperatingSystemMXBean;
...
OperatingSystemMXBean osBean = ManagementFactory.getPlatformMXBean(
                OperatingSystemMXBean.class);
// What % CPU load this current JVM is taking, from 0.0-1.0
System.out.println(osBean.getProcessCpuLoad());

// What % load the overall system is at, from 0.0-1.0
System.out.println(osBean.getSystemCpuLoad());

Answer 12

看看这篇非常详细的文章：
http://nadeausoftware.com/articles/2008/03/java_tip_how_get_cpu_and_user_time_benchmarking#UsingaSuninternalclasstogetJVM CPU时间

要获取 CPU 使用的百分比，您需要的只是一些简单的数学计算：

MBeanServerConnection mbsc = ManagementFactory.getPlatformMBeanServer();

OperatingSystemMXBean osMBean = ManagementFactory.newPlatformMXBeanProxy(
mbsc, ManagementFactory.OPERATING_SYSTEM_MXBEAN_NAME, OperatingSystemMXBean.class);

long nanoBefore = System.nanoTime();
long cpuBefore = osMBean.getProcessCpuTime();

// Call an expensive task, or sleep if you are monitoring a remote process

long cpuAfter = osMBean.getProcessCpuTime();
long nanoAfter = System.nanoTime();

long percent;
if (nanoAfter > nanoBefore)
 percent = ((cpuAfter-cpuBefore)*100L)/
   (nanoAfter-nanoBefore);
else percent = 0;

System.out.println("Cpu usage: "+percent+"%");

注意：您必须导入 com.sun.management.OperatingSystemMXBean 而不是 java.lang.management.OperatingSystemMXBean代码>.