Come si interrompe un processo Java con grazia in Linux e Windows?
Quando Runtime.getRuntime().addShutdownHookviene chiamato e quando no?
E i finalizzatori, aiutano qui?
Posso inviare una sorta di segnale a un processo Java da una shell?
Sto cercando soluzioni preferibilmente portatili.
Risposte:
Gli hook di arresto vengono eseguiti in tutti i casi in cui la VM non viene uccisa forzatamente. Quindi, se si dovesse emettere un kill "standard" ( SIGTERMda un comando kill), allora verranno eseguiti. Allo stesso modo, verranno eseguiti dopo la chiamata System.exit(int).
Tuttavia un hard kill ( kill -9o kill -SIGKILL) non verranno eseguiti. Allo stesso modo (e ovviamente) non verranno eseguiti se si estrae l'alimentazione dal computer, lo si lascia cadere in una vasca di lava bollente o si fa a pezzi la CPU con una mazza. Probabilmente lo sapevi già, però.
Anche i finalizzatori dovrebbero funzionare, ma è meglio non fare affidamento su questo per la pulizia dell'arresto, ma piuttosto fare affidamento sugli hook di arresto per fermare le cose in modo pulito. E, come sempre, fai attenzione ai deadlock (ho visto troppi ganci di arresto sospendere l'intero processo)!
Ok, dopo tutte le possibilità che ho scelto di lavorare con "Java Monitoring and Management"
Panoramica è qui
che ti permette di controllare un'applicazione da un'altra in modo relativamente semplice. È possibile chiamare l'applicazione di controllo da uno script per arrestare correttamente l'applicazione controllata prima di ucciderla.
Ecco il codice semplificato:
Applicazione controllata:
eseguirla con i seguenti parametri VM:
-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");
}
}
}
Controllo dell'applicazione:
eseguilo con stop o start come argomento della riga di comando
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();
}
}
}
Questo è tutto. :-)
Un altro modo: la tua applicazione può aprire un server socet e attendere che le informazioni arrivino. Ad esempio una stringa con una parola "magica" :) e poi reagire per fare shutdown: System.exit (). È possibile inviare tali informazioni a socke utilizzando un'applicazione esterna come telnet.
Ecco una soluzione un po 'complicata, ma portatile:
Ho implementato l'agente Java. È disponibile su Github: https://github.com/everit-org/javaagent-shutdown
Una descrizione dettagliata della soluzione è disponibile qui: https://everitorg.wordpress.com/2016/06/15/shutting-down-a-jvm-process/
Domanda simile qui
I finalizzatori in Java sono pessimi. Aggiungono un sacco di overhead alla raccolta dei rifiuti. Evitalo quando possibile.
ShutdownHook verrà chiamato solo quando la VM si sta spegnendo. Penso che possa fare molto bene quello che vuoi.
La segnalazione in Linux può essere eseguita con "kill" (man kill per i segnali disponibili), avresti bisogno dell'ID del processo per farlo. (ps ax | grep java) o qualcosa del genere, o memorizza l'id del processo quando il processo viene creato (questo è usato nella maggior parte dei file di avvio di Linux, vedere /etc/init.d)
La segnalazione portatile può essere eseguita integrando un SocketServer nella tua applicazione java. Non è così difficile e ti dà la libertà di inviare qualsiasi comando tu voglia.
Se intendevi infine clausole invece di finalizzatori; non vengono estesi quando viene chiamato System.exit (). I finalizzatori dovrebbero funzionare, ma in realtà non dovrebbero fare nulla di più significativo se non stampare un'istruzione di debug. Sono pericolosi.
Grazie per le tue risposte. I ganci di arresto sembrano qualcosa che potrebbe funzionare nel mio caso. Ma mi sono anche imbattuto nella cosa chiamata bean di monitoraggio e gestione:
http://java.sun.com/j2se/1.5.0/docs/guide/management/overview.html
Che offre alcune belle possibilità, per il monitoraggio remoto e la manipolazione del processo java. (È stato introdotto in Java 5)