Obter informações do sistema no nível do sistema operacional

Atualmente, estou criando um aplicativo Java que pode acabar sendo executado em muitas plataformas diferentes, mas principalmente em variantes do Solaris, Linux e Windows.

Alguém conseguiu extrair com sucesso informações como o espaço em disco atual usado, a utilização da CPU e a memória usada no sistema operacional subjacente? E o que o próprio aplicativo Java está consumindo?

De preferência, eu gostaria de obter essas informações sem usar o JNI.

Você pode obter algumas informações de memória limitadas da classe Runtime. Realmente não é exatamente o que você está procurando, mas pensei em fornecer isso por uma questão de integridade. Aqui está um pequeno exemplo. Editar: Você também pode obter informações de uso do disco da classe java.io.File. O material de uso do espaço em disco requer Java 1.6 ou superior.

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

O pacote java.lang.management fornece muito mais informações que o Runtime - por exemplo, ele fornece memória heap ( ManagementFactory.getMemoryMXBean().getHeapMemoryUsage()) separada da memória não heap ( ManagementFactory.getMemoryMXBean().getNonHeapMemoryUsage()).

Você também pode obter o uso da CPU do processo (sem escrever seu próprio código JNI), mas você precisa para lançar o java.lang.management.OperatingSystemMXBeana um com.sun.management.OperatingSystemMXBean. Isso funciona no Windows e Linux, eu não testei em nenhum outro lugar.

Por exemplo ... chame o método get getCpuUsage () com mais frequência para obter leituras mais precisas.

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

Eu acho que o melhor método disponível para implementar a API SIGAR da Hyperic . Ele funciona para a maioria dos principais sistemas operacionais (muito perto de qualquer coisa moderna) e é muito fácil de trabalhar. Os desenvolvedores são muito responsivos em seus fóruns e listas de discussão. Também gosto que seja licenciado pela GPL2 Apache . Eles fornecem uma tonelada de exemplos em Java também!

SIGAR == Sistema de informações, coleta e relatórios ferramenta.

Há um projeto Java que usa JNA (portanto, não há bibliotecas nativas para instalar) e está em desenvolvimento ativo. Atualmente, ele suporta Linux, OSX, Windows, Solaris e FreeBSD e fornece informações sobre RAM, CPU, bateria e sistema de arquivos.

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

Para janelas eu fui por aqui.

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

Aqui está o link com detalhes.

Você pode obter algumas informações no nível do sistema usando System.getenv(), passando o nome da variável de ambiente relevante como parâmetro. Por exemplo, no Windows:

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

Para outros sistemas operacionais, a presença / ausência e os nomes das variáveis ​​de ambiente relevantes serão diferentes.

Adicione dependência OSHI via maven:

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

Obtenha uma capacidade da bateria restante em porcentagem:

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

Veja as APIs disponíveis no pacote java.lang.management . Por exemplo:

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

Existem muitas outras coisas úteis lá também.

Geralmente, para obter informações de baixo nível do sistema operacional, você pode chamar comandos específicos do sistema operacional que fornecem as informações desejadas com o Runtime.exec () ou ler arquivos como / proc / * no Linux.

O uso da CPU não é simples - java.lang.management via com.sun.management.OperatingSystemMXBean.getProcessCpuTime chega perto (consulte o excelente trecho de código de Patrick acima), mas observe que ele só dá acesso ao tempo que a CPU gastou em seu processo. ele não informa sobre o tempo de CPU gasto em outros processos ou mesmo o tempo de CPU executando atividades do sistema relacionadas ao seu processo.

por exemplo, eu tenho um processo java intensivo em rede - é a única coisa em execução e a CPU está em 99%, mas apenas 55% disso é relatado como "CPU do processador".

nem me inicie na "carga média", pois é quase inútil, apesar de ser o único item relacionado à CPU no bean MX. se apenas o sol em sua sabedoria ocasional expusesse algo como "getTotalCpuTime" ...

para monitoramento sério da CPU, o SIGAR mencionado por Matt parece ser a melhor aposta.

Em Windows, você pode executar o systeminfocomando e recuperar sua saída, por exemplo, com o seguinte código:

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 você estiver usando o Jrockit VM, eis uma outra maneira de obter o uso da CPU da VM. O bean de tempo de execução também pode fornecer a carga da CPU por processador. Eu usei isso apenas no Red Hat Linux para observar o desempenho do Tomcat. Você precisa habilitar o JMX remote em catalina.sh para que isso funcione.

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

Ainda está em desenvolvimento, mas você já pode usar o jHardware

É uma biblioteca simples que captura dados do sistema usando Java. Funciona em Linux e 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());
//[...]

Uma maneira simples que pode ser usada para obter as informações no nível do SO e eu testei no meu Mac, que funciona bem:

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

Você pode encontrar muitas métricas relevantes do sistema operacional aqui

Ei, você pode fazer isso com a integração java / com. Ao acessar os recursos WMI, você pode obter todas as informações.

Para obter a média de carregamento do sistema de 1 minuto, 5 minutos e 15 minutos dentro do código java, você pode fazer isso executando o comando cat /proc/loadavgusando e interpretando-o como abaixo:

    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 para obter a memória do sistema físico executando o comando free -me interpretando-o como abaixo:

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