Java-Anwendung sauber beenden mit addShutdownHook

21.09.2015 yahe code java legacy

Bei einfachen Java-Anwendungen macht man sich typischerweise wenig Gedanken um das saubere Beenden aller Prozesse. Man geht davon aus, dass der Nutzer weiß, was er tut, wenn er auf Beenden klickt und fragt zur Not vorher nochmal nach, ob er tatsächlich fortfahren will. Anders sieht das jedoch aus, wenn man mehrere Threads verwaltet, wie das zum Beispiel bei Serveranwendungen der Fall ist. Dann möchte man vor dem tatsächlichen Beenden lieber doch noch die einen oder anderen Aufräumarbeiten durchführen, zum Beispiel Logdateien flushen, laufende Serveranfragen beantworten oder temporäre Dateien wegräumen. Die JVM-Runtime bietet für solche Fälle die Möglichkeit, sogenannte Shutdown-Hooks via "Runtime.getRuntime().addShutdownHook()" zu registrieren. Wenn die JVM beendet wird, werden die registrierten Hooks ausgeführt. Im Grunde sind es Threads, deren "run()"-Methode aufgerufen wird.

Im folgenden Beispiel habe ich mal eine kleine Vorlage gebastelt, in der man sieht, wie man das ganze verwenden kann. In der Methode "startupMain()" implementiert man alle Initialisierungen, die beim Programmstart ausgeführt werden sollen, in der Methode "runMain()" führt man dann die tatsächliche Anwendung aus, während in der Methode "shutdownMain()" notwendige Deinitialisierungen durchgeführt werden können:

public class Main extends Object implements Runnable {

    // singleton instance
    protected static Main fInstance = null;

    static {
        // create singleton instance
        fInstance = new Main();
    }

    // prevent external instantiation
    protected Main() {
        super();
    }

    public static Main getInstance() {
        return fInstance;
    }

    public static void main(String[] args) {
        Main lMain = Main.getInstance();

        // call startup code
        lMain.startupMain(args);

        // register shutdown code
        Runtime.getRuntime().addShutdownHook(new Thread(lMain));

        // call main code
        lMain.runMain();
    }

    @Override
    public void run() {
        // call shutdown code
        shutdownMain();
    }

    public synchronized void startupMain(String[] aArguments) {
        // startup code
        // ...
    }

    public synchronized void shutdownMain() {
        // shutdown code
        // ...
    }

    public void runMain() {
        // main code
        // ...
    }

}

Als Test habe ich mir eine einfache Anwendung geschrieben, die beim Starten das Wort "start", während des Laufens in einer Endlosschleife das Wort "sleep" und beim Beenden das Wort "stop" schreibt. Die drei Methoden sehen dabei wie folgt aus:

    public synchronized void startupMain(String[] aArguments) {
        // startup code
        // ...
        System.out.println("start");
    }

    public synchronized void shutdownMain() {
        // shutdown code
        // ...
        System.out.println("stop");
    }

    public void runMain() {
        // main code
        // ...
        while (true) {
            System.out.println("sleep");
            try {
                Thread.sleep(1000);
            }
            catch (Exception e) {}
        }
    }

Nach dem Starten verwende ich den Linuxbefehl "kill -SIGINT <Prozess-ID>" um die Anwendung wieder zu beenden. Dabei wird vor dem tatsächlichen Beenden noch der Shutdown-Hook ausgeführt. Ich habe ein kleines Video bei Youtube hochgeladen, das das ganze mal demonstriert.

Wie ihr seht, kann man mit einfachen Mitteln Java-Anwendungen sauber und ordentlich beenden. Es ist übrigens auch möglich, mehrere Shutdown-Hooks zu registrieren. Da jedoch deren Ausführungsreihenfolge nicht definiert ist, ist anzuraten, nur einen Shutdown-Hook für die gesamte Anwendung zu verwenden und in diesem zur Not weiteren Cleanup-Code aufzurufen. Da der Shutdown-Hook ein Thread ist, müsst ihr euch zudem um Themen wie Threadsicherheit kümmern.