Avviare e Terminare Processi in Java

[fabio1982]

Salve a tutti,
ho scritto in java la seguente classe:

public class Elem{
public Elem(String [] str){
this.cmd = str;
}

private String [] cmd;
public String aid = null;
public String bat = null;
public Process proc;
public Elem next = null;
private Runtime rt = Runtime.getRuntime();

public void Lanch(){
try {
proc = rt.exec(cmd);
} catch (IOException ex) {
ex.printStackTrace();
}
}

public void Exit(){
proc.destroy();

}
}

Il comando cmd eseguito attraverso la funzione Lunch() è il seguente:

cmd[0] = "cmd.exe";
cmd[1] = "/C";
cmd[2] = "start";
cmd[3] = "C:/jade/RunProgramm/File.bat";

Fin qui và alla grande,si avvia cmd.exe che esegue il mio file.bat
il problema è che quando chiamo la funzione Exit(),il processo non viene distrutto,infatti nel task di win,nei processi resta presente.
Ho provato anche con waitFor(), exitValue(),ma non c'è nulla da fare,il processo rimane attivo.
Qualcuno di voi saprebbe darmi qualche diritta?

Ringrazio anticipatamente tutti coloro che interverrano a questa discussione.

[LeleFT]

Java ha un sub-forum dedicato.
Inoltre il codice va postato all'interno dei tag [ CODE ] come indicato nel regolamento.

Sposto la discussione.


Ciao.

[fabio1982]

Scusami,ma purtoppo me ne sono reso conto troppo tardi.
Per quanto riguarda la mia problematica non sapresti darmi qualche indicazione?
Grazie.

[andbin]

Originariamente inviato da fabio1982
Il comando cmd eseguito attraverso la funzione Lunch() è il seguente:

cmd[0] = "cmd.exe";
cmd[1] = "/C";
cmd[2] = "start";
cmd[3] = "C:/jade/RunProgramm/File.bat";

Fin qui và alla grande,si avvia cmd.exe che esegue il mio file.bat
il problema è che quando chiamo la funzione Exit(),il processo non viene distrutto,infatti nel task di win,nei processi resta presente.

La questione è che avendo usato "start", il processo cmd.exe (che è quello direttamente lanciato da Java) ha una durata praticamente brevissima ... si limita solo a creare una nuova shell in cui interpretare il bat e poi esce immediatamente, senza aspettare la terminazione di quella shell.

Quindi quando tu cerchi di fare il destroy(), il processo cmd.exe quasi sicuramente è già terminato!!

Dovresti non usare "start", quindi:

cmd[0] = "cmd.exe";
cmd[1] = "/C";
cmd[2] = "C:/jade/RunProgramm/File.bat";

in questo modo il processo cmd.exe lanciato resta in vita per tutto il tempo di esecuzione del bat. Quindi se fai un destroy(), distruggi la shell che sta realmente interpretando il bat.

Ma nota, non distruggeresti gli eventuali processi lanciati dall'interno del bat.

[fabio1982]

Ok!
Adesso provo,grazie mille .

[fabio1982]

Ho provato e così facendo,non mi esegue le istruzioni contenute nel file.bat.
In effetti a me servirebbe chiudere l'applicazione cmd.exe che esegue il bat facendolo da programma.
Il file bat eseguito avvia nei processi di win un nuovo processo java.exe ed questo che io vorrei distrugere o terminare da programma.
Tu pensi si possa fare?
Attenzione però io voglio terminare solo quel processo java.exe e non anche gli altri.

[andbin]

Originariamente inviato da fabio1982
Il file bat eseguito avvia nei processi di win un nuovo processo java.exe ed questo che io vorrei distrugere o terminare da programma.

Allora no. Con Runtime avvii 1 processo, che nel tuo caso è cmd.exe. È questo a cui fa riferimento l'oggetto Process e su cui hai il controllo. Non su ciò che eventualmente il processo lancia a sua volta.

Non credo che si possa fare ... non con le API standard di Java. Bisognerebbe determinare il PID del processo java.exe lanciato e quindi usare poi un comando di sistema per terminarlo.

[fabio1982]

Ho trovato questa classe java per determinare il pid:

package dpml.util;

import java.io.Serializable;

import java.util.Random;

/**
* The PID class is a process identifer.
*
* @author @PUBLISHER-NAME@
* @version @PROJECT-VERSION@
*/
public class PID implements Serializable
{
private final int m_value;

/**
* Creation of a new process identifier.
*/
public PID()
{
m_value = setupInitialValue();
}

/**
* Creation of a new process identifier.
*/
private PID( int id )
{
m_value = id;
}

private static int setupInitialValue()
{
String id = System.getProperty( "process.id" );
if( null == id )
{
return Math.abs( new Random().nextInt() );
}
else
{
try
{
return Integer.parseInt( id );
}
catch( NumberFormatException e )
{
return Math.abs( new Random().nextInt() );
}
}
}

/**
* Return the process identifier int value.
* @return the process id value
*/
public int getValue()
{
return m_value;
}

/**
* Return the string representation of this process identifier.
* @return the process identifier as a string
*/
public String toString()
{
return "[" + m_value + "]";
}

/**
* Test if a supplied object is equal to this process identifier.
* @param other the object to compare with this object
* @return TRUE if the objects are equivalent
*/
public boolean equals( Object other )
{
if( other instanceof PID )
{
PID pid = (PID) other;
return getValue() == pid.getValue();
}
else
{
return false;
}
}

/**
* Return the hashcode for this PID instance.
* @return the hashcode value
*/
public int hashCode()
{
return getValue();
}
}

Quale comando devo utilizzare ora per terminare il processo con relativo pid?

[andbin]

Non so chi ha fatto quella classe .... e non so a cosa/quanto possa servire. Non mi risulta che ci sia una proprietà "standard" di sistema di nome "process.id". E non capisco cosa possa servire usare Random e nextInt().

Cerchiamo di non andare troppo fuori dal seminato ....

qui l'autore del blog spiega alcune possibili soluzioni. Tutte però sono fortemente dipendenti dalla JVM e/o dal sistema operativo.