La charge CPU à partir de Java

Utiliser le ManagementFactory pour obtenir un OperatingSystemMXBean et appel getSystemLoadAverage().

OriginalL'auteur Joachim Sauer

getSystemLoadAverage() vous donne la valeur de plus de 1 minute de temps (actualise toutes les secondes) et donne à cette valeur pour l'ensemble du système d'exploitation. De plus en temps réel aperçu devrait être fait par le suivi de chaque thread séparément. Il est aussi Important de remarquer la surveillance de l'intervalle d'actualisation - le plus souvent, vous vérifiez la valeur, plus precice c'est à moment donné, et si vous le faites à chaque milliseconde, il est généralement de 0 ou 100 (ou plus selon le nombre de processeurs est là). Mais si nous permettons période (par exemple 1 seconde), nous obtenons avarage au cours de cette période de temps et nous obtenons plus instructif résultat. Aussi, il est important de noter, qu'il est très peu probable, qu'un seul thread occupe plus d'un CPU (core).

Après la mise en œuvre permet d'utiliser 3 méthodes:

• getTotalUsage() - charge Totale par tous les threads dans la JVM
• getAvarageUsagePerCPU() - Avarage de charge par le CPU (core)

• getUsageByThread(Thread t) - charge Totale par thread spécifié

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

OriginalL'auteur Kaido Kalda

Sous Linux vous pouvez utiliser Runtime.exec() pour exécuter la commande “uptime” et d'évaluer la sortie. Je n'ai pas il ya une meilleure façon sous Linux, et je ne pense pas qu'il y a aussi “pratique” sous Windows.

OriginalL'auteur Bombe