JavaからのCPU負荷

Question

JNIを使​​用せずにJavaで現在のCPU負荷を取得する方法はありますか？

Answer 1

ManagementFactoryを使用してOperatingSystemMXBeanを取得し、getSystemLoadAverage()を呼び出してください。

Answer 2

LinuxではRuntimeを使用できます。 exec()で "稼働時間"を実行し、出力を評価してください。私はLinux上では良い方法はないと思いますが、Windowsの下でも同様に「便利」な方法はないと思います。

Answer 3

Linuxでは、/ proc/loadavgファイルを読み込むことができます。最初の3つの値は負荷平均を表します。 WindowsではおそらくJNIに固執する必要があります。

Answer 4

これにはJNIが関係しますが、HypericのSigarと呼ばれるGPLライブラリがあり、主要なプラットフォームすべてにこの情報を提供します。また、ディスク使用率などのOS依存の統計情報もたくさんあります。それは私たちにとって素晴らしい仕事です。

Answer 5

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

Answer 6

getSystemLoadAverage（）あなたは時間の1分にわたり価値を提供します（毎秒リフレッシュし）、全体的なオペレーティングシステムのためにこの値を与えます。各スレッドを別々に監視することにより、よりリアルタイムの概要を把握する必要があります。重要なのは、監視のリフレッシュ間隔にも注意してください。値を確認する頻度が増え、指定された時刻にもっと正確になります。ミリ秒ごとに実行すると、通常は0または100（またはそこにあるCPUの数によって異なります）。しかし、時間枠（例えば1秒）を許せば、この期間に平均してより有益な結果が得られます。また、1つのスレッドだけが複数のCPU（コア）を占有する可能性は非常に低いことに注意することが重要です。 CPUあたりAvarage負荷（コア） -

getAvarageUsagePerCPU（） JVM内のすべてのスレッドにより総荷重 -

• getTotalUsage（）：実装後

  は、3つの方法を使用することができ

• getUsageByThread（スレッド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; 
       } 
      } 
  }