Java for System Programming: Writing Utilities That Don't Lag

Java for System Programming: When a "Heavy" Language Becomes a Lightweight Tool

When you hear "system programming," associations with C, assembly, raw pointers, and manual memory management usually come to mind. Java is the last thing that comes to mind. And that's a mistake. Over more than twenty years of evolution, Java has transformed from a "slow monster for corporate websites" into a full-fledged tool for writing system utilities, network daemons, resource monitors, and even operating system components.

Of course, Java won't replace C when writing a graphics card driver. But for 90% of system programming tasks — working with processes, file descriptors, network sockets, OS-level memory management — Java offers an elegant, safe, and cross-platform approach. In this article, we'll break down real examples of how to use Java for system programming and show that Java code can be no less efficient than C++, while being much more readable.

Why Java Isn't Just "Enterprise"?

The main stereotype: Java is slow due to garbage collection and the virtual machine. This was true in 2004. Today, the JVM uses just-in-time compilation (JIT), branch prediction, and generational garbage collection with pauses under a millisecond. For system programming, three things are critical:

\n
• Cross-platform compatibility — one utility works on Linux, Windows, and macOS without recompilation.
\n
• Memory safety — no segfaults, no memory leaks (in the classical sense).
\n
• Rich standard library — working with processes, NIO, sockets, file channels — everything is built-in.
\n

It is these qualities that make Java an excellent choice for writing system utilities that need to run stably and predictably.

Working with Processes: ProcessBuilder and Runtime.exec

Any system utility will eventually launch external programs. In Java, Runtime.exec() and the more flexible ProcessBuilder handle this. The latter is preferable: it allows you to manage the environment, working directory, and redirect input/output streams.

Example: Monitoring Memory Usage (Linux)

Let's say we want to get the percentage of used RAM. Instead of manually parsing /proc/meminfo, we can run free and process its output:

import java.io.*;\n\npublic class MemMonitor {\n    public static void main(String[] args) throws IOException {\n        ProcessBuilder pb = new ProcessBuilder("free", "-m");\n        pb.redirectErrorStream(true);\n        Process process = pb.start();\n\n        StringBuilder output = new StringBuilder();\n        try (BufferedReader reader = new BufferedReader(\n                new InputStreamReader(process.getInputStream()))) {\n            String line;\n            while ((line = reader.readLine()) != null) {\n                output.append(line).append("\\n");\n            }\n        }\n\n        int exitCode = process.waitFor();\n        if (exitCode == 0) {\n            System.out.println("Memory (MB):");\n            System.out.println(output.toString());\n        } else {\n            System.err.println("Error calling free");\n        }\n    }\n}

This code is a typical example of system programming in Java: launching a native process, reading its output, handling errors. Important: always use redirectErrorStream(true) to avoid a deadlock when reading two streams (stdout and stderr) simultaneously.

Managing the Environment and Working Directory

ProcessBuilder allows fine-tuning the launch. For example, to run a script with specific environment variables:

ProcessBuilder pb = new ProcessBuilder("python3", "backup.py");\npb.directory(ne