Systeminformationen auf Betriebssystemebene abrufen

Ich baue derzeit eine Java-App, die möglicherweise auf vielen verschiedenen Plattformen ausgeführt wird, aber hauptsächlich auf Varianten von Solaris, Linux und Windows.

Konnte jemand erfolgreich Informationen wie den aktuell verwendeten Speicherplatz, die CPU-Auslastung und den im zugrunde liegenden Betriebssystem verwendeten Speicher extrahieren? Was ist mit dem, was die Java-App selbst verbraucht?

Am liebsten möchte ich diese Informationen ohne JNI erhalten.

Sie können einige Informationen zum begrenzten Speicher von der Runtime-Klasse erhalten. Es ist wirklich nicht genau das, wonach Sie suchen, aber ich dachte, ich würde es der Vollständigkeit halber bereitstellen. Hier ist ein kleines Beispiel. Bearbeiten: Sie können Informationen zur Datenträgernutzung auch von der Klasse java.io.File abrufen. Für die Speicherplatznutzung ist Java 1.6 oder höher erforderlich.

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

Das Paket java.lang.management bietet Ihnen viel mehr Informationen als Runtime - zum Beispiel gibt es Ihnen Heap-Speicher ( ManagementFactory.getMemoryMXBean().getHeapMemoryUsage()) getrennt von Nicht-Heap-Speicher ( ManagementFactory.getMemoryMXBean().getNonHeapMemoryUsage()).

Sie können auch Prozess der CPU - Auslastung (ohne eigenen JNI Code schreiben), aber Sie müssen das werfen , java.lang.management.OperatingSystemMXBeanum ein com.sun.management.OperatingSystemMXBean. Dies funktioniert unter Windows und Linux, ich habe es nicht anderswo getestet.

Beispiel: Rufen Sie die Methode get getCpuUsage () häufiger auf, um genauere Messwerte zu erhalten.

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

Ich denke, die beste Methode ist die Implementierung der SIGAR-API von Hyperic . Es funktioniert für die meisten gängigen Betriebssysteme (fast alles Moderne) und ist sehr einfach zu handhaben. Die Entwickler reagieren sehr schnell auf ihre Foren und Mailinglisten. Mir gefällt auch, dass es GPL2 Apache lizenziert ist . Sie bieten auch in Java eine Menge Beispiele!

SIGAR == Systeminformations-, Erfassungs- und Berichterstellungstool.

Es gibt ein Java-Projekt, das JNA verwendet (also keine nativen Bibliotheken zu installieren) und sich in der aktiven Entwicklung befindet. Es unterstützt derzeit Linux, OSX, Windows, Solaris und FreeBSD und bietet Informationen zu RAM, CPU, Akku und Dateisystem.

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

Für Fenster bin ich diesen Weg gegangen.

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

Hier ist der Link mit Details.

Sie können einige Informationen auf Systemebene abrufen System.getenv(), indem Sie den entsprechenden Umgebungsvariablennamen als Parameter übergeben. Zum Beispiel unter Windows:

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

Bei anderen Betriebssystemen unterscheiden sich das Vorhandensein / Fehlen und die Namen der relevanten Umgebungsvariablen.

Fügen Sie die OSHI-Abhängigkeit über maven hinzu:

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

Erhalten Sie eine verbleibende Batteriekapazität in Prozent:

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

Schauen Sie sich die APIs an, die im Paket java.lang.management verfügbar sind . Beispielsweise:

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

Es gibt dort auch viele andere nützliche Dinge.

Um Informationen zum Betriebssystem auf niedriger Ebene zu erhalten, können Sie normalerweise betriebssystemspezifische Befehle aufrufen, die Ihnen die gewünschten Informationen mit Runtime.exec () geben, oder Dateien wie / proc / * unter Linux lesen.

Die CPU-Auslastung ist nicht einfach - java.lang.management über com.sun.management.OperatingSystemMXBean.getProcessCpuTime kommt dem nahe (siehe Patricks hervorragendes Code-Snippet oben), aber beachten Sie, dass es nur Zugriff auf die Zeit gibt, die die CPU in Ihrem Prozess verbracht hat. Es gibt keinen Aufschluss über die CPU-Zeit, die in anderen Prozessen verbracht wurde, oder sogar über die CPU-Zeit, die für Systemaktivitäten im Zusammenhang mit Ihrem Prozess aufgewendet wurde.

Zum Beispiel habe ich einen netzwerkintensiven Java-Prozess - es ist das einzige, was läuft und die CPU ist bei 99%, aber nur 55% davon werden als "Prozessor-CPU" gemeldet.

Lassen Sie mich nicht einmal mit "Load Average" anfangen, da es so gut wie nutzlos ist, obwohl es das einzige CPU-bezogene Element auf der MX-Bean ist. wenn nur die Sonne in ihrer gelegentlichen Weisheit etwas wie "getTotalCpuTime" aussetzen würde ...

Für eine ernsthafte CPU-Überwachung scheint das von Matt erwähnte SIGAR die beste Wahl zu sein.

Ein Windows, Sie können den systeminfoBefehl ausführen und seine Ausgabe beispielsweise mit dem folgenden Code abrufen:

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

Wenn Sie Jrockit VM verwenden, finden Sie hier eine andere Möglichkeit, die CPU-Auslastung der VM zu ermitteln. Runtime Bean kann Ihnen auch die CPU-Auslastung pro Prozessor geben. Ich habe dies nur unter Red Hat Linux verwendet, um die Leistung von Tomcat zu beobachten. Sie müssen JMX remote in Catalina.sh aktivieren, damit dies funktioniert.

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

Es befindet sich noch in der Entwicklung, aber Sie können jHardware bereits verwenden

Es ist eine einfache Bibliothek, die Systemdaten mit Java verschrottet. Es funktioniert sowohl unter Linux als auch unter 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());
//[...]

Ein einfacher Weg, um Informationen auf Betriebssystemebene abzurufen, und den ich auf meinem Mac getestet habe und der gut funktioniert:

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

Sie können viele relevante Kennzahlen des Betriebssystems finden Sie hier

Hey, das kannst du mit Java / Com Integration machen. Durch den Zugriff auf WMI-Funktionen erhalten Sie alle Informationen.

Um den Systemlastdurchschnitt von 1 Minute, 5 Minuten und 15 Minuten innerhalb des Java-Codes zu erhalten, können Sie dies tun, indem Sie den Befehl cat /proc/loadavgwie folgt ausführen und interpretieren:

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

Und um den physischen Systemspeicher zu erhalten, indem Sie den Befehl ausführen free -mund ihn dann wie folgt interpretieren:

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