¿Cómo reviso el uso de CPU y memoria en Java?

Question

Necesito verificar el uso de CPU y memoria para el servidor en java, ¿alguien sabe cómo se podría hacer?

Answer 1

Si está utilizando Tomcat, consulte Psi Probe, que le permite controlar el consumo de memoria interna y externa, así como una serie de otras áreas.

Answer 2

El objeto Runtime de Java puede informar el uso de memoria de la JVM. Para el consumo de CPU, tendrá que utilizar una utilidad externa, como Top Manager de Unix o Windows Process Manager.

Answer 3

Para uso de la memoria, el siguiente trabajo,

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

Para uso de la CPU, tendrá que utilizar una aplicación externa para medirlo.

Answer 4

JConsole es una manera fácil de controlar una aplicación Java en ejecución o puede usar un Analizador para obtener información más detallada sobre su aplicación. Me gusta usar el NetBeans Profiler para esto.

Answer 5

Si utiliza la solución runtime/totalMemory que se ha publicado en muchas respuestas aquí (he hecho mucho), asegúrese de forzar dos colecciones de basura primero si desea resultados bastante precisos/consistentes.

Para effiency Java generalmente permite que la basura ocupe toda la memoria antes de forzar un GC, e incluso entonces no es generalmente un GC completo, por lo que los resultados de runtime.freeMemory() siempre estarán entre la cantidad "real" de memoria libre y 0.

El primer GC no tiene todo, se lleva la mayor parte.

La mejora es que si solo hace la llamada a freeMemory() obtendrá un número que es absolutamente inútil y varía ampliamente, pero si hace 2 gc, es un indicador muy confiable. También hace que la rutina MUCHO más lenta (segundos, posiblemente).

Answer 6

Si buscando específicamente en la memoria 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/>"); 

Sin embargo, éstas deben tomarse sólo una estimación ...

Answer 7

Desde Java JDK 1.5 viene con una nueva herramienta: JConsole wich puede mostrarle el uso de la CPU y la memoria de cualquier JVM 1.5 o posterior. Puede hacer gráficos de estos parámetros, exportar a CSV, mostrar el número de clases cargadas, el número de instancias, deadlocks, hilos, etc. ...

Answer 8

El generador de perfiles YourKit es una excelente solución comercial. Puede encontrar más información en los documentos en CPU profiling y memory profiling.

Answer 9

JMX, los MXbeans (ThreadMXBean, etc.) proporcionados le darán usos de memoria y CPU.

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

Answer 10

Si está utilizando la JVM de Sun, y está interesado en el uso de la memoria interna de la aplicación (la cantidad de la memoria asignada su aplicación está utilizando) Prefiero encender las JVM de basura incorporado registro de recopilación. Simplemente agrega -verbose: gc al comando de inicio.

A partir de la documentación de Sun:

El argumento de la línea de comandos -verbose: gc imprime la información en cada colección. Tenga en cuenta que el formato de la salida -verbose: gc está sujeto a para cambiar entre versiones de la plataforma J2SE. Por ejemplo, aquí está salida de una aplicación de servidor grande:

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

Aquí vemos dos colecciones menores y un gran uno. Los números antes y después de la flecha

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

indican el tamaño combinado de objetos vivos antes y después de la recolección de basura , respectivamente. Después de recopilaciones menores, el recuento incluye objetos que no están necesariamente vivos pero que no pueden recuperarse, ya sea porque están directamente vivos, o porque están dentro o a los que se hace referencia de la generación mantenida. El número en paréntesis

(776768K) (in the first line) 

es el espacio total disponible, sin contar el espacio en el generación permanente, que es el montón total menos uno de los espacios sobrevivientes. La colección menor tomó aproximadamente un cuarto de segundo.

0.2300771 secs (in the first line) 

Para más información ver: http://java.sun.com/docs/hotspot/gc5.0/gc_tuning_5.html

Answer 11

Aquí hay un código simple de calcular el uso actual de memoria en megabytes:

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

Answer 12

para Eclipse, puede utilizar TPTP (Prueba y Performance Tools Platform) para analizar el uso de memoria, etc. more information

Answer 13

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

Answer 14

De here

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

Answer 15

También me gustaría añadir la siguiente manera de seguir carga de la 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(); 
} 

Usted puede leer más here