Java中的CPU负载

Question

有没有一种不使用JNI就能获取Java下当前CPU负载的方法？

- pawel

Answer 1

使用 ManagementFactory 来获取一个 OperatingSystemMXBean，并在其上调用 getSystemLoadAverage() 方法。

- saua

Answer 2

getSystemLoadAverage()方法提供的是1分钟内操作系统总体负载值（每秒刷新一次）。要获得更实时的概览，应单独监视每个线程。重要的是注意监视刷新间隔，你检查的次数越多，在给定时刻它就越精确，如果你每毫秒检查一次，则通常为0或100（或更多，这取决于有多少个CPU）。但如果我们允许时间范围（例如1秒），我们就能得到该时间段内的平均值，并获得更多信息。另外，需要注意的是，很可能只有一个线程占用超过一个CPU（核心）的情况非常少见。

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

• getTotalUsage() - Total load by all the threads in JVM
• getAvarageUsagePerCPU() - Avarage load per CPU (core)

• getUsageByThread(Thread t) - Total load by specified thread

  import java.lang.management.ManagementFactory;
  import java.lang.management.OperatingSystemMXBean;
  import java.lang.management.ThreadMXBean;
  import java.util.Collection;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Map;
  import java.util.Set;
  
  public class MonitoringThread extends Thread {
  
      private long refreshInterval;
      private boolean stopped;
  
      private Map<Long, ThreadTime> threadTimeMap = new HashMap<Long, ThreadTime>();
      private ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();
      private OperatingSystemMXBean opBean = ManagementFactory.getOperatingSystemMXBean();
  
      public MonitoringThread(long refreshInterval) {
          this.refreshInterval = refreshInterval;
  
          setName("MonitoringThread");
  
          start();
      }
  
      @Override
      public void run() {
          while(!stopped) {
              Set<Long> mappedIds;
              synchronized (threadTimeMap) {
                  mappedIds = new HashSet<Long>(threadTimeMap.keySet());
              }
  
              long[] allThreadIds = threadBean.getAllThreadIds();
  
              removeDeadThreads(mappedIds, allThreadIds);
  
              mapNewThreads(allThreadIds);
  
              Collection<ThreadTime> values;
              synchronized (threadTimeMap) {
                  values = new HashSet<ThreadTime>(threadTimeMap.values());    
              }
  
              for (ThreadTime threadTime : values) {
                  synchronized (threadTime) {
                      threadTime.setCurrent(threadBean.getThreadCpuTime(threadTime.getId())); 
                  }
              }
  
              try {
                  Thread.sleep(refreshInterval);
              } catch (InterruptedException e) {
                  throw new RuntimeException(e);
              }
  
              for (ThreadTime threadTime : values) {
                  synchronized (threadTime) {
                      threadTime.setLast(threadTime.getCurrent());    
                  }
              }
          }
      }
  
      private void mapNewThreads(long[] allThreadIds) {
          for (long id : allThreadIds) {
              synchronized (threadTimeMap) {
                  if(!threadTimeMap.containsKey(id))
                      threadTimeMap.put(id, new ThreadTime(id));
              }
          }
      }
  
      private void removeDeadThreads(Set<Long> mappedIds, long[] allThreadIds) {
          outer: for (long id1 : mappedIds) {
              for (long id2 : allThreadIds) {
                  if(id1 == id2)
                      continue outer;
              }
              synchronized (threadTimeMap) {
                  threadTimeMap.remove(id1);
              }
          }
      }
  
      public void stopMonitor() {
          this.stopped = true;
      }
  
      public double getTotalUsage() {
          Collection<ThreadTime> values;
          synchronized (threadTimeMap) {
              values = new HashSet<ThreadTime>(threadTimeMap.values());    
          }
  
          double usage = 0D;
          for (ThreadTime threadTime : values) {
              synchronized (threadTime) {
                  usage += (threadTime.getCurrent() - threadTime.getLast()) / (refreshInterval * 10000);
              }
          }
          return usage;
      }
  
      public double getAvarageUsagePerCPU() {
          return getTotalUsage() / opBean.getAvailableProcessors(); 
      }
  
      public double getUsageByThread(Thread t) {
          ThreadTime info;
          synchronized (threadTimeMap) {
              info = threadTimeMap.get(t.getId());
          }
  
          double usage = 0D;
          if(info != null) {
              synchronized (info) {
                  usage = (info.getCurrent() - info.getLast()) / (refreshInterval * 10000);
              }
          }
          return usage;
      }
  
      static class ThreadTime {
  
          private long id;
          private long last;
          private long current;
  
          public ThreadTime(long id) {
              this.id = id;
          }
  
          public long getId() {
              return id;
          }
  
          public long getLast() {
              return last;
          }
  
          public void setLast(long last) {
              this.last = last;
          }
  
          public long getCurrent() {
              return current;
          }
  
          public void setCurrent(long current) {
              this.current = current;
          }
      }
  }
  

- Kaido Kalda

Answer 3

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

- Alex Miller

Answer 4

在Linux系统下，您可以直接读取文件/proc/loadavg，其中前三个值表示负载平均值。对于Windows系统，您可能需要使用JNI。

- welterde

Answer 5

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

- Bombe

Answer 6

如果您正在使用JRockit JVM，您可以使用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();
}

- Kire Haglin