When should we call System.exit in Java

java

shutdown-hooks

system-exit

thread-management

byNikita Barsukov·Mar 12, 2025

To instantly terminate JVM and signal termination status to the operating system, use System.exit(int status). It is highly useful for command-line tools where control over exit semantics is crucial. However, be vigilant! It ends all running threads abruptly and bypasses the typical shutdown mechanisms. Use it only when the situation calls for a drastic action.

if (itGoesDown) {  // When things hit the fan 
    System.err.println("Oh deer!");
    System.exit(1); // Signal Emergency exit
}
// ...
System.exit(0); // Everything finished fine, like the End of a good Netflix series

System.exit is useful when you need to quickly stop the JVM, especially when managing system resources or dealing with third-party code requiring a strict shutdown.

The power of Shutdown Hooks

Let's dive into the Java Runtime class. It offers another elegant route to ensure a graceful application shutdown by employing shutdown hooks. Shutdown Hooks allow you to organize cleanup actions in an orderly manner. Here is what you need to know:

Use Runtime.getRuntime().addShutdownHook() to register an action or, technically, a Thread.
These hooks are executed concurrently when the JVM initiates the shutdown sequence.
If you simply return from main(), the JVM will typically terminate itself, but merrily running non-daemon threads can keep it alive.

In larger, more complex applications, it's good practice to leverage shutdown hooks and use System.exit(0) judiciously to trigger hooks and clean up.

To Quit Gracefully or Forcefully, That is the Question

Daemon threads in the spotlight

While daemon threads may run in the background, a call to System.exit() will bring their journey to an abrupt halt. The JVM, though, won't bail out if any daemon threads are active, but will indeed quit when all non-daemon threads finish running. Making sure you're aware of this could save your application from unexpected closure.

OS, Tell me how I did

System.exit() signals the operating system with an exit code. Use non-zero values to report specific failure types. This practice proves helpful in automated scripts and command-line tools.

Deadlock Drama during shutdown

Shutdown hooks might try to lock objects another thread is using; this is where a deadlock could occur. Bypass this fatal concurrency issue by creating a dedicated thread solely for calling System.exit().

The Web-app/server conundrum

Be careful! In an application server environment, System.exit() could bring down the entire server, impacting all hosted applications. Use it in such environments only after serious consideration and always in a controlled manner, like when the server is in maintenance mode.

For Smooth sailings: Design your Application

A story of Threads, Daemons, & Resource cleanup

For a smooth shutdown of your Java application, keep three things in mind:

Manage start-and-stop lifecycle of threads. Don't start a roadtrip without a map, right?
Every resource should have an owner who ensures its proper closure.
Global states are tricky. They're like the holiday turkeys that never get finished. Avoid them for a hassle-free shutdown.

Alternatives to System.exit, anyone?

Sometimes, System.exit() might feel a bit harsh. Here are some softer alternatives:

To send signals to the caller, return a status or handle the situations via exceptions.
Some frameworks or containers manage entire lifecycles, leaving lesser things to worry about.
If you're using a framework, write callbacks to take care of cleanup actions rather than relying entirely on shutdown hooks.

Post-Shutdown Tasks

Tasks that are meant to continue after the main application can be managed separately.

An out-of-process solution, like a dedicated watchdog process, is one such approach.
Another good option is to use OS schedulers or job managers to handle these after-lifecycle tasks.

explain-codes / Java / When should we call System.exit in Java

Linked

How do you kill a Thread in Java?



How to quit a Java app from within the program



How to properly stop the Thread in Java?



What's the difference between Thread start() and Runnable run()



Does a finally block run even if you throw a new Exception?

