Comment puis-je vérifier l’utilisation du processeur et de la mémoire en Java?

J’ai besoin de vérifier l’utilisation du processeur et de la mémoire pour le serveur en Java, tout le monde sait comment cela pourrait être fait?

Si vous recherchez spécifiquement dans la mémoire JVM:

Runtime runtime = Runtime.getRuntime(); NumberFormat format = NumberFormat.getInstance(); SsortingngBuilder sb = new SsortingngBuilder(); long maxMemory = runtime.maxMemory(); long allocatedMemory = runtime.totalMemory(); long freeMemory = runtime.freeMemory(); sb.append("free memory: " + format.format(freeMemory / 1024) + "
"); sb.append("allocated memory: " + format.format(allocatedMemory / 1024) + "
"); sb.append("max memory: " + format.format(maxMemory / 1024) + "
"); sb.append("total free memory: " + format.format((freeMemory + (maxMemory - allocatedMemory)) / 1024) + "
");

Cependant, ceux-ci ne doivent être pris qu’à une estimation …

 package mkd.Utils; import java.io.File; import java.text.NumberFormat; public class systemInfo { private Runtime runtime = Runtime.getRuntime(); public Ssortingng Info() { SsortingngBuilder sb = new SsortingngBuilder(); sb.append(this.OsInfo()); sb.append(this.MemInfo()); sb.append(this.DiskInfo()); return sb.toSsortingng(); } public Ssortingng OSname() { return System.getProperty("os.name"); } public Ssortingng OSversion() { return System.getProperty("os.version"); } public Ssortingng OsArch() { return System.getProperty("os.arch"); } public long totalMem() { return Runtime.getRuntime().totalMemory(); } public long usedMem() { return Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory(); } public Ssortingng MemInfo() { NumberFormat format = NumberFormat.getInstance(); SsortingngBuilder sb = new SsortingngBuilder(); long maxMemory = runtime.maxMemory(); long allocatedMemory = runtime.totalMemory(); long freeMemory = runtime.freeMemory(); sb.append("Free memory: "); sb.append(format.format(freeMemory / 1024)); sb.append("
"); sb.append("Allocated memory: "); sb.append(format.format(allocatedMemory / 1024)); sb.append("
"); sb.append("Max memory: "); sb.append(format.format(maxMemory / 1024)); sb.append("
"); sb.append("Total free memory: "); sb.append(format.format((freeMemory + (maxMemory - allocatedMemory)) / 1024)); sb.append("
"); return sb.toSsortingng(); } public Ssortingng OsInfo() { SsortingngBuilder sb = new SsortingngBuilder(); sb.append("OS: "); sb.append(this.OSname()); sb.append("
"); sb.append("Version: "); sb.append(this.OSversion()); sb.append("
"); sb.append(": "); sb.append(this.OsArch()); sb.append("
"); sb.append("Available processors (cores): "); sb.append(runtime.availableProcessors()); sb.append("
"); return sb.toSsortingng(); } public Ssortingng DiskInfo() { /* Get a list of all filesystem roots on this system */ File[] roots = File.listRoots(); SsortingngBuilder sb = new SsortingngBuilder(); /* For each filesystem root, print some info */ for (File root : roots) { sb.append("File system root: "); sb.append(root.getAbsolutePath()); sb.append("
"); sb.append("Total space (bytes): "); sb.append(root.getTotalSpace()); sb.append("
"); sb.append("Free space (bytes): "); sb.append(root.getFreeSpace()); sb.append("
"); sb.append("Usable space (bytes): "); sb.append(root.getUsableSpace()); sb.append("
"); } return sb.toSsortingng(); } }

Si vous utilisez la JVM de Sun et que vous êtes intéressé par l’utilisation de la mémoire interne de l’application (sur la quantité de mémoire allouée utilisée par votre application), je préfère activer la journalisation de la récupération de place intégrée à la JVM. Vous ajoutez simplement -verbose: gc à la commande de démarrage.

De la documentation Sun:

L’argument de la ligne de commande -verbose: gc imprime des informations à chaque collection. Notez que le format de la sortie -verbose: gc est susceptible de changer entre les versions de la plate-forme J2SE. Par exemple, voici une sortie d’une grande application serveur:

 [GC 325407K->83000K(776768K), 0.2300771 secs] [GC 325816K->83372K(776768K), 0.2454258 secs] [Full GC 267628K->83769K(776768K), 1.8479984 secs] 

Nous voyons ici deux collections mineures et une majeure. Les chiffres avant et après la flèche

 325407K->83000K (in the first line) 

Indiquez la taille combinée des objects actifs avant et après la récupération de place, respectivement. Après les collections mineures, le nombre inclut les objects qui ne sont pas nécessairement vivants mais qui ne peuvent pas être récupérés, soit parce qu’ils sont directement vivants, soit parce qu’ils sont ou sont référencés par la génération titulaire. Le nombre entre parenthèses

 (776768K) (in the first line) 

est l’espace total disponible, sans compter l’espace dans la génération permanente, qui est le tas total moins un des espaces de survie. La collection mineure a pris environ un quart de seconde.

 0.2300771 secs (in the first line) 

Pour plus d’informations, voir: http://java.sun.com/docs/hotspot/gc5.0/gc_tuning_5.html

D’ ici

  OperatingSystemMXBean operatingSystemMXBean = (OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean(); RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean(); int availableProcessors = operatingSystemMXBean.getAvailableProcessors(); long prevUpTime = runtimeMXBean.getUptime(); long prevProcessCpuTime = operatingSystemMXBean.getProcessCpuTime(); double cpuUsage; try { Thread.sleep(500); } catch (Exception ignored) { } operatingSystemMXBean = (OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean(); long upTime = runtimeMXBean.getUptime(); long processCpuTime = operatingSystemMXBean.getProcessCpuTime(); long elapsedCpu = processCpuTime - prevProcessCpuTime; long elapsedTime = upTime - prevUpTime; cpuUsage = Math.min(99F, elapsedCpu / (elapsedTime * 10000F * availableProcessors)); System.out.println("Java CPU: " + cpuUsage); 

JMX, les MXBeans (ThreadMXBean, etc.) fournis vous permettront d’utiliser la mémoire et le processeur.

 OperatingSystemMXBean operatingSystemMXBean = (OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean(); operatingSystemMXBean.getSystemCpuLoad(); 

Pour l’utilisation de la mémoire, les éléments suivants fonctionneront,

 long total = Runtime.getRuntime().totalMemory(); long used = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory(); 

Pour l’utilisation du processeur, vous devrez utiliser une application externe pour le mesurer.

Depuis Java 1.5, le JDK est livré avec un nouvel outil: JConsole qui peut vous montrer l’utilisation du processeur et de la mémoire de toute JVM 1.5 ou ultérieure. Il peut faire des graphiques de ces parameters, exporter au format CSV, afficher le nombre de classes chargées, le nombre d’instances, les blocages, les threads, etc.

Si vous utilisez la solution runtime / totalMemory qui a été publiée dans de nombreuses réponses (je l’ai fait beaucoup), veillez à forcer deux collectes de données en premier si vous voulez des résultats assez précis / cohérents.

Pour être efficace, Java permet généralement à la mémoire de remplir toute la mémoire avant de forcer un GC, et même alors, ce n’est généralement pas un GC complet, donc vos résultats pour runtime.freeMemory () se situent toujours entre 0 .

Le premier GC ne comprend pas tout, il en tire le maximum.

L’augmentation est que si vous faites juste l’appel freeMemory (), vous obtiendrez un nombre absolument inutile et très variable, mais si c’est le cas, 2 gc est une mesure très fiable. Cela rend également la routine BEAUCOUP plus lente (secondes, éventuellement).

Voici un code simple pour calculer l’utilisation actuelle de la mémoire en mégaoctets:

 double currentMemory = ( (double)((double)(Runtime.getRuntime().totalMemory()/1024)/1024))- ((double)((double)(Runtime.getRuntime().freeMemory()/1024)/1024)); 

L’object d’ exécution Java peut signaler l’utilisation de la mémoire de la machine virtuelle Java. Pour la consommation du processeur, vous devez utiliser un utilitaire externe, tel que le top Unix ou le gestionnaire de processus Windows.

Je voudrais également append la façon suivante pour suivre la charge du processeur:

 import java.lang.management.ManagementFactory; import com.sun.management.OperatingSystemMXBean; double getCpuLoad() { OperatingSystemMXBean osBean = (com.sun.management.OperatingSystemMXBean) ManagementFactory. getPlatformMXBeans(OperatingSystemMXBean.class); return osBean.getProcessCpuLoad(); } 

Vous pouvez en lire plus ici

JConsole est un moyen simple de surveiller une application Java en cours d’exécution ou vous pouvez utiliser un profileur pour obtenir des informations plus détaillées sur votre application. J’aime utiliser le profileur NetBeans pour cela.

Le profileur Java YourKit est une excellente solution commerciale. Vous pouvez trouver plus d’informations dans la documentation sur le profilage du processeur et le profilage de la mémoire .

Si vous utilisez Tomcat, consultez Psi Probe , qui vous permet de surveiller la consommation de mémoire interne et externe, ainsi que de nombreux autres domaines.

Pour Eclipse, vous pouvez utiliser TPTP (plate-forme d’outils de test et de performance) pour parsingr l’utilisation de la mémoire, etc. Plus d’informations