Ottieni informazioni sul sistema a livello di sistema operativo

Attualmente sto costruendo un'app Java che potrebbe essere eseguita su molte piattaforme diverse, ma principalmente varianti di Solaris, Linux e Windows.

Qualcuno è stato in grado di estrarre con successo informazioni come lo spazio su disco corrente utilizzato, l'utilizzo della CPU e la memoria utilizzata nel sistema operativo sottostante? Che dire di ciò che l'app Java stessa sta consumando?

Preferibilmente vorrei ottenere queste informazioni senza usare JNI.

È possibile ottenere alcune informazioni sulla memoria limitate dalla classe Runtime. Non è esattamente quello che stai cercando, ma ho pensato che l'avrei fornito per completezza. Ecco un piccolo esempio. Modifica: è inoltre possibile ottenere informazioni sull'utilizzo del disco dalla classe java.io.File. L'utilizzo dello spazio su disco richiede Java 1.6 o versione successiva.

public class Main {
  public static void main(String[] args) {
    /* Total number of processors or cores available to the JVM */
    System.out.println("Available processors (cores): " + 
        Runtime.getRuntime().availableProcessors());

    /* Total amount of free memory available to the JVM */
    System.out.println("Free memory (bytes): " + 
        Runtime.getRuntime().freeMemory());

    /* This will return Long.MAX_VALUE if there is no preset limit */
    long maxMemory = Runtime.getRuntime().maxMemory();
    /* Maximum amount of memory the JVM will attempt to use */
    System.out.println("Maximum memory (bytes): " + 
        (maxMemory == Long.MAX_VALUE ? "no limit" : maxMemory));

    /* Total memory currently available to the JVM */
    System.out.println("Total memory available to JVM (bytes): " + 
        Runtime.getRuntime().totalMemory());

    /* Get a list of all filesystem roots on this system */
    File[] roots = File.listRoots();

    /* For each filesystem root, print some info */
    for (File root : roots) {
      System.out.println("File system root: " + root.getAbsolutePath());
      System.out.println("Total space (bytes): " + root.getTotalSpace());
      System.out.println("Free space (bytes): " + root.getFreeSpace());
      System.out.println("Usable space (bytes): " + root.getUsableSpace());
    }
  }
}

Il pacchetto java.lang.management fornisce molte più informazioni di Runtime, ad esempio ti darà memoria heap ( ManagementFactory.getMemoryMXBean().getHeapMemoryUsage()) separata dalla memoria non heap ( ManagementFactory.getMemoryMXBean().getNonHeapMemoryUsage()).

È inoltre possibile ottenere l'utilizzo della CPU del processo (senza scrivere il proprio codice JNI), ma è necessario eseguire il cast java.lang.management.OperatingSystemMXBeandi a com.sun.management.OperatingSystemMXBean. Funziona su Windows e Linux, non l'ho provato altrove.

Ad esempio ... chiama il metodo get getCpuUsage () più frequentemente per ottenere letture più accurate.

public class PerformanceMonitor { 
    private int  availableProcessors = getOperatingSystemMXBean().getAvailableProcessors();
    private long lastSystemTime      = 0;
    private long lastProcessCpuTime  = 0;

    public synchronized double getCpuUsage()
    {
        if ( lastSystemTime == 0 )
        {
            baselineCounters();
            return;
        }

        long systemTime     = System.nanoTime();
        long processCpuTime = 0;

        if ( getOperatingSystemMXBean() instanceof OperatingSystemMXBean )
        {
            processCpuTime = ( (OperatingSystemMXBean) getOperatingSystemMXBean() ).getProcessCpuTime();
        }

        double cpuUsage = (double) ( processCpuTime - lastProcessCpuTime ) / ( systemTime - lastSystemTime );

        lastSystemTime     = systemTime;
        lastProcessCpuTime = processCpuTime;

        return cpuUsage / availableProcessors;
    }

    private void baselineCounters()
    {
        lastSystemTime = System.nanoTime();

        if ( getOperatingSystemMXBean() instanceof OperatingSystemMXBean )
        {
            lastProcessCpuTime = ( (OperatingSystemMXBean) getOperatingSystemMXBean() ).getProcessCpuTime();
        }
    }
}

Penso che il metodo migliore in circolazione sia implementare l' API SIGAR di Hyperic . Funziona con la maggior parte dei principali sistemi operativi (dannatamente vicino a qualsiasi cosa moderna) ed è molto facile da lavorare. Gli sviluppatori sono molto reattivi sul loro forum e mailing list. Mi piace anche che abbia la licenza GPL2 Apache . Forniscono moltissimi esempi anche in Java!

SIGAR == Strumento di informazioni di sistema, raccolta e reportistica.

C'è un progetto Java che utilizza JNA (quindi nessuna libreria nativa da installare) ed è in sviluppo attivo. Attualmente supporta Linux, OSX, Windows, Solaris e FreeBSD e fornisce informazioni su RAM, CPU, batteria e file system.

• https://github.com/oshi/oshi

Per Windows sono andato in questo modo.

    com.sun.management.OperatingSystemMXBean os = (com.sun.management.OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();

    long physicalMemorySize = os.getTotalPhysicalMemorySize();
    long freePhysicalMemory = os.getFreePhysicalMemorySize();
    long freeSwapSize = os.getFreeSwapSpaceSize();
    long commitedVirtualMemorySize = os.getCommittedVirtualMemorySize();

Ecco il link con i dettagli.

È possibile ottenere alcune informazioni a livello di sistema utilizzando System.getenv(), passando il nome della variabile di ambiente pertinente come parametro. Ad esempio, su Windows:

System.getenv("PROCESSOR_IDENTIFIER")
System.getenv("PROCESSOR_ARCHITECTURE")
System.getenv("PROCESSOR_ARCHITEW6432")
System.getenv("NUMBER_OF_PROCESSORS")

Per altri sistemi operativi la presenza / assenza e i nomi delle variabili di ambiente rilevanti differiranno.

Aggiungi dipendenza OSHI tramite Maven:

<dependency>
    <groupId>com.github.dblock</groupId>
    <artifactId>oshi-core</artifactId>
    <version>2.2</version>
</dependency>

Ottieni una capacità della batteria rimasta in percentuale:

SystemInfo si = new SystemInfo();
HardwareAbstractionLayer hal = si.getHardware();
for (PowerSource pSource : hal.getPowerSources()) {
    System.out.println(String.format("%n %s @ %.1f%%", pSource.getName(), pSource.getRemainingCapacity() * 100d));
}

Dai un'occhiata alle API disponibili nel pacchetto java.lang.management . Per esempio:

• OperatingSystemMXBean.getSystemLoadAverage()
• ThreadMXBean.getCurrentThreadCpuTime()
• ThreadMXBean.getCurrentThreadUserTime()

Ci sono anche molte altre cose utili.

Di solito, per ottenere informazioni sul sistema operativo di basso livello, è possibile chiamare comandi specifici del sistema operativo che forniscono le informazioni desiderate con Runtime.exec () o leggere file come / proc / * in Linux.

L'utilizzo della CPU non è semplice: java.lang.management tramite com.sun.management.OperatingSystemMXBean.getProcessCpuTime si avvicina (vedi l'eccellente frammento di codice di Patrick sopra) ma nota che dà accesso solo al tempo impiegato dalla CPU nel processo. non ti dirà del tempo della CPU speso in altri processi, né del tempo della CPU impiegato per svolgere attività di sistema relative al tuo processo.

ad esempio, ho un processo java ad alta intensità di rete: è l'unica cosa in esecuzione e la CPU è al 99%, ma solo il 55% è segnalato come "CPU del processore".

non farmi nemmeno iniziare con il "carico medio" dato che è quasi inutile, nonostante sia l'unico elemento relativo alla CPU sul bean MX. se solo il sole nella loro saggezza occasionale esponesse qualcosa come "getTotalCpuTime" ...

per un serio monitoraggio della CPU SIGAR citato da Matt sembra la scommessa migliore.

Sì Windows, è possibile eseguire il systeminfocomando e recuperare l'output, ad esempio con il seguente codice:

private static class WindowsSystemInformation
{
    static String get() throws IOException
    {
        Runtime runtime = Runtime.getRuntime();
        Process process = runtime.exec("systeminfo");
        BufferedReader systemInformationReader = new BufferedReader(new InputStreamReader(process.getInputStream()));

        StringBuilder stringBuilder = new StringBuilder();
        String line;

        while ((line = systemInformationReader.readLine()) != null)
        {
            stringBuilder.append(line);
            stringBuilder.append(System.lineSeparator());
        }

        return stringBuilder.toString().trim();
    }
}

Se si utilizza Jrockit VM, ecco un altro modo per ottenere l'utilizzo della CPU VM. Il bean di runtime può anche fornire il carico della CPU per processore. L'ho usato solo su Red Hat Linux per osservare le prestazioni di Tomcat. Devi abilitare il telecomando JMX in catalina.sh affinché funzioni.

JMXServiceURL url = new JMXServiceURL("service:jmx:rmi:///jndi/rmi://my.tomcat.host:8080/jmxrmi");
JMXConnector jmxc = JMXConnectorFactory.connect(url, null);     
MBeanServerConnection conn = jmxc.getMBeanServerConnection();       
ObjectName name = new ObjectName("oracle.jrockit.management:type=Runtime");
Double jvmCpuLoad =(Double)conn.getAttribute(name, "VMGeneratedCPULoad");

È ancora in fase di sviluppo ma è già possibile utilizzarlo jHardware

È una semplice libreria che elimina i dati di sistema usando Java. Funziona sia in Linux che in Windows.

ProcessorInfo info = HardwareInfo.getProcessorInfo();
//Get named info
System.out.println("Cache size: " + info.getCacheSize());        
System.out.println("Family: " + info.getFamily());
System.out.println("Speed (Mhz): " + info.getMhz());
//[...]

Un modo semplice che può essere utilizzato per ottenere informazioni a livello di sistema operativo e ho testato sul mio Mac che funziona bene:

 OperatingSystemMXBean osBean =
        (OperatingSystemMXBean)ManagementFactory.getOperatingSystemMXBean();
    return osBean.getProcessCpuLoad();

Puoi trovare molte metriche rilevanti del sistema operativo qui

Ehi, puoi farlo con l'integrazione java / com. Accedendo alle funzionalità WMI è possibile ottenere tutte le informazioni.

Per ottenere la media del caricamento del sistema di 1 minuto, 5 minuti e 15 minuti all'interno del codice java, è possibile farlo eseguendo il comando cat /proc/loadavgutilizzando e interpretandolo come di seguito:

    Runtime runtime = Runtime.getRuntime();

    BufferedReader br = new BufferedReader(
        new InputStreamReader(runtime.exec("cat /proc/loadavg").getInputStream()));

    String avgLine = br.readLine();
    System.out.println(avgLine);
    List<String> avgLineList = Arrays.asList(avgLine.split("\\s+"));
    System.out.println(avgLineList);
    System.out.println("Average load 1 minute : " + avgLineList.get(0));
    System.out.println("Average load 5 minutes : " + avgLineList.get(1));
    System.out.println("Average load 15 minutes : " + avgLineList.get(2));

E per ottenere la memoria di sistema fisica eseguendo il comando free -me quindi interpretandolo come di seguito:

Runtime runtime = Runtime.getRuntime();

BufferedReader br = new BufferedReader(
    new InputStreamReader(runtime.exec("free -m").getInputStream()));

String line;
String memLine = "";
int index = 0;
while ((line = br.readLine()) != null) {
  if (index == 1) {
    memLine = line;
  }
  index++;
}
//                  total        used        free      shared  buff/cache   available
//    Mem:          15933        3153        9683         310        3097       12148
//    Swap:          3814           0        3814

List<String> memInfoList = Arrays.asList(memLine.split("\\s+"));
int totalSystemMemory = Integer.parseInt(memInfoList.get(1));
int totalSystemUsedMemory = Integer.parseInt(memInfoList.get(2));
int totalSystemFreeMemory = Integer.parseInt(memInfoList.get(3));

System.out.println("Total system memory in mb: " + totalSystemMemory);
System.out.println("Total system used memory in mb: " + totalSystemUsedMemory);
System.out.println("Total system free memory in mb: "   + totalSystemFreeMemory);