How to process SIGTERM signal gracefully in Java?

Question

Let's assume we have such a trivial daemon written in java:

public class Hellow {
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        while(true) {
            // 1. do
            // 2. some
            // 3. important
            // 4. job
            // 5. sleep
        }

    }
}

and we daemonize it using start-stop-daemon which by default sends SIGTERM (TERM) signal on --stop

Let's suppose the current step performed is #2. And at this very moment we're sending TERM signal.

What happens is that the execution terminates immediately.

I've found that I can handle the signal event using addShutdownHook() but the thing is that it still interrupts the current execution and passes the control to handler:

public class Hellow {
    private static boolean shutdownFlag = false;
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        registerShutdownHook();

        try {
            doProcessing();
        } catch (InterruptedException ex) {
            System.out.println(ex);
        }
    }

    static private void doProcessing() throws InterruptedException {
        int i = 0;
        while(shutdownFlag == false) {
            i++;
            System.out.println("i:" + i);
            if(i == 5) {
                System.out.println("i is 5");
                System.exit(1); // for testing
            }

            System.out.println("Hello"); // It doesn't print after System.exit(1);

            Thread.sleep(1000);
        }
    }

    static public void setShutdownProcess() {
        shutdownFlag = true;
    }

    private static void registerShutdownHook() {
        Runtime.getRuntime().addShutdownHook(new Thread() {
            public void run() {
                System.out.println("Tralala");
                Hellow.setShutdownProcess();
            }
        });
    }
}

So, my question is - is it possible to not interrupt the current execution but handle the TERM signal in a separated thread (?) so that I would able to set shutdown_flag = True so that loop in main would had a chance to stop gracefully?

Orectic

Answer 1

I rewritten the registerShutdownHook() method and now it works as I wanted.

private static void registerShutdownHook() {
    final Thread mainThread = Thread.currentThread();
    Runtime.getRuntime().addShutdownHook(new Thread() {
        public void run() {
            try {
                System.out.println("Tralala");
                Hellow.setShutdownProcess();
                mainThread.join();
            } catch (InterruptedException ex) {
                System.out.println(ex);
            }

        }
    });  
}

Orectic

Answer 2

You can use SignalHandler. Please check out this example: https://dumpz.org/2707213/

It will catch up INTERRUPTED signal and unset operating flag, which in turn will allow app shutdown gracefully.

Notable

Yes, your solution works but at compile time the compiler swears that SignalHandler in the future does not work. I found another solution, but thanks) – Orectic

@IslomkhodjaHamidullakhodjaev Would you share your solution? Kind regards – Leisure