来自 Java 的 CPU 负载

CPU load from Java

提问by paweloque

Is there a way to get the current cpu load under Java without using the JNI?

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

回答by Joachim Sauer

Use the ManagementFactoryto get an OperatingSystemMXBeanand call getSystemLoadAverage()on it.

使用ManagementFactory来获取OperatingSystemMXBean并调用getSystemLoadAverage()它。

回答by Kaido Kalda

getSystemLoadAverage()gives you value over 1 minute of time (refreshes every second) and gives this value for overall operating system. More realtime overview should be done by monitoring each thread separately. Important is also notice the monitoring refresh interval - more often you check the value, more precice it is in given moment and if you do it every millisecond, it is typically 0 or 100 (or more depending how many CPU's is there). But if we allow timeframe (for example 1 second), we get avarage over this period of time and we get more informative result. Also, it is important to notice, that it is highly unlikely, that only one thread occupies more than one CPU (core).

getSystemLoadAverage()为您提供超过 1 分钟的时间（每秒刷新一次）并为整个操作系统提供此值。更多的实时概览应该通过分别监控每个线程来完成。重要的是还请注意监视刷新间隔 - 更频繁地检查值，在给定时刻更精确，如果每毫秒执行一次，它通常为 0 或 100（或更多，取决于有多少 CPU 存在）。但是如果我们允许时间范围（例如 1 秒），我们会得到这段时间的平均值，我们会得到更多信息的结果。此外，重要的是要注意，只有一个线程占用多个 CPU（核心）的可能性很小。

Following implementation allows to use 3 methods:

以下实现允许使用 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;
          }
      }
  }
  

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

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

  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;
          }
      }
  }
  

回答by Alex Miller

This does involve JNI but there is a GPL library from Hyperic called Sigarthat provides this information for all the major platforms, as well as a bunch of other OS-dependent stats like disk usage. It's worked great for us.

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

回答by welterde

On linux you could just read the file /proc/loadavg, where the first three values represent the load averages. For Windows you probably have to stick to JNI.

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

回答by Bombe

Under Linux you could use Runtime.exec()to execute “uptime” and evaluate the output. I don't there's a better way under Linux, and I don't think there's an equally “convenient” way under Windows.

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

回答by Kire Haglin

If you're using the JRockit JVMyou could use JMAPI. It works for JDK 1.4, 1.5 and 1.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();
}