h2 { color: #333 !important; } p { color: #666 !important; } ul { color: #666 !important; } 1\. Introducción ---------------- Cuando se trata de monitorear el uso de CPU, el estado de la memoria o el espacio en disco en Java, muchos programadores se preguntan: “¿Es necesario ejecutar comandos del sistema o utilizar JNI?”. ¡La respuesta es no! En este artículo, exploraremos cómo podemos utilizar **OSHI** (Operating System and Hardware Information), una biblioteca pura de Java que permite obtener detalles a nivel de sistema sin depender de ningún código nativo. OSHI actúa como un puente entre nuestras aplicaciones Java y las API del sistema operativo, recolectando información útil sobre el sistema operativo, el hardware y la red de manera multiplataforma. Esta entrada está diseñada para ofrecer una visión integral sobre cómo configurar y utilizar OSHI para monitorizar el sistema en aplicaciones Java. [Más información sobre OSHI aquí](https://github.com/oshi/oshi). 2\. ¿Por Qué Utilizar OSHI para Monitoreo del Sistema? ------------------------------------------------------ Es natural preguntarse: “¿Por qué no usar `Runtime.exec()` o `System.getProperty()`?”. Estas aproximaciones tienen limitaciones significativas. Mientras que `System.getProperty()` puede obtener el nombre y versión del sistema operativo, `Runtime.exec()` requiere comandos específicos del sistema, lo que lo hace intensivo en mantenimiento y menos portátil. OSHI, por otro lado, **funciona con los sistemas operativos más populares (Windows, macOS, Linux)**. Proporciona información detallada sobre la CPU, RAM, discos, sensores y redes sin necesidad de código nativo, es **ligero y fácil de usar**. Solo necesitamos agregar una dependencia a nuestro proyecto. 3\. Características Clave y Ventajas ------------------------------------ Con OSHI, podemos: * Obtener detalles del sistema operativo: nombre, versión, arquitectura y tiempo de actividad. * Monitorear el uso de la CPU, detalles del núcleo y velocidad del procesador. * Obtener estadísticas de memoria: RAM total, memoria disponible, uso de intercambio. * Recuperar información sobre el almacenamiento del disco: particiones, velocidad de lectura/escritura. * Rastrear interfaces de red, direcciones IP y uso de ancho de banda. * Acceder a datos de sensores como temperatura del CPU, velocidades de ventilador y voltajes (si está soportado). Ahora, veamos cómo implementar estas características en nuestro proyecto. 4\. Configuración de OSHI en un Proyecto Java --------------------------------------------- ### Agregando la Dependencia Antes de comenzar, necesitamos agregar OSHI a nuestro proyecto. Si estamos utilizando Maven, debemos incluir la siguiente dependencia en nuestro `pom.xml`: com.github.oshi oshi-core 6.4.2 Una vez agregada, ¡OSHI estará listo para usarse! 5\. Recuperando Información Básica del Sistema ---------------------------------------------- ### 5.1. Obteniendo Detalles del Sistema Operativo Imaginemos que queremos saber qué sistema operativo estamos utilizando, su versión y si es de 32 o 64 bits. Veamos cómo hacerlo fácilmente con OSHI: @Test void givenSystem_whenUsingOSHI_thenExtractOSDetails() { SystemInfo si = new SystemInfo(); OperatingSystem os = si.getOperatingSystem(); assertNotNull(os, "El objeto del Sistema Operativo no debe ser nulo"); assertNotNull(os.getFamily(), "La familia del SO no debe ser nula"); assertNotNull(os.getVersionInfo(), "La información de la versión del SO no debe ser nula"); assertTrue(os.getBitness() == 32 || os.getBitness() == 64, "La arquitectura del SO debe ser 32 o 64 bits"); } En este código, creamos un objeto `SystemInfo` de la biblioteca OSHI para acceder a detalles relacionados con el sistema. Obtenemos la instancia de `OperatingSystem`, que proporciona información sobre la familia del sistema operativo, la versión y la arquitectura. ### 5.2. Verificando el Tiempo de Actividad del Sistema ¿Alguna vez te has preguntado cuánto tiempo ha estado funcionando tu sistema sin reinicio? El tiempo de actividad del sistema nos lo dice: @Test void givenSystem_whenUsingOSHI_thenExtractSystemUptime() { SystemInfo si = new SystemInfo(); OperatingSystem os = si.getOperatingSystem(); long uptime = os.getSystemUptime(); assertTrue(uptime >= 0, "El tiempo de actividad del sistema debe ser no negativo"); try { Thread.sleep(2000); } catch (InterruptedException e) { fail("Prueba interrumpida"); } long newUptime = os.getSystemUptime(); assertTrue(newUptime >= uptime, "El tiempo de actividad debe aumentar con el tiempo"); } Aquí, recuperamos el tiempo de actividad del sistema y comprobamos que es no negativo, asegurando así un valor válido. Después, pausamos el hilo durante dos segundos y verificamos que el tiempo de actividad aumenta. Si vemos un valor como `3600 segundos`, significa que nuestra máquina lleva encendida durante una hora. 6\. Monitoreo de la CPU con OSHI -------------------------------- La CPU (Unidad Central de Procesamiento) es el corazón de cualquier sistema. Monitorear su uso, carga y número de núcleos es vital para la optimización del rendimiento. ### 6.1. Recuperando Detalles del Procesador OSHI facilita la obtención del nombre de nuestro procesador, el conteo de núcleos y la velocidad de reloj usando Java: @Test void givenSystem_whenUsingOSHI_thenExtractCPUDetails() { SystemInfo si = new SystemInfo(); CentralProcessor processor = si.getHardware().getProcessor(); assertNotNull(processor, "El objeto del procesador no debe ser nulo"); assertTrue(processor.getPhysicalProcessorCount() > 0, "La CPU debe tener al menos un núcleo físico"); assertTrue(processor.getLogicalProcessorCount() >= processor.getPhysicalProcessorCount(), "Los núcleos lógicos deben ser mayores o iguales a los núcleos físicos"); } Este test inicializa un objeto `SystemInfo` de OSHI y recupera la instancia `CentralProcessor` de la hardware del sistema. Proporciona detalles sobre el CPU, como el número de núcleos y métricas de carga. ### 6.2. Midiendo la Carga de la CPU Dinámicamente Para comprobar la carga de nuestra CPU en un momento dado, podemos hacerlo fácilmente: @Test void givenSystem_whenUsingOSHI_thenExtractCPULoad() throws InterruptedException { SystemInfo si = new SystemInfo(); CentralProcessor processor = si.getHardware().getProcessor(); long[] prevTicks = processor.getSystemCpuLoadTicks(); TimeUnit.SECONDS.sleep(1); double cpuLoad = processor.getSystemCpuLoadBetweenTicks(prevTicks) * 100; assertTrue(cpuLoad >= 0 && cpuLoad <= 100, "La carga de la CPU debe estar entre 0% y 100%"); } El código captura los ticks de carga del CPU del sistema, espera un segundo y calcula el porcentaje de carga de CPU entre los ticks grabados. Finalmente, comprobamos que la carga de CPU se encuentra en el rango válido de 0% a 100%. Una carga baja significa que el CPU está inactivo, mientras que un porcentaje alto indica una alta carga de trabajo. 7\. Monitoreo de Memoria ------------------------ La RAM (Memoria de Acceso Aleatorio) de nuestro sistema determina cuántas aplicaciones pueden ejecutarse simultáneamente. ### 7.1. Recuperando RAM Total y Disponible Veamos cómo podemos recuperar la RAM total y disponible para nuestro sistema: @Test void givenSystem_whenUsingOSHI_thenExtractMemoryDetails() { SystemInfo si = new SystemInfo(); GlobalMemory memory = si.getHardware().getMemory(); assertTrue(memory.getTotal() > 0, "La memoria total debe ser positiva"); assertTrue(memory.getAvailable() >= 0, "La memoria disponible no debe ser negativa"); assertTrue(memory.getAvailable() <= memory.getTotal(), "La memoria disponible no debe exceder la memoria total"); } Este código inicializa un objeto `SystemInfo` y obtiene la instancia `GlobalMemory`, que proporciona información relacionada con la memoria. Aseguramos que la memoria total sea positiva y que la memoria disponible no sea negativa. ### 7.2. Información de Almacenamiento y Disco Los discos duros y SSD almacenan todos nuestros datos. OSHI ayuda a monitorear el espacio total en disco, particiones y estadísticas de uso: @Test void givenSystem_whenUsingOSHI_thenExtractDiskDetails() { SystemInfo si = new SystemInfo(); List diskStores = si.getHardware().getDiskStores(); assertFalse(diskStores.isEmpty(), "Debe haber al menos un disco"); for (HWDiskStore disk : diskStores) { assertNotNull(disk.getModel(), "El modelo del disco no debe ser nulo"); assertTrue(disk.getSize() >= 0, "El tamaño del disco debe ser no negativo"); } } El código recoge detalles del almacenamiento del disco usando OSHI y asegura que al menos un disco esté presente. Iteramos sobre cada disco, verificando que el modelo no sea nulo y que el tamaño sea no negativo, asegurando que OSHI detecte correctamente la información del disco. 8\. Limitaciones de OSHI ------------------------ Aunque OSHI es una herramienta rica en características, tiene algunas limitaciones: * La disponibilidad de datos de sensores depende del soporte del hardware: No todas las máquinas exponen lecturas de temperatura o voltajes. * Control limitado a bajo nivel: OSHI proporciona información de sistema en modo de solo lectura; no permite modificaciones del sistema. * Dependencia de las API del sistema: Algunas informaciones pueden variar ligeramente entre sistemas operativos. 9\. Conclusión -------------- En este artículo, exploramos cómo **OSHI** es una poderosa y ligera biblioteca de Java para recuperar información del sistema y hardware. Elimina la necesidad de lidiar con comandos nativos del sistema, JNI o dependencias específicas de la plataforma, lo que la convierte en una excelente opción para desarrolladores que necesitan monitoreo de sistemas multiplataforma. OSHI proporciona una solución simple y efectiva para cualquier desarrollador de Java que busque entender su entorno de ejecución y optimizar el rendimiento de sus aplicaciones. ¡Anímate a implementarlo en tu próximo proyecto! Para más ejemplos y código, visita la página oficial de OSHI en [GitHub](https://github.com/oshi/oshi).

Monitoreo de Sistemas en Java con OSHI