Dapatkan informasi sistem tingkat OS

Saat ini saya sedang membangun aplikasi Java yang akhirnya bisa dijalankan pada banyak platform yang berbeda, tetapi terutama varian Solaris, Linux dan Windows.

Adakah yang berhasil mengekstraksi informasi seperti ruang disk saat ini yang digunakan, pemanfaatan CPU, dan memori yang digunakan dalam OS yang mendasarinya? Bagaimana dengan apa yang dikonsumsi aplikasi Java itu sendiri?

Lebih disukai saya ingin mendapatkan informasi ini tanpa menggunakan JNI.

Anda bisa mendapatkan beberapa informasi memori terbatas dari kelas Runtime. Sebenarnya bukan apa yang Anda cari, tapi saya pikir saya akan menyediakannya demi kelengkapan. Ini adalah contoh kecil. Sunting: Anda juga bisa mendapatkan informasi penggunaan disk dari kelas java.io.File. Hal-hal penggunaan ruang disk memerlukan Java 1.6 atau lebih tinggi.

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

The java.lang.management paket tidak memberikan info lebih banyak daripada Runtime - misalnya itu akan memberikan memori tumpukan ( ManagementFactory.getMemoryMXBean().getHeapMemoryUsage()) terpisah dari memori non-tumpukan ( ManagementFactory.getMemoryMXBean().getNonHeapMemoryUsage()).

Anda juga bisa mendapatkan proses penggunaan CPU (tanpa menulis kode JNI Anda sendiri), tetapi Anda harus menggunakan java.lang.management.OperatingSystemMXBeana com.sun.management.OperatingSystemMXBean. Ini berfungsi pada Windows dan Linux, saya belum mengujinya di tempat lain.

Misalnya ... panggil metode get getCpuUsage () lebih sering untuk mendapatkan pembacaan yang lebih akurat.

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

Saya pikir metode terbaik di luar sana adalah mengimplementasikan SIGAR API oleh Hyperic . Ini bekerja untuk sebagian besar sistem operasi utama (sangat dekat dengan apa pun yang modern) dan sangat mudah digunakan. Pengembang sangat responsif terhadap forum dan milis mereka. Saya juga suka bahwa itu adalah lisensi GPL2 Apache . Mereka memberikan banyak contoh di Jawa juga!

SIGAR == Alat Informasi, Pengumpulan Dan Pelaporan Sistem.

Ada proyek Java yang menggunakan JNA (jadi tidak ada perpustakaan asli untuk menginstal) dan sedang dalam pengembangan aktif. Saat ini mendukung Linux, OSX, Windows, Solaris dan FreeBSD dan menyediakan RAM, CPU, Baterai dan informasi sistem file.

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

Untuk windows saya pergi ke sini.

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

Ini tautan dengan detail.

Anda bisa mendapatkan beberapa informasi tingkat sistem dengan menggunakan System.getenv(), meneruskan nama variabel lingkungan yang relevan sebagai parameter. Misalnya, di Windows:

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

Untuk sistem operasi lain, ada / tidaknya dan nama variabel lingkungan yang relevan akan berbeda.

Tambahkan ketergantungan OSHI melalui pakar:

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

Persentase kapasitas baterai tersisa:

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

Lihat API yang tersedia di paket manajemen java.lang.man . Sebagai contoh:

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

Ada banyak hal berguna lainnya di sana juga.

Biasanya, untuk mendapatkan informasi OS tingkat rendah Anda dapat memanggil perintah khusus OS yang memberi Anda informasi yang Anda inginkan dengan Runtime.exec () atau membaca file seperti / proc / * di Linux.

Penggunaan CPU tidak mudah - java.lang.management via com.sun.management.OperatingSystemMXBean.getProcessCpuTime mendekati (lihat cuplikan kode Patrick yang sangat baik di atas) tetapi perhatikan bahwa itu hanya memberikan akses ke waktu yang dihabiskan CPU dalam proses Anda. itu tidak akan memberi tahu Anda tentang waktu CPU yang dihabiskan dalam proses lain, atau bahkan waktu CPU yang dihabiskan untuk melakukan aktivitas sistem yang terkait dengan proses Anda.

misalnya saya punya proses java jaringan-intensif - itu satu-satunya yang berjalan dan CPU pada 99% tetapi hanya 55% dari yang dilaporkan sebagai "prosesor CPU".

bahkan tidak memulai saya pada "rata-rata memuat" karena itu tidak berguna, meskipun menjadi satu-satunya item yang berhubungan dengan cpu pada kacang MX. jika hanya berjemur dalam kebijaksanaan sesekali mereka mengekspos sesuatu seperti "getTotalCpuTime" ...

untuk pemantauan CPU yang serius SIGAR yang disebutkan oleh Matt tampaknya merupakan taruhan terbaik.

Pada Windows, Anda dapat menjalankan systeminfoperintah dan mengambil outputnya misalnya dengan kode berikut:

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

Jika Anda menggunakan Jrockit VM maka berikut adalah cara lain untuk mendapatkan penggunaan CPU VM. Kacang Runtime juga dapat memberi Anda beban CPU per prosesor. Saya hanya menggunakan ini di Red Hat Linux untuk mengamati kinerja Tomcat. Anda harus mengaktifkan JMX remote di catalina.sh agar ini berfungsi.

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

Ini masih dalam pengembangan tetapi Anda sudah bisa menggunakan jHardware

Ini adalah perpustakaan sederhana yang memotong data sistem menggunakan Java. Ia bekerja di Linux dan 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());
//[...]

Salah satu cara sederhana yang dapat digunakan untuk mendapatkan informasi level OS dan saya uji di Mac saya yang berfungsi dengan baik:

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

Anda dapat menemukan banyak metrik yang relevan dari sistem operasi di sini

Hai Anda dapat melakukan ini dengan integrasi java / com. Dengan mengakses fitur WMI, Anda dapat memperoleh semua informasi.

Untuk mendapatkan System Load rata - rata 1 menit, 5 menit dan 15 menit di dalam kode java, Anda bisa melakukan ini dengan mengeksekusi perintah cat /proc/loadavgmenggunakan dan menafsirkannya seperti di bawah ini:

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

Dan untuk mendapatkan memori sistem fisik dengan mengeksekusi perintah free -mdan kemudian menafsirkannya sebagai berikut:

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