Console-Based System Monitor
Basic System Information Collector
import java.lang.management.*; import java.io.*; import java.util.*; import java.text.DecimalFormat; public class SystemMonitor { private static final DecimalFormat df = new DecimalFormat("0.00"); private static final int REFRESH_INTERVAL = 2000; // 2 seconds public static void main(String[] args) { System.out.println("Java System Monitoring Dashboard"); System.out.println("Press 'q' to quit, 'c' to clear screen"); Scanner scanner = new Scanner(System.in); Thread inputThread = new Thread(() -> { while (true) { String input = scanner.nextLine(); if ("q".equalsIgnoreCase(input)) { System.exit(0); } else if ("c".equalsIgnoreCase(input)) { clearScreen(); } } }); inputThread.setDaemon(true); inputThread.start(); // Start monitoring startMonitoring(); } private static void clearScreen() { try { if (System.getProperty("os.name").contains("Windows")) { new ProcessBuilder("cmd", "/c", "cls").inheritIO().start().waitFor(); } else { new ProcessBuilder("clear").inheritIO().start().waitFor(); } } catch (Exception e) { // Fallback: print empty lines for (int i = 0; i < 50; i++) { System.out.println(); } } } private static void startMonitoring() { while (true) { displaySystemInfo(); try { Thread.sleep(REFRESH_INTERVAL); } catch (InterruptedException e) { break; } } } private static void displaySystemInfo() { StringBuilder dashboard = new StringBuilder(); dashboard.append("╔══════════════════════════════════════════════════════════════╗\n"); dashboard.append("║ SYSTEM MONITORING DASHBOARD ║\n"); dashboard.append("╠══════════════════════════════════════════════════════════════╣\n"); // CPU Information dashboard.append(getCPUInfo()); // Memory Information dashboard.append(getMemoryInfo()); // Thread Information dashboard.append(getThreadInfo()); // Operating System Information dashboard.append(getOSInfo()); // Disk Information dashboard.append(getDiskInfo()); // Network Information (basic) dashboard.append(getNetworkInfo()); dashboard.append("╚══════════════════════════════════════════════════════════════╝\n"); dashboard.append("Commands: [q] Quit | [c] Clear Screen | Refreshing every " + (REFRESH_INTERVAL/1000) + " seconds\n"); System.out.print(dashboard.toString()); } private static String getCPUInfo() { OperatingSystemMXBean osBean = ManagementFactory.getOperatingSystemMXBean(); com.sun.management.OperatingSystemMXBean sunOsBean = (com.sun.management.OperatingSystemMXBean) osBean; double systemCpuLoad = sunOsBean.getSystemCpuLoad() * 100; double processCpuLoad = sunOsBean.getProcessCpuLoad() * 100; long availableProcessors = sunOsBean.getAvailableProcessors(); String cpuUsageBar = getProgressBar(systemCpuLoad, 100, 20); return String.format( "║ CPU Usage: %6s%% %s ║\n" + "║ Process CPU: %6s%% ║\n" + "║ Processors: %6d ║\n", df.format(systemCpuLoad), cpuUsageBar, df.format(processCpuLoad), availableProcessors ); } private static String getMemoryInfo() { OperatingSystemMXBean osBean = ManagementFactory.getOperatingSystemMXBean(); com.sun.management.OperatingSystemMXBean sunOsBean = (com.sun.management.OperatingSystemMXBean) osBean; MemoryMXBean memoryBean = ManagementFactory.getMemoryMXBean(); MemoryUsage heapUsage = memoryBean.getHeapMemoryUsage(); MemoryUsage nonHeapUsage = memoryBean.getNonHeapMemoryUsage(); long totalPhysicalMemory = sunOsBean.getTotalPhysicalMemorySize(); long freePhysicalMemory = sunOsBean.getFreePhysicalMemorySize(); long usedPhysicalMemory = totalPhysicalMemory - freePhysicalMemory; double physicalMemoryUsage = ((double) usedPhysicalMemory / totalPhysicalMemory) * 100; String physicalMemBar = getProgressBar(physicalMemoryUsage, 100, 20); String heapMemBar = getProgressBar( ((double) heapUsage.getUsed() / heapUsage.getMax()) * 100, 100, 20); return String.format( "║ Physical Memory: %6s%% %s ║\n" + "║ Used: %s / %s ║\n" + "║ Heap Memory: %6s%% %s ║\n" + "║ Used: %s / %s ║\n" + "║ Non-Heap: %10s / %-10s ║\n", df.format(physicalMemoryUsage), physicalMemBar, formatBytes(usedPhysicalMemory), formatBytes(totalPhysicalMemory), df.format(((double) heapUsage.getUsed() / heapUsage.getMax()) * 100), heapMemBar, formatBytes(heapUsage.getUsed()), formatBytes(heapUsage.getMax()), formatBytes(nonHeapUsage.getUsed()), formatBytes(nonHeapUsage.getMax()) ); } private static String getThreadInfo() { ThreadMXBean threadBean = ManagementFactory.getThreadMXBean(); int threadCount = threadBean.getThreadCount(); int peakThreadCount = threadBean.getPeakThreadCount(); long totalStartedThreadCount = threadBean.getTotalStartedThreadCount(); int daemonThreadCount = threadBean.getDaemonThreadCount(); // Find deadlocked threads long[] deadlockedThreads = threadBean.findDeadlockedThreads(); int deadlockCount = deadlockedThreads != null ? deadlockedThreads.length : 0; String deadlockStatus = deadlockCount > 0 ? "DEADLOCK DETECTED!" : "No deadlocks"; return String.format( "║ Threads: %6d ║\n" + "║ Daemon Threads: %6d ║\n" + "║ Peak Threads: %6d ║\n" + "║ Total Started: %6d ║\n" + "║ Deadlocks: %6d - %-15s ║\n", threadCount, daemonThreadCount, peakThreadCount, totalStartedThreadCount, deadlockCount, deadlockStatus ); } private static String getOSInfo() { OperatingSystemMXBean osBean = ManagementFactory.getOperatingSystemMXBean(); String osName = osBean.getName(); String osVersion = osBean.getVersion(); String arch = osBean.getArchitecture(); double systemLoadAverage = osBean.getSystemLoadAverage(); return String.format( "║ OS: %-40s ║\n" + "║ Version: %-40s ║\n" + "║ Architecture: %-40s ║\n" + "║ Load Average: %-40s ║\n", truncateString(osName, 40), truncateString(osVersion, 40), truncateString(arch, 40), systemLoadAverage >= 0 ? df.format(systemLoadAverage) : "N/A" ); } private static String getDiskInfo() { File[] roots = File.listRoots(); StringBuilder diskInfo = new StringBuilder(); for (File root : roots) { long totalSpace = root.getTotalSpace(); long freeSpace = root.getFreeSpace(); long usedSpace = totalSpace - freeSpace; double usagePercent = totalSpace > 0 ? ((double) usedSpace / totalSpace) * 100 : 0; String diskBar = getProgressBar(usagePercent, 100, 15); diskInfo.append(String.format( "║ Disk %s: %6s%% %s ║\n" + "║ %s / %s free ║\n", root.getPath(), df.format(usagePercent), diskBar, formatBytes(freeSpace), formatBytes(totalSpace) )); } return diskInfo.toString(); } private static String getNetworkInfo() { // Basic network info - in a real implementation, use more sophisticated monitoring Runtime runtime = Runtime.getRuntime(); try { // This is a simple approach - for real monitoring, use more robust methods String hostName = java.net.InetAddress.getLocalHost().getHostName(); return String.format("║ Hostname: %-40s ║\n", truncateString(hostName, 40)); } catch (Exception e) { return "║ Network: Unable to retrieve network info ║\n"; } } private static String getProgressBar(double value, double max, int length) { int progress = (int) ((value / max) * length); progress = Math.min(progress, length); StringBuilder bar = new StringBuilder(); bar.append("["); for (int i = 0; i < length; i++) { if (i < progress) { bar.append("█"); } else { bar.append(" "); } } bar.append("]"); return bar.toString(); } private static String formatBytes(long bytes) { if (bytes < 1024) return bytes + " B"; int exp = (int) (Math.log(bytes) / Math.log(1024)); String pre = "KMGTPE".charAt(exp-1) + ""; return String.format("%.1f %sB", bytes / Math.pow(1024, exp), pre); } private static String truncateString(String str, int maxLength) { if (str.length() <= maxLength) return str; return str.substring(0, maxLength - 3) + "..."; } } Swing GUI System Monitor
Graphical Dashboard
import javax.swing.*; import javax.swing.Timer; import java.awt.*; import java.awt.event.*; import java.lang.management.*; import java.text.DecimalFormat; import java.util.*; public class SystemMonitorGUI extends JFrame { private static final DecimalFormat df = new DecimalFormat("0.00"); private static final int UPDATE_INTERVAL = 1000; // 1 second // Components private JProgressBar cpuProgressBar, memoryProgressBar, heapProgressBar; private JLabel cpuLabel, memoryLabel, heapLabel, threadLabel, osLabel; private JTextArea processListArea; private JPanel chartPanel; private java.util.List<Double> cpuHistory = new ArrayList<>(); private java.util.List<Double> memoryHistory = new ArrayList<>(); public SystemMonitorGUI() { initializeUI(); startMonitoring(); } private void initializeUI() { setTitle("Java System Monitor Dashboard"); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setLayout(new BorderLayout()); // Create main panels JPanel topPanel = createTopPanel(); JPanel centerPanel = createCenterPanel(); JPanel bottomPanel = createBottomPanel(); add(topPanel, BorderLayout.NORTH); add(centerPanel, BorderLayout.CENTER); add(bottomPanel, BorderLayout.SOUTH); setSize(1000, 700); setLocationRelativeTo(null); } private JPanel createTopPanel() { JPanel panel = new JPanel(new GridLayout(2, 3, 10, 10)); panel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10)); panel.setBackground(Color.WHITE); // CPU Panel JPanel cpuPanel = createMetricPanel("CPU Usage", Color.RED); cpuProgressBar = new JProgressBar(0, 100); cpuProgressBar.setStringPainted(true); cpuLabel = new JLabel("0%", SwingConstants.CENTER); cpuLabel.setFont(new Font("Arial", Font.BOLD, 16)); cpuPanel.add(cpuProgressBar); cpuPanel.add(cpuLabel); // Memory Panel JPanel memoryPanel = createMetricPanel("Physical Memory", Color.BLUE); memoryProgressBar = new JProgressBar(0, 100); memoryProgressBar.setStringPainted(true); memoryLabel = new JLabel("0%", SwingConstants.CENTER); memoryLabel.setFont(new Font("Arial", Font.BOLD, 16)); memoryPanel.add(memoryProgressBar); memoryPanel.add(memoryLabel); // Heap Memory Panel JPanel heapPanel = createMetricPanel("Heap Memory", Color.GREEN); heapProgressBar = new JProgressBar(0, 100); heapProgressBar.setStringPainted(true); heapLabel = new JLabel("0%", SwingConstants.CENTER); heapLabel.setFont(new Font("Arial", Font.BOLD, 16)); heapPanel.add(heapProgressBar); heapPanel.add(heapLabel); // Thread Info Panel JPanel threadPanel = createInfoPanel("Threads", Color.ORANGE); threadLabel = new JLabel("Loading...", SwingConstants.CENTER); threadLabel.setFont(new Font("Arial", Font.PLAIN, 12)); threadPanel.add(threadLabel); // OS Info Panel JPanel osPanel = createInfoPanel("Operating System", Color.MAGENTA); osLabel = new JLabel("Loading...", SwingConstants.CENTER); osLabel.setFont(new Font("Arial", Font.PLAIN, 12)); osPanel.add(osLabel); // System Load Panel JPanel loadPanel = createInfoPanel("System Load", Color.CYAN); JLabel loadLabel = new JLabel("Loading...", SwingConstants.CENTER); loadLabel.setFont(new Font("Arial", Font.PLAIN, 12)); loadPanel.add(loadLabel); panel.add(cpuPanel); panel.add(memoryPanel); panel.add(heapPanel); panel.add(threadPanel); panel.add(osPanel); panel.add(loadPanel); return panel; } private JPanel createMetricPanel(String title, Color color) { JPanel panel = new JPanel(new BorderLayout()); panel.setBorder(BorderFactory.createTitledBorder( BorderFactory.createLineBorder(color, 2), title)); JLabel titleLabel = new JLabel(title, SwingConstants.CENTER); titleLabel.setFont(new Font("Arial", Font.BOLD, 14)); titleLabel.setForeground(color); panel.add(titleLabel, BorderLayout.NORTH); return panel; } private JPanel createInfoPanel(String title, Color color) { JPanel panel = new JPanel(new BorderLayout()); panel.setBorder(BorderFactory.createTitledBorder( BorderFactory.createLineBorder(color, 2), title)); return panel; } private JPanel createCenterPanel() { JPanel panel = new JPanel(new GridLayout(1, 2, 10, 10)); panel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10)); // Process List JPanel processPanel = new JPanel(new BorderLayout()); processPanel.setBorder(BorderFactory.createTitledBorder("Running Processes")); processListArea = new JTextArea(); processListArea.setEditable(false); processListArea.setFont(new Font("Monospaced", Font.PLAIN, 12)); JScrollPane processScrollPane = new JScrollPane(processListArea); processPanel.add(processScrollPane, BorderLayout.CENTER); // Charts Panel JPanel chartsPanel = new JPanel(new BorderLayout()); chartsPanel.setBorder(BorderFactory.createTitledBorder("Performance Charts")); chartPanel = new ChartPanel(); chartsPanel.add(chartPanel, BorderLayout.CENTER); panel.add(processPanel); panel.add(chartsPanel); return panel; } private JPanel createBottomPanel() { JPanel panel = new JPanel(new FlowLayout()); panel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10)); JButton refreshButton = new JButton("Refresh Now"); JButton exportButton = new JButton("Export Report"); JButton settingsButton = new JButton("Settings"); refreshButton.addActionListener(e -> updateSystemInfo()); exportButton.addActionListener(e -> exportReport()); settingsButton.addActionListener(e -> showSettings()); panel.add(refreshButton); panel.add(exportButton); panel.add(settingsButton); return panel; } private void startMonitoring() { Timer timer = new Timer(UPDATE_INTERVAL, e -> updateSystemInfo()); timer.start(); } private void updateSystemInfo() { // Update CPU Info updateCPUInfo(); // Update Memory Info updateMemoryInfo(); // Update Thread Info updateThreadInfo(); // Update OS Info updateOSInfo(); // Update Process List updateProcessList(); // Update Charts updateCharts(); // Repaint the chart chartPanel.repaint(); } private void updateCPUInfo() { try { OperatingSystemMXBean osBean = ManagementFactory.getOperatingSystemMXBean(); com.sun.management.OperatingSystemMXBean sunOsBean = (com.sun.management.OperatingSystemMXBean) osBean; double systemCpuLoad = sunOsBean.getSystemCpuLoad() * 100; cpuProgressBar.setValue((int) systemCpuLoad); cpuLabel.setText(df.format(systemCpuLoad) + "%"); // Add to history for chart cpuHistory.add(systemCpuLoad); if (cpuHistory.size() > 50) { cpuHistory.remove(0); } } catch (Exception e) { cpuLabel.setText("N/A"); } } private void updateMemoryInfo() { try { OperatingSystemMXBean osBean = ManagementFactory.getOperatingSystemMXBean(); com.sun.management.OperatingSystemMXBean sunOsBean = (com.sun.management.OperatingSystemMXBean) osBean; long totalPhysicalMemory = sunOsBean.getTotalPhysicalMemorySize(); long freePhysicalMemory = sunOsBean.getFreePhysicalMemorySize(); long usedPhysicalMemory = totalPhysicalMemory - freePhysicalMemory; double physicalMemoryUsage = ((double) usedPhysicalMemory / totalPhysicalMemory) * 100; memoryProgressBar.setValue((int) physicalMemoryUsage); memoryLabel.setText(df.format(physicalMemoryUsage) + "%"); // Update heap memory MemoryMXBean memoryBean = ManagementFactory.getMemoryMXBean(); MemoryUsage heapUsage = memoryBean.getHeapMemoryUsage(); double heapUsagePercent = ((double) heapUsage.getUsed() / heapUsage.getMax()) * 100; heapProgressBar.setValue((int) heapUsagePercent); heapLabel.setText(df.format(heapUsagePercent) + "%"); // Add to history for chart memoryHistory.add(physicalMemoryUsage); if (memoryHistory.size() > 50) { memoryHistory.remove(0); } } catch (Exception e) { memoryLabel.setText("N/A"); heapLabel.setText("N/A"); } } private void updateThreadInfo() { try { ThreadMXBean threadBean = ManagementFactory.getThreadMXBean(); int threadCount = threadBean.getThreadCount(); int peakThreadCount = threadBean.getPeakThreadCount(); int daemonThreadCount = threadBean.getDaemonThreadCount(); long[] deadlockedThreads = threadBean.findDeadlockedThreads(); int deadlockCount = deadlockedThreads != null ? deadlockedThreads.length : 0; String threadInfo = String.format( "<html><center>Current: %d<br>Peak: %d<br>Daemon: %d<br>Deadlocks: %d</center></html>", threadCount, peakThreadCount, daemonThreadCount, deadlockCount ); threadLabel.setText(threadInfo); // Change color if deadlocks detected if (deadlockCount > 0) { threadLabel.setForeground(Color.RED); } else { threadLabel.setForeground(Color.BLACK); } } catch (Exception e) { threadLabel.setText("Error"); } } private void updateOSInfo() { try { OperatingSystemMXBean osBean = ManagementFactory.getOperatingSystemMXBean(); String osName = osBean.getName(); String arch = osBean.getArchitecture(); double loadAverage = osBean.getSystemLoadAverage(); String osInfo = String.format( "<html><center>%s<br>%s<br>Load: %s</center></html>", osName, arch, loadAverage >= 0 ? df.format(loadAverage) : "N/A" ); osLabel.setText(osInfo); } catch (Exception e) { osLabel.setText("Error"); } } private void updateProcessList() { try { ThreadMXBean threadBean = ManagementFactory.getThreadMXBean(); StringBuilder processText = new StringBuilder(); // Get top threads by CPU time ThreadInfo[] threadInfos = threadBean.dumpAllThreads(false, false); Arrays.sort(threadInfos, (t1, t2) -> Long.compare(threadBean.getThreadCpuTime(t2.getThreadId()), threadBean.getThreadCpuTime(t1.getThreadId()))); processText.append(String.format("%-8s %-20s %-12s %s\n", "ID", "Name", "State", "CPU Time")); processText.append("──────────────────────────────────────────────────\n"); int count = 0; for (ThreadInfo info : threadInfos) { if (count++ >= 15) break; // Show top 15 long cpuTime = threadBean.getThreadCpuTime(info.getThreadId()); String cpuTimeStr = cpuTime >= 0 ? formatNanos(cpuTime) : "N/A"; processText.append(String.format("%-8d %-20s %-12s %s\n", info.getThreadId(), truncateString(info.getThreadName(), 20), info.getThreadState(), cpuTimeStr )); } processListArea.setText(processText.toString()); } catch (Exception e) { processListArea.setText("Error retrieving process information"); } } private void updateCharts() { // Data is already updated in the history lists // The chart panel will use these lists when painting } private void exportReport() { JFileChooser fileChooser = new JFileChooser(); fileChooser.setDialogTitle("Export System Report"); if (fileChooser.showSaveDialog(this) == JFileChooser.APPROVE_OPTION) { try { java.io.File file = fileChooser.getSelectedFile(); PrintWriter writer = new PrintWriter(file); writer.println("System Monitoring Report"); writer.println("Generated: " + new Date()); writer.println("================================="); writer.println(); // Write system information writer.println("CPU Usage: " + cpuLabel.getText()); writer.println("Memory Usage: " + memoryLabel.getText()); writer.println("Heap Usage: " + heapLabel.getText()); writer.println("Thread Info: " + threadLabel.getText().replaceAll("<[^>]*>", "")); writer.close(); JOptionPane.showMessageDialog(this, "Report exported successfully!"); } catch (Exception e) { JOptionPane.showMessageDialog(this, "Error exporting report: " + e.getMessage(), "Export Error", JOptionPane.ERROR_MESSAGE); } } } private void showSettings() { JDialog settingsDialog = new JDialog(this, "Monitor Settings", true); settingsDialog.setLayout(new GridLayout(0, 2, 10, 10)); settingsDialog.setSize(300, 200); settingsDialog.setLocationRelativeTo(this); settingsDialog.add(new JLabel("Refresh Interval (ms):")); JTextField intervalField = new JTextField(String.valueOf(UPDATE_INTERVAL)); settingsDialog.add(intervalField); settingsDialog.add(new JLabel("Max History Points:")); JTextField historyField = new JTextField("50"); settingsDialog.add(historyField); JButton saveButton = new JButton("Save"); saveButton.addActionListener(e -> { // In a real implementation, save these settings settingsDialog.dispose(); }); settingsDialog.add(saveButton); settingsDialog.setVisible(true); } private String formatNanos(long nanos) { if (nanos < 1000) return nanos + " ns"; if (nanos < 1000000) return (nanos / 1000) + " μs"; if (nanos < 1000000000) return (nanos / 1000000) + " ms"; return (nanos / 1000000000) + " s"; } private String truncateString(String str, int maxLength) { if (str.length() <= maxLength) return str; return str.substring(0, maxLength - 3) + "..."; } // Custom panel for drawing charts private class ChartPanel extends JPanel { @Override protected void paintComponent(Graphics g) { super.paintComponent(g); Graphics2D g2d = (Graphics2D) g; g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); int width = getWidth(); int height = getHeight(); int padding = 20; // Draw CPU history chart drawLineChart(g2d, cpuHistory, "CPU Usage %", Color.RED, width / 2 - padding, height, padding); // Draw Memory history chart drawLineChart(g2d, memoryHistory, "Memory Usage %", Color.BLUE, width / 2, height, padding); } private void drawLineChart(Graphics2D g2d, java.util.List<Double> data, String title, Color color, int xOffset, int height, int padding) { if (data.isEmpty()) return; int chartWidth = getWidth() / 2 - padding * 2; int chartHeight = height - padding * 3; // Draw title g2d.setColor(Color.BLACK); g2d.drawString(title, xOffset + padding, padding); // Draw axes g2d.drawRect(xOffset + padding, padding * 2, chartWidth, chartHeight); // Draw data points g2d.setColor(color); for (int i = 1; i < data.size(); i++) { int x1 = xOffset + padding + (i - 1) * chartWidth / Math.max(1, data.size() - 1); int y1 = padding * 2 + chartHeight - (int)(data.get(i - 1) * chartHeight / 100); int x2 = xOffset + padding + i * chartWidth / Math.max(1, data.size() - 1); int y2 = padding * 2 + chartHeight - (int)(data.get(i) * chartHeight / 100); g2d.drawLine(x1, y1, x2, y2); } } } public static void main(String[] args) { SwingUtilities.invokeLater(() -> { try { UIManager.setLookAndFeel(UIManager.getSystemLookAndFeel()); } catch (Exception e) { e.printStackTrace(); } new SystemMonitorGUI().setVisible(true); }); } } Advanced Monitoring Features
Network Monitoring Component
import java.net.*; import java.util.*; public class NetworkMonitor { private Map<String, NetworkInterfaceStats> interfaceStats = new HashMap<>(); public void monitorNetwork() { try { Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces(); while (interfaces.hasMoreElements()) { NetworkInterface ni = interfaces.nextElement(); if (ni.isUp() && !ni.isLoopback()) { NetworkInterfaceStats stats = getInterfaceStats(ni); interfaceStats.put(ni.getName(), stats); } } } catch (SocketException e) { System.err.println("Error monitoring network: " + e.getMessage()); } } private NetworkInterfaceStats getInterfaceStats(NetworkInterface ni) { NetworkInterfaceStats stats = new NetworkInterfaceStats(); stats.setInterfaceName(ni.getDisplayName()); try { List<InterfaceAddress> addresses = ni.getInterfaceAddresses(); for (InterfaceAddress addr : addresses) { InetAddress inetAddr = addr.getAddress(); if (inetAddr instanceof Inet4Address) { stats.setIpv4Address(inetAddr.getHostAddress()); } } // Get basic statistics (this would need more sophisticated monitoring) stats.setBytesReceived(0); // Would need to track over time stats.setBytesSent(0); stats.setPacketsReceived(0); stats.setPacketsSent(0); } catch (Exception e) { // Handle exception } return stats; } public Map<String, NetworkInterfaceStats> getInterfaceStats() { return interfaceStats; } public static class NetworkInterfaceStats { private String interfaceName; private String ipv4Address; private long bytesReceived; private long bytesSent; private long packetsReceived; private long packetsSent; // Getters and setters public String getInterfaceName() { return interfaceName; } public void setInterfaceName(String interfaceName) { this.interfaceName = interfaceName; } public String getIpv4Address() { return ipv4Address; } public void setIpv4Address(String ipv4Address) { this.ipv4Address = ipv4Address; } public long getBytesReceived() { return bytesReceived; } public void setBytesReceived(long bytesReceived) { this.bytesReceived = bytesReceived; } public long getBytesSent() { return bytesSent; } public void setBytesSent(long bytesSent) { this.bytesSent = bytesSent; } public long getPacketsReceived() { return packetsReceived; } public void setPacketsReceived(long packetsReceived) { this.packetsReceived = packetsReceived; } public long getPacketsSent() { return packetsSent; } public void setPacketsSent(long packetsSent) { this.packetsSent = packetsSent; } } } Alert System
import java.util.*; import java.util.concurrent.*; public class AlertSystem { private List<Alert> activeAlerts = new CopyOnWriteArrayList<>(); private Map<String, Double> thresholds = new HashMap<>(); private AlertListener alertListener; public AlertSystem() { // Set default thresholds thresholds.put("cpu.usage", 90.0); thresholds.put("memory.usage", 85.0); thresholds.put("heap.usage", 90.0); thresholds.put("thread.count", 500.0); thresholds.put("disk.usage", 90.0); } public void checkMetrics(SystemMetrics metrics) { checkCPUUsage(metrics.getCpuUsage()); checkMemoryUsage(metrics.getMemoryUsage()); checkHeapUsage(metrics.getHeapUsage()); checkThreadCount(metrics.getThreadCount()); } private void checkCPUUsage(double usage) { if (usage > thresholds.get("cpu.usage")) { triggerAlert("HIGH_CPU", String.format("CPU usage is high: %.2f%%", usage), Alert.Severity.WARNING); } } private void checkMemoryUsage(double usage) { if (usage > thresholds.get("memory.usage")) { triggerAlert("HIGH_MEMORY", String.format("Memory usage is high: %.2f%%", usage), Alert.Severity.WARNING); } } private void checkHeapUsage(double usage) { if (usage > thresholds.get("heap.usage")) { triggerAlert("HIGH_HEAP", String.format("Heap memory usage is high: %.2f%%", usage), Alert.Severity.ERROR); } } private void checkThreadCount(int count) { if (count > thresholds.get("thread.count")) { triggerAlert("HIGH_THREADS", String.format("High thread count: %d", count), Alert.Severity.WARNING); } } private void triggerAlert(String type, String message, Alert.Severity severity) { Alert alert = new Alert(type, message, severity, new Date()); // Check if similar alert already exists if (!activeAlerts.contains(alert)) { activeAlerts.add(alert); if (alertListener != null) { alertListener.onAlertTriggered(alert); } } } public void clearAlert(String type) { activeAlerts.removeIf(alert -> alert.getType().equals(type)); } public List<Alert> getActiveAlerts() { return new ArrayList<>(activeAlerts); } public void setAlertListener(AlertListener listener) { this.alertListener = listener; } public static class Alert { public enum Severity { INFO, WARNING, ERROR, CRITICAL } private String type; private String message; private Severity severity; private Date timestamp; public Alert(String type, String message, Severity severity, Date timestamp) { this.type = type; this.message = message; this.severity = severity; this.timestamp = timestamp; } // Getters public String getType() { return type; } public String getMessage() { return message; } public Severity getSeverity() { return severity; } public Date getTimestamp() { return timestamp; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null || getClass() != obj.getClass()) return false; Alert alert = (Alert) obj; return type.equals(alert.type); } @Override public int hashCode() { return type.hashCode(); } } public interface AlertListener { void onAlertTriggered(Alert alert); } } class SystemMetrics { private double cpuUsage; private double memoryUsage; private double heapUsage; private int threadCount; // Getters and setters public double getCpuUsage() { return cpuUsage; } public void setCpuUsage(double cpuUsage) { this.cpuUsage = cpuUsage; } public double getMemoryUsage() { return memoryUsage; } public void setMemoryUsage(double memoryUsage) { this.memoryUsage = memoryUsage; } public double getHeapUsage() { return heapUsage; } public void setHeapUsage(double heapUsage) { this.heapUsage = heapUsage; } public int getThreadCount() { return threadCount; } public void setThreadCount(int threadCount) { this.threadCount = threadCount; } } Running the System Monitor
How to Run:
- Console Version:
javac SystemMonitor.java java SystemMonitor
- GUI Version:
javac SystemMonitorGUI.java java SystemMonitorGUI
Features Included:
- Real-time CPU monitoring with usage percentage and history
- Memory monitoring including physical and heap memory
- Thread information with deadlock detection
- Process listing showing top CPU-consuming threads
- Disk usage monitoring for all drives
- Network interface information
- Alert system for threshold breaches
- Historical charts for performance trends
- Export functionality for reports
- Configurable refresh rates
This system monitoring dashboard provides comprehensive insights into Java application and system performance, making it useful for development, testing, and production monitoring scenarios.