How to stop java process gracefully?

Question

How to stop java process gracefully in Linux and Windows?
When does Runtime.getRuntime().addShutdownHook gets called, and when it does not?
What about finalizers, do they help here?
Can I send some sort of signal to java process from shell?

I am looking for preferably portable solution.
Thanks,

Answer 1

Similar Question Here

Finalizers in Java are bad. They add a lot of overhead to garbage collection. Avoid them whenever possible.

The shutdownHook will only get called when the VM is shutting down. I think it very well may do what you want.

Answer 2

In the case of shutdown Hook did you read the javadoc for it?

http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Runtime.html#addShutdownHook(java.lang.Thread)

Answer 3

Signalling in Linux can be done with "kill" (man kill for the available signals), you'd need the process ID to do that. (ps ax | grep java) or something like that, or store the process id when the process gets created (this is used in most linux startup files, see /etc/init.d)

Portable signalling can be done by integrating a SocketServer in your java application. It's not that difficult and gives you the freedom to send any command you want.

If you meant finally clauses in stead of finalizers; they do not get extecuted when System.exit() is called. Finalizers should work, but shouldn't really do anything more significant but print a debug statement. They're dangerous.

Answer 4

Shutdown hooks execute in all cases where the VM is not forcibly killed. So, if you were to issue a "standard" kill (SIGTERM from a kill command) then they will execute. Similarly, they will execute after calling System.exit(int).

However a hard kill (kill -9 or kill -SIGKILL) then they won't execute. Similarly (and obviously) they won't execute if you pull the power from the computer, drop it into a vat of boiling lava, or beat the CPU into pieces with a sledgehammer. You probably already knew that, though.

finalizers really should run as well, but its best not to rely on that for shutdown cleanup, but rather rely on your shutdown hooks to stop things cleanly. And, as always, be careful of deadlocks (I've seen far too many shutdown hooks hang the entire process)!

Answer 5

Thanks for you answers. Shutdown hooks seams like something that would work in my case. But I also bumped into the thing called Monitoring and Management beans:
http://java.sun.com/j2se/1.5.0/docs/guide/management/overview.html
That gives some nice possibilities, for remote monitoring, and manipulation of the java process. (Was introduced in Java 5)

Answer 6

Ok, after all the possibilities I have chosen to work with "Java Monitoring and Management"
Overview is here
That allows you to control one application from another one in relatively easy way. You can call the controlling application from a script to stop controlled application gracefully before killing it.

Here is the simplified code:

Controlled application:
run it with the folowing VM parameters:
-Dcom.sun.management.jmxremote
-Dcom.sun.management.jmxremote.port=9999
-Dcom.sun.management.jmxremote.authenticate=false
-Dcom.sun.management.jmxremote.ssl=false

//ThreadMonitorMBean.java
public interface ThreadMonitorMBean
{
String getName();
void start();
void stop();
boolean isRunning();
}

// ThreadMonitor.java
public class ThreadMonitor implements ThreadMonitorMBean
{
private Thread m_thrd = null;

public ThreadMonitor(Thread thrd)
{
 m_thrd = thrd;
}

@Override
public String getName()
{
 return "JMX Controlled App";
}

@Override
public void start()
{
 // TODO: start application here
 System.out.println("remote start called");
}

@Override
public void stop()
{
 // TODO: stop application here
 System.out.println("remote stop called");

 m_thrd.interrupt();
}

public boolean isRunning()
{
 return Thread.currentThread().isAlive();
}

public static void main(String[] args)
{
 try
 {
  System.out.println("JMX started");

  ThreadMonitorMBean monitor = new ThreadMonitor(Thread.currentThread());

  MBeanServer server = ManagementFactory.getPlatformMBeanServer();

  ObjectName name = new ObjectName("com.example:type=ThreadMonitor");

  server.registerMBean(monitor, name);

  while(!Thread.interrupted())
  {
   // loop until interrupted
   System.out.println(".");
            try 
            {
                Thread.sleep(1000);
            } 
            catch(InterruptedException ex) 
            {
                Thread.currentThread().interrupt();
            }
  }
 }
 catch(Exception e)
 {
  e.printStackTrace();
 }
 finally
 {
  // TODO: some final clean up could be here also
  System.out.println("JMX stopped");
 }
}
}

Controlling application:
run it with the stop or start as the command line argument

public class ThreadMonitorConsole
{

public static void main(String[] args)
{
 try
 { 
  // connecting to JMX
  System.out.println("Connect to JMX service.");
  JMXServiceURL url = new JMXServiceURL("service:jmx:rmi:///jndi/rmi://:9999/jmxrmi");
  JMXConnector jmxc = JMXConnectorFactory.connect(url, null);
  MBeanServerConnection mbsc = jmxc.getMBeanServerConnection();

  // Construct proxy for the the MBean object
  ObjectName mbeanName = new ObjectName("com.example:type=ThreadMonitor");
  ThreadMonitorMBean mbeanProxy = JMX.newMBeanProxy(mbsc, mbeanName, ThreadMonitorMBean.class, true);

  System.out.println("Connected to: "+mbeanProxy.getName()+", the app is "+(mbeanProxy.isRunning() ? "" : "not ")+"running");

  // parse command line arguments
  if(args[0].equalsIgnoreCase("start"))
  {
   System.out.println("Invoke \"start\" method");
   mbeanProxy.start();
  }
  else if(args[0].equalsIgnoreCase("stop"))
  {
   System.out.println("Invoke \"stop\" method");
   mbeanProxy.stop();
  }

  // clean up and exit
  jmxc.close();
  System.out.println("Done."); 
 }
 catch(Exception e)
 {
  // TODO Auto-generated catch block
  e.printStackTrace();
 }
}
}

That's it. :-)

Answer 7

An another way: your application can open a server socet and wait for an information arrived to it. For example a string with a "magic" word :) and then react to make shutdown: System.exit(). You can send such information to the socke using an external application like telnet.