Useful example of a shutdown hook in Java?

I'm trying to make sure my Java application takes reasonable steps to be robust, and part of that involves shutting down gracefully. I am reading about shutdown hooks and I don't actually get how to make use of them in practice.

Is there a practical example out there?

Let's say I had a really simple application like this one below, which writes numbers to a file, 10 to a line, in batches of 100, and I want to make sure a given batch finishes if the program is interrupted. I get how to register a shutdown hook but I have no idea how to integrate that into my application. Any suggestions?

package com.example.test.concurrency;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintWriter;

public class GracefulShutdownTest1 {
	final private int N;
	final private File f;
	public GracefulShutdownTest1(File f, int N) { this.f=f; this.N = N; }
	
	public void run()
	{
		PrintWriter pw = null;
		try {
			FileOutputStream fos = new FileOutputStream(this.f);
			pw = new PrintWriter(fos);
			for (int i = 0; i < N; ++i)
				writeBatch(pw, i);
		}
		catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		finally
		{
			pw.close();
		}		
	}

	private void writeBatch(PrintWriter pw, int i) {
		for (int j = 0; j < 100; ++j)
		{
			int k = i*100+j;
			pw.write(Integer.toString(k));
			if ((j+1)%10 == 0)
				pw.write('\n');
			else
				pw.write(' ');
		}
	}

	static public void main(String[] args)
	{
		if (args.length < 2)
		{
			System.out.println("args = [file] [N] "
					+"where file = output filename, N=batch count");
		}
		else
		{
			new GracefulShutdownTest1(
					new File(args[0]), 
					Integer.parseInt(args[1])
			).run();
		}
	}
}

You could do the following:

• Let the shutdown hook set some AtomicBoolean (or volatile boolean) "keepRunning" to false
• (Optionally, .interrupt the working threads if they wait for data in some blocking call)
• Wait for the working threads (executing writeBatch in your case) to finish, by calling the Thread.join() method on the working threads.
• Terminate the program

Some sketchy code:

• Add a static volatile boolean keepRunning = true;

• In run() you change to

    for (int i = 0; i < N && keepRunning; ++i)
        writeBatch(pw, i);
  

• In main() you add:

    final Thread mainThread = Thread.currentThread();
    Runtime.getRuntime().addShutdownHook(new Thread() {
        public void run() {
            keepRunning = false;
            mainThread.join();
        }
    });
  

That's roughly how I do a graceful "reject all clients upon hitting Control-C" in terminal.

---

From the docs:

> When the virtual machine begins its shutdown sequence it will start all registered shutdown hooks in some unspecified order and let them run concurrently. When all the hooks have finished it will then run all uninvoked finalizers if finalization-on-exit has been enabled. Finally, the virtual machine will halt.

That is, a shutdown hook keeps the JVM running until the hook has terminated (returned from the run()-method.

Shutdown Hooks are unstarted threads that are registered with Runtime.addShutdownHook().JVM does not give any guarantee on the order in which shutdown hooks are started.For more info refer http://techno-terminal.blogspot.in/2015/08/shutdown-hooks.html