Exiting an application gracefully?

Question

I have an application with a well defined Try/Catch/Finally chain that exits and executes the finally block just fine under normal conditions, however when someone prematurely hits the red X in the GUI, the program fully exists (code = 0) and the main thread's finally block isn't called.

In fact, I do want the program to exit upon a click of the red-X, but what I do not want is a skipping of the finally{} block! I sort of put in the most important part of the finally block manually in the GUI but I really do not want to do it this way since I want the GUI decoupled from the actual program:

class GUI { // ...
...
mainFrame.addWindowListener(new WindowAdapter() {
  public void windowClosing(WindowEvent evt) {
    try {
      processObject.getIndicatorFileStream().close();
    } catch (Exception ignore) {}
    System.exit(0);
  }
});
...
}

But I'd prefer to just have a call like this:

mainFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

And make sure that all the finally{} blocks get called from each thread after the Exit.

I know this is actually expected. If the application is closed from a separate thread (say the GUI thread) then the main thread will just stop in its tracks.

In short -- how do I ensure that a System.exit(0) or a JFrame.EXIT_ON_CLOSE will still cause each thread's finally block to execute?

Juned Ahsan · Answer 1 · 2013-07-22T16:52:09.360

If you have no other design change choices then what you may need is a JVM shutdown hook, which can be added to run a piece of code when System.exit is called.

Shutdown Hooks are a special construct that allow developers to plug in a piece of code to be executed when the JVM is shutting down. This comes in handy in cases where we need to do special clean up operations in case the VM is shutting down.

You can add a shutdown hook as mentioned here:

Runtime.getRuntime().addShutdownHook(Thread)

Read more about shutdown hooks here:

http://java.dzone.com/articles/know-jvm-series-2-shutdown

Word of Caution:

We must keep in mind is that it is not guaranteed that shutdown hooks will always run. If the JVM crashes due to some internal error, then it might crash down without having a chance to execute a single instruction. Also, if the O/S gives a SIGKILL (http://en.wikipedia.org/wiki/SIGKILL) signal (kill -9 in Unix/Linux) or TerminateProcess (Windows), then the application is required to terminate immediately without doing even waiting for any cleanup activities. In addition to the above, it is also possible to terminate the JVM without allowing the shutdown hooks to run by calling Runime.halt() method.

Probably important to note that this is not guaranteed to always run (e.g. when the jvm crashes). — DannyMo, Jul 22 '13 at 16:49
@damo Yes it is an important point. Let me add it to the answer — Juned Ahsan, Jul 22 '13 at 16:50
This is bad advice. Shutdown hooks should **never** be used as a part of the regular exit routine. They are a last-resort provision only, when all else fails, to salvage what can be salvaged. — Marko Topolnik, Jul 22 '13 at 16:54

score 3 · Answer 2 · answered Jul 22 '13 at 17:00

If you happen to have such threads which can legally be stopped at any time, at any point at all within their loop, at any point within any method which they invoke, and may I warn you that it is very unlikely that you do, then you can stop all of them upon program exit. This will result in an exception being thrown in each thread, and the finally blocks will execute.

However, the proper way to achieve your goal and have GUI decoupled from the program logic, is to issue a single "exit" signal from the GUI, which will trigger all the application cleanup, which is written in an entirely different class. If you have running threads, then implement the interrupt mechanism in each of them.

There are many ways to achieve the exit signaling. For example, your business code could register a GUI listener for a special event, which would trigger the cleanup. You could also have a thread which doesn't do anything else but await on a CountDownLatch which would be countDown from the GUI.

Please, do not at any cost use a shutdown hook. This is the dirtiest mechanism imaginable, and it is there only as a last resort, when all regular cleanup procedures fail. It is never to be used as a part of the regular shutdown routine.

In summary, there is no royal way to clean application shutdown. You must implement specific mechanisms for each specific concern.

Any example code? I hear what you are saying and it sounds logical (I am basically looking for examples of this very thing) — E.S., Jul 22 '13 at 17:17
could you elaborate more about this, or give some links or phrases to google? — Andrzej Rehmann, Feb 12 '14 at 09:52
@hoto `Thread#interrupt` is one thing to google for; `CountDownLatch` is another; `AWT custom event` is a third one. — Marko Topolnik, Feb 12 '14 at 09:54

score 1 · Answer 3 · answered Mar 05 '17 at 11:19

With modern Java, Window.dispose() on all application windows can offer more graceful possibility to exit an AWT application than System.exit(0), see
https://docs.oracle.com/javase/8/docs/api/java/awt/Window.html#dispose--

/** Listens and closes AWT windows.
 * The class is implemented as singleton since only one is needed.
 */
public class ExitListener extends WindowAdapter {

  /** the instance object */
  private static final ExitListener INSTANCE = new ExitListener();

  // hide the constructor
  private ExitListener () {}

  /** retrieve the listener object */
  public static ExitListener getInstance () {
    return INSTANCE;
  }

  @Override
  public void windowClosing ( final WindowEvent e ) {
    e.getWindow().dispose();
  }
}

and with your windows

window.addWindowListener( ExitListener.getInstance() );

However, be careful in adverse environments, see:
https://docs.oracle.com/javase/8/docs/api/java/awt/doc-files/AWTThreadIssues.html#Autoshutdown

Exiting an application gracefully?

3 Answers3

Linked

Related