Загрузка процессора из Java

Question

Есть ли способ получить текущую загрузку процессора под Java без использования JNI?

Answer 1

Используйте ManagementFactory, чтобы получить OperatingSystemMXBean и позвоните по телефону getSystemLoadAverage().

Answer 2

Под Linux вы можете использовать Runtime. exec() выполнить «время безотказной работы» и оценить выход. У меня нет лучшего способа под Linux, и я не думаю, что в Windows есть одинаково удобный способ.

Answer 3

В linux вы можете просто прочитать файл/proc/loadavg, где первые три значения представляют средние значения нагрузки. Для Windows вы, вероятно, должны придерживаться JNI.

Answer 4

Это связано с JNI, но есть библиотека GPL от Hyperic, называемая Sigar, которая предоставляет эту информацию для всех основных платформ, а также множество других зависимых от ОС статистических данных, таких как использование диска. Это отлично работает для нас.

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 секунду), мы получаем avarage в течение этого периода времени, и мы получаем более информативный результат. Кроме того, важно заметить, что маловероятно, что только один поток занимает не один процессор (ядро).

После осуществления позволяет использовать 3 метода:

• getTotalUsage() - суммарная нагрузка по всем потокам в JVM
• getAvarageUsagePerCPU() - насчитайте нагрузка на процессор (ядро)

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