Comment vérifier l'utilisation du PROCESSEUR et de la mémoire en Java?

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

Runtime runtime = Runtime.getRuntime();

NumberFormat format = NumberFormat.getInstance();

StringBuilder sb = new StringBuilder();
long maxMemory = runtime.maxMemory();
long allocatedMemory = runtime.totalMemory();
long freeMemory = runtime.freeMemory();

sb.append("free memory: " + format.format(freeMemory / 1024) + "<br/>");
sb.append("allocated memory: " + format.format(allocatedMemory / 1024) + "<br/>");
sb.append("max memory: " + format.format(maxMemory / 1024) + "<br/>");
sb.append("total free memory: " + format.format((freeMemory + (maxMemory - allocatedMemory)) / 1024) + "<br/>");

Cependant, ceux-ci ne devraient ê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 String Info() {
        StringBuilder sb = new StringBuilder();
        sb.append(this.OsInfo());
        sb.append(this.MemInfo());
        sb.append(this.DiskInfo());
        return sb.toString();
    }

    public String OSname() {
        return System.getProperty("os.name");
    }

    public String OSversion() {
        return System.getProperty("os.version");
    }

    public String OsArch() {
        return System.getProperty("os.arch");
    }

    public long totalMem() {
        return Runtime.getRuntime().totalMemory();
    }

    public long usedMem() {
        return Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
    }

    public String MemInfo() {
        NumberFormat format = NumberFormat.getInstance();
        StringBuilder sb = new StringBuilder();
        long maxMemory = runtime.maxMemory();
        long allocatedMemory = runtime.totalMemory();
        long freeMemory = runtime.freeMemory();
        sb.append("Free memory: ");
        sb.append(format.format(freeMemory / 1024));
        sb.append("<br/>");
        sb.append("Allocated memory: ");
        sb.append(format.format(allocatedMemory / 1024));
        sb.append("<br/>");
        sb.append("Max memory: ");
        sb.append(format.format(maxMemory / 1024));
        sb.append("<br/>");
        sb.append("Total free memory: ");
        sb.append(format.format((freeMemory + (maxMemory - allocatedMemory)) / 1024));
        sb.append("<br/>");
        return sb.toString();

    }

    public String OsInfo() {
        StringBuilder sb = new StringBuilder();
        sb.append("OS: ");
        sb.append(this.OSname());
        sb.append("<br/>");
        sb.append("Version: ");
        sb.append(this.OSversion());
        sb.append("<br/>");
        sb.append(": ");
        sb.append(this.OsArch());
        sb.append("<br/>");
        sb.append("Available processors (cores): ");
        sb.append(runtime.availableProcessors());
        sb.append("<br/>");
        return sb.toString();
    }

    public String DiskInfo() {
        /* Get a list of all filesystem roots on this system */
        File[] roots = File.listRoots();
        StringBuilder sb = new StringBuilder();

        /* For each filesystem root, print some info */
        for (File root : roots) {
            sb.append("File system root: ");
            sb.append(root.getAbsolutePath());
            sb.append("<br/>");
            sb.append("Total space (bytes): ");
            sb.append(root.getTotalSpace());
            sb.append("<br/>");
            sb.append("Free space (bytes): ");
            sb.append(root.getFreeSpace());
            sb.append("<br/>");
            sb.append("Usable space (bytes): ");
            sb.append(root.getUsableSpace());
            sb.append("<br/>");
        }
        return sb.toString();
    }
}

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

De la documentation Sun:

L'argument de ligne de commande-verbose: gc imprime des informations à chaque collection. Notez que le format de la sortie-verbose: gc est soumis pour changer entre versions de la plate-forme J2SE. Par exemple, ici, est 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. Nombre avant et après la flèche

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

Indiquer la taille combinée des objets vivants avant et après la poubelle collection, respectivement. Après les collectes mineures le compte comprend des objets qui ne sont pas nécessairement vivants mais qui ne peuvent pas non plus être récupérés parce qu'ils sont directement en vie, ou parce qu'ils sont l'intérieur ou à référencé à partir de la génération titulaire. Le nombre entre parenthèses

(776768K) (in the first line)

Est l'espace disponible total, sans compter l'espace dans le permanent génération, qui est le tas total moins l'un des espaces survivants. La collecte mineure a pris environ un quart de seconde.

0.2300771 secs (in the first line)

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

À Partir de 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 donneront des utilisations de mémoire et de CPU.

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

Pour l'utilisation de la mémoire, ce qui suit fonctionnera,

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 paramètres, exporter au format CSV, afficher le nombre de classes chargées, le nombre d'instances, de blocages, de threads, etc...

Si vous utilisez la solution runtime/totalMemory qui a été publiée dans de nombreuses réponses ici (je l'ai beaucoup fait), assurez-vous de forcer d'abord deux garbage collections si vous voulez des résultats assez précis/cohérents.

Pour effiency Java permet généralement à garbage 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 l'exécution.freeMemory () est toujours quelque part entre la "vraie" quantité de mémoire libre et 0.

Le premier GC ne obtenez tout, il obtient la plupart de celui-ci.

La reprise est que si vous faites juste l'appel freeMemory (), vous obtiendrez un numéro absolument inutile et qui varie considérablement, mais si vous faites 2 gc d'abord, c'est une jauge très fiable. Cela rend également la routine BEAUCOUP plus lente (secondes, éventuellement).

L'objet

JavaRuntime peut signaler l'utilisation de la mémoire de la JVM. Pour la consommation du PROCESSEUR, vous devrez utiliser un utilitaire externe, comme top Unix ou Windows Process Manager.

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

J'ajouterais également la façon suivante de 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 savoir plus ici

JConsole est un moyen facile 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 NetBeans Profiler pour cela.

Le YourKit Java profiler est une excellente solution commerciale. Vous pouvez trouver plus d'informations dans les documents sur Profilage CPU et profilage 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 nombreuses autres zones.

Pour Eclipse, vous pouvez utiliser TPTP (Test and Performance Tools Platform) pour analyser l'utilisation de la mémoire, etc. plus d'informations