Newsgroup: it.comp.java
Titolo: Processi singoli della stessa applicazione

Avrei l'esigenza di evitare che il mio programma venga lanciato più di
una volta. L'idea che ho in mente io è confrontando tutti i processi
in esecuzione nel sistema operativo, e controllarli con il mio, ma
come. Se qualcuno mi sa dire come si fa o ha qualche idea in proposito
mi faccia sapere grazie.



Per l'esame dei processi in esecuzione devi usare le funzionalita'
specifiche del sistema operativo (ad esempio lanciando un comando esterno,
come ps in Unix/Linux e catturandone l'output).
In questo modo pero' riduci la portabilita' della tua applicazione.
Un modo piu' portabile potrebbe essere quello di creare un file all'avvio
della tua applicazione e cancellarlo alla terminazione. E'
sufficiente controllare se quel file e' presente per sapere se
l'applicazione e' gia' in esecuzione (salvo crash intermedi che non hanno
permesso la cancellazione del file).
-- 
Lucio Benfante
Java User Group Padova: 
http://www.jugpadova.it
Brainbench MVP for Java 1: 
http://www.brainbench.com
MyTranscript: 
http://www.brainbench.com/transcript.jsp?pid=167064

 wrote in message
news:4b9ef321.03092...@posting.google.com...



Io proverei inserendo nella classe principale dell'applicazione una 
variabile statica e pubblica di tipo booleano, la quale viene impostata 
dal costruttore e controllata nel main.
Provo a spiegarmi meglio:
public class Launcher {
   public static boolean started = false;
   public Launcher() {
     started = true;
     /* codice classe */
   }
   public static void main(String[] args) {
     if (Launcher.started) {
       System.exut(0);
     }
     new Launcher();
   }
}
-- 
+-------------------------+--------------------------------------+
| GNU/Linux Slackware 9.0 | Java                                 |
+-------------------------+--------------------------------------+
| Linux Registered User #313185 at 
http://www.counter.li.org
     |
+----------------------------------------------------------------+
| GPG Key available on 
www.keyserver.net
 (key_ID: 0x1B6FF4DC)    |
+----------------------------------------------------------------+

 wrote in message
news:oOldb.1831$uv4...@news.edisontel.com...


 volte..[cut]
A parte il fatto che il codice che ho scritto è privo di senso (mea 
culpa), hai perfettamente ragione.
Forse si potrebbe utilizzare file di lock.


Bye
IMHO è la soluzione migliore, però nn c'è bisogno di inviare il messaggio
sul socket: se un secondo server socket (un altra istanza del programma) è
lanciato sulla stessa interfaccia di rete (es. localhost) e sulla stessa
porta del primo, allora verrà lanciata un'eccezione di binding.
Mauro
--
L’uomo è condannato ad essere libero: condannato perché non si è creato da
se stesso, e pur tuttavia libero, perché, una volta gettato nel mondo, è
responsabile di tutto ciò che fa.(Sartre)

 wrote in message
news:bl6boh$bvb$1...@lacerta.tiscalinet.it...


sinceramente piuttosto che occupare risorse con una socket (dove rischi di
trovarti una porta occupata da qualsiasi altro processo) utilizzerei un
tempfile di java. la classe File ti permette di creare file che possono
essere cancellati oltre che manualmente in automatico dalla virtual
machine allo shutdown della stessa.
in questo caso funzionerebbe come la maggioranza dei sistemi di lock unix
dove solitamente questi file vengono salvati in /var/locks o /var/run.
se la scrittura su disco non è possibile dovrai ricorrere necessariamente
o ad una socket o al recupero dei processi tramite ps -ef | grep app ma
attenzione che la virtual machine sarà solo java <params> classe <params>
e se la linea di comando è troppo lunga il grep di solito la taglia,
inoltre, ps c'è in unix ma non in windows (perlomeno non l'ho visto :))
in qualsiasi caso, il tempfile java ti garantisce l'atomicità
dell'operazione. 
ciao
On Fri, 26 Sep 2003 09:48:51 -0700, vendel wrote:


Forse l'unico problema che può comportare l'uso del tempfile è che se la tua
applicazione finisce in "abnormal mode" il file non viene cancellato e a te
risulta in esecuzione........
Quindi devi prevedere una procedura manuale di controllo, oppure dovresti
ogni n secondi scivere il time (hh:mm:ss) in questo modo un'altra
applicazione leggendo il file sa' se c'e' un processo attivo.
Per quanto riguarda il "ps -ef | grep aa" lo sconsiglio, come hai detto tu,
non è portabile (vale solo per Unix e non per Windows)
Bye
"gparmiggiani" <gNOSPAMpa...@NOSPAMetasistemi.it> wrote in message
news:pan.2003.09.29....@NOSPAMetasistemi.it...



perchè ti devi complicare la vita???
spedisci un messaggio sul sock????
attendi 5s ???? (cmq ci si può prendere un caffè nel mentre ;-) )
aspetti la risposta?????
ti basta molto semplicemente fare:
try {
    ServerSocket ss = new ServerSocket(8000);
    System.out.println("Nuova istanza");
}
catch (IOException ioEx) {
    System.out.println("Già lanciato...");
}

in unix fondamentalmente hai lo stessa problema, se un app viene killata
(-9) o va in core dump il file di lock non viene rimosso. la cosa viene
però ovviata salvndo nel tempfile il pid del processo di modo che gli
script di startup possano effettivamente verificarne l'esistenza: è un
metodo un po' empirico ma generalmente funziona così.
non essendoci, almeno credo, api specifiche per il controllo di processi
esterni da java non vedo altre soluzioni.. a meno che qualcuno non si
prenda la briga di fare una bella lib jni ;)
ciauz
