来自 Java 的 CPU 负载

Question

有没有办法在Java下不使用JNI获取当前cpu负载？

Answer 1

使用 ManagementFactory< /a> 获取 OperatingSystemMXBean< /code>并调用 getSystemLoadAverage() 就可以了。

Answer 2

getSystemLoadAverage() 为您提供 1 分钟内的值（每秒刷新一次），并给出整个操作系统的该值。 应通过单独监视每个线程来完成更多实时概述。 还需要注意的是监视刷新间隔 - 您检查该值的频率越高，在给定时刻的值就越精确，如果您每毫秒执行一次，则它通常为 0 或 100（或更多，具体取决于有多少个 CPU）。 但是，如果我们允许时间范围（例如 1 秒），我们就会得到这段时间的平均值，并且得到信息更丰富的结果。 另外，值得注意的是，只有一个线程占用多个 CPU（核心）的可能性极小。

以下实现允许使用 3 种方法：

• getTotalUsage() - JVM 中所有线程的总负载
• getAvarageUsagePerCPU() - 每个 CPU（核心）的平均负载

• getUsageByThread(Thread t) - 指定线程的总负载

  导入java.lang.management.ManagementFactory; 
    导入 java.lang.management.OperatingSystemMXBean; 
    导入 java.lang.management.ThreadMXBean; 
    导入java.util.Collection； 
    导入java.util.HashMap； 
    导入java.util.HashSet； 
    导入java.util.Map； 
    导入java.util.Set； 
  
    公共类MonitoringThread扩展Thread { 
  
        私有长刷新间隔； 
        私人布尔值停止； 
  
        private Map   threadTimeMap = new HashMap(); 
        私有 ThreadMXBean threadBean = ManagementFactory.getThreadMXBean(); 
        私有 OperatingSystemMXBean opBean = ManagementFactory.getOperatingSystemMXBean(); 
  
        公共监控线程（长刷新间隔）{ 
            this.refreshInterval = 刷新间隔； 
  
            setName("监控线程"); 
  
            开始（）; 
        } 
  
        @覆盖 
        公共无效运行（）{ 
            while(!stopped) { 
                设置<长>   映射的 ID； 
                同步（线程时间映射）{ 
                    mappedIds = new HashSet(threadTimeMap.keySet()); 
                } 
  
                long[] allThreadIds = threadBean.getAllThreadIds(); 
  
                删除DeadThreads（mappedIds，allThreadIds）； 
  
                mapNewThreads(allThreadIds); 
  
                集合   价值观； 
                同步（线程时间映射）{ 
                    value = new HashSet(threadTimeMap.values());     
                } 
  
                for (ThreadTime 线程时间：值) { 
                    同步（线程时间）{ 
                        threadTime.setCurrent(threadBean.getThreadCpuTime(threadTime.getId()));  
                    } 
                } 
  
                尝试 { 
                    Thread.sleep(刷新间隔); 
                } catch (InterruptedException e) { 
                    抛出新的运行时异常（e）； 
                } 
  
                for (ThreadTime 线程时间：值) { 
                    同步（线程时间）{ 
                        threadTime.setLast(threadTime.getCurrent());     
                    } 
                } 
            } 
        } 
  
        私有无效mapNewThreads（长[] allThreadIds）{ 
            for (长 id : allThreadIds) { 
                同步（线程时间映射）{ 
                    if(!threadTimeMap.containsKey(id)) 
                        threadTimeMap.put(id, new ThreadTime(id)); 
                } 
            } 
        } 
  
        private void removeDeadThreads(Setma​​ppedIds, long[] allThreadIds) { 
            外部：for（长id1：mappedIds）{ 
                for (long id2 : allThreadIds) { 
                    如果（id1==id2） 
                        继续外； 
                } 
                同步（线程时间映射）{ 
                    threadTimeMap.remove(id1); 
                } 
            } 
        } 
  
        公共无效停止监视器（）{ 
            this.stopped = true; 
        } 
  
        公共双 getTotalUsage() { 
            集合   价值观； 
            同步（线程时间映射）{ 
                value = new HashSet(threadTimeMap.values());     
            } 
  
            双重使用 = 0D； 
            for (ThreadTime 线程时间：值) { 
                同步（线程时间）{ 
                    用法 += (threadTime.getCurrent() - threadTime.getLast()) / (refreshInterval * 10000); 
                } 
            } 
            返回使用情况； 
        } 
  
        公共双 getAvarageUsagePerCPU() { 
            返回 getTotalUsage() / opBean.getAvailableProcessors();  
        } 
  
        公共双 getUsageByThread(线程 t) { 
            线程时间信息； 
            同步（线程时间映射）{ 
                信息 = threadTimeMap.get(t.getId()); 
            } 
  
            双重使用 = 0D； 
            如果（信息！=空）{ 
                同步（信息）{ 
                    用法 = (info.getCurrent() - info.getLast()) / (refreshInterval * 10000); 
                } 
            } 
            返回使用情况； 
        } 
  
        静态类 ThreadTime { 
  
            私人长ID； 
            私人长久以来； 
            私人长电； 
  
            公共线程时间（长ID）{ 
                这个.id = id; 
            } 
  
            公共长 getId() { 
                返回ID； 
            } 
  
            公共长 getLast() { 
                最后返回； 
            } 
  
            公共无效setLast（最后）{ 
                这.最后=最后; 
            } 
  
            公共长 getCurrent() { 
                返回电流； 
            } 
  
            公共无效setCurrent（长电流）{ 
                this.current = 当前； 
            } 
        } 
    } 
    

Answer 3

这确实涉及 JNI，但 Hyperic 有一个名为 Sigar 的 GPL 库，它提供了此信息所有主要平台，以及许多其他依赖于操作系统的统计信息，例如磁盘使用情况。 这对我们来说非常有效。

Answer 4

在 Linux 上，您可以只读取文件 /proc/loadavg，其中前三个值代表负载平均值。 对于 Windows，您可能必须坚持使用 JNI。

Answer 5

在 Linux 下，您可以使用 Runtime . exec() 执行“uptime”并评估输出。 我认为在 Linux 下没有更好的方法，并且我认为在 Windows 下也没有同样“方便”的方法。

Answer 6

如果您使用 JRockit JVM 您可以使用 < a href="http://download.oracle.com/docs/cd/E13150_01/jrockit_jvm/jrockit/releases/R27/javadoc/manapi27.2/docs/index.html" rel="nofollow noreferrer">JMAPI。 它适用于 JDK 1.4、1.5 和 1.6。

System.out.println("Total CPU-usage:" + JVMFactory.getJVM().getMachine().getCPULoad());

System.out.println("Total JVM-load :" + JVMFactory.getJVM().getJVMLoad());

for(Iterator it = JVMFactory.getJVM().getMachine().getCPUs().iterator(); it.hasNext();)
{
   CPU cpu = (CPU)it.next();
   System.out.println("CPU Description: " + cpu.getDescription());
   System.out.println("CPU Clock Frequency: " + cpu.getClockFrequency());
   System.out.println("CPU Load: " + cpu.getLoad());
   System.out.println();
}