it-swarm-eu.dev

Come posso controllare l'utilizzo della CPU e della memoria in Java?

Devo controllare l'utilizzo della CPU e della memoria per il server in Java, qualcuno sa come si potrebbe fare?

93
Johnny Bou

Se stai cercando specificamente memoria in 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/>");

Tuttavia, questi dovrebbero essere presi solo come stima ...

69
Jeremy
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();
    }
}
19
Dave

Se si sta utilizzando Sun JVM e si è interessati all'utilizzo della memoria interna dell'applicazione (la quantità di memoria allocata utilizzata dall'app), preferisco attivare la registrazione della garbage collection integrata di JVM. È sufficiente aggiungere -verbose: gc al comando di avvio.

Dalla documentazione Sun:

L'argomento della riga di comando -verbose: gc stampa le informazioni in ogni raccolta. Si noti che il formato dell'uscita -verbose: gc è soggetto a modifiche tra le versioni della piattaforma J2SE. Ad esempio, ecco l'output di un'applicazione server di grandi dimensioni:

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

Qui vediamo due raccolte minori e una maggiore. I numeri prima e dopo la freccia

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

indica la dimensione combinata degli oggetti vivi prima e dopo la garbage collection, rispettivamente. Dopo raccolte secondarie, il conteggio include oggetti che non sono necessariamente vivi ma che non possono essere recuperati, sia perché sono direttamente vivi, sia perché sono all'interno o citati dalla generazione posseduta. Il numero tra parentesi

(776768K) (in the first line)

è lo spazio totale disponibile, senza contare lo spazio nella generazione permanente, che è l'heap totale meno uno degli spazi sopravvissuti. La raccolta minore ha richiesto circa un quarto di secondo.

0.2300771 secs (in the first line)

Per maggiori informazioni, consultare: http://Java.Sun.com/docs/hotspot/gc5.0/gc_tuning_5.html

17
unknown (yahoo)

Da qui

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

JMX, MXBeans (ThreadMXBean, ecc.) Forniti ti daranno gli usi di memoria e CPU.

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

Per l'utilizzo della memoria, funzionerà quanto segue,

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

Per l'utilizzo della CPU, è necessario utilizzare un'applicazione esterna per misurarla.

8
Rich Adams

Poiché Java 1.5 il JDK viene fornito con un nuovo strumento: JConsole che può mostrarti l'utilizzo della CPU e della memoria di qualsiasi JVM 1.5 o successive. Può fare grafici di questi parametri, esporta in CSV, mostra il numero di classi caricate, il numero di istanze, deadlock, thread ecc ...

5
Telcontar

Se usi la soluzione runtime/totalMemory che è stata pubblicata in molte risposte qui (l'ho fatto molto), assicurati di forzare prima due garbage collection se vuoi risultati abbastanza accurati/coerenti.

Per effiency Java di solito consente a Garbage di riempire tutta la memoria prima di forzare un GC, e anche allora non è di solito un GC completo, quindi i tuoi risultati per runtime.freeMemory () sono sempre a metà strada tra quantità "reale" di memoria libera e 0.

Il primo GC non ottiene tutto, ne ottiene la maggior parte.

Il vantaggio è che se fai semplicemente la chiamata freeMemory () otterrai un numero che è assolutamente inutile e varia ampiamente, ma se fai prima 2 gc è un indicatore molto affidabile. Rende anche la routine MOLTO più lenta (secondi, possibilmente).

4
Bill K

L'oggetto Runtime di Java può segnalare l'utilizzo della memoria della JVM. Per il consumo della CPU dovrai usare un'utilità esterna, come la top di Unix o Windows Process Manager.

3
moonshadow

Ecco un semplice codice per calcolare l'attuale utilizzo della memoria in megabyte:

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

Vorrei anche aggiungere il seguente modo per tenere traccia del carico della CPU:

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

Puoi leggere di più qui

2
sbeliakov

JConsole è un modo semplice per monitorare un'applicazione in esecuzione Java oppure puoi usare un Profiler per ottenere informazioni più dettagliate sulla tua applicazione. Mi piace usare NetBeans Profiler per questo.

1
blahspam

YourKit Java profiler è un'ottima soluzione commerciale. Puoi trovare ulteriori informazioni nei documenti su CPU profiling e memory profiling .

1
Gregg

Se si utilizza Tomcat, controllare Psi Probe , che consente di monitorare il consumo di memoria interna ed esterna e un host di altre aree.

1
Tim Howland

Per Eclipse, è possibile utilizzare TPTP (Test and Performance Tools Platform) per analizzare l'utilizzo della memoria e così via --- lteriori informazioni

0
Fuangwith S.