Comment arrêter le processus java gracieusement?

Ok, après toutes les possibilités, j'ai choisi de travailler avec "Java de Surveillance et de Gestion"

Vue d'ensemble est ici

Qui vous permet de contrôler une application à partir d'une autre de façon relativement facile. Vous pouvez appeler l'application de contrôle à partir d'un script pour arrêter l'application contrôlée gracieusement avant de le tuer.

Voici le code simplifié:

Application contrôlée:

exécuter avec le suivant VM paramètres:

-Dcom.soleil.de la gestion.jmxremote

-Dcom.soleil.de la gestion.jmxremote.port=9999

-Dcom.soleil.de la gestion.jmxremote.authentifier=false

-Dcom.soleil.de la gestion.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");
}
}
}

Application de contrôle:

exécuter avec la arrêter ou commencer que l'argument de ligne de commande

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();
}
}
}

C'est tout. 🙂

Question Similaire Ici

Finaliseurs en Java sont mauvais. Elles apportent beaucoup de généraux à la collecte des déchets. Éviter autant que possible.

La shutdownHook uniquement quand la machine virtuelle est en cours d'arrêt. Je pense qu'il peut très bien le faire ce que vous voulez.

De signalisation dans Linux peut se faire "tuer" (l'homme à tuer pour les signaux disponibles), vous auriez besoin de l'ID de processus pour le faire. (ps ax | grep java) ou quelque chose comme ça, ou de stocker l'id de processus lorsque le processus est créé (il est utilisé dans la plupart des linux les fichiers de démarrage, voir /etc/init.d)

Portable de signalisation peut être fait par l'intégration d'une SocketServer dans votre application java. Il n'est pas difficile et vous donne la liberté de vous envoyer toutes les commandes que vous voulez.

Si vous vouliez dire, enfin, des clauses en place des finaliseurs; ils n'ont pas extecuted lorsque le Système.exit() est appelée.
Les finaliseurs devrait fonctionner, mais ne devrait pas vraiment faire quelque chose de plus important, mais l'impression d'une instruction de débogage. Ils sont dangereux.