Newsgroup: it.comp.java
Titolo: intercettare le eccezioni di un thread

[SOURCE]
public class Esempio extends Thread{
    public static void main(String[] args){
        try{
            Esempio mySelf=new Esempio();
            mySelf.start();
            do{
            }while(true);
        }catch(RuntimeException e){
            System.out.println("Eccezione intercettata...");
        }
    }
    public void run(){
        throw new RuntimeException("Thread exception!");
    }
}
[/SOURCE]
Mi aspettavo che il catch nel metodo main intercettasse l'exception generata
nel metodo run;
PERCHE' non succede?C'č modo per farlo succedere?
Grazie a chi mi saprŕ ILLUMINARE,
Maurizio.

 nel metodo run;
Un'eccezione generata in un thread o filo d'esecuzione puo' essere
recuperata solo in quello stesso filo d'esecuzione. Dopo la linea
"mySelf.start();" ci sono due thread: uno continua nella funzione main() e
l'altro esegue il codice nel metodo run() e da quel momento vivono vita
indipendente.
Quando in un thread viene lanciata un'ecccezione, questa dev'essere trattata
nel thread stesso. Se non lo fai, il thread si termina. Se si trattava
dell'ultimo thread vivente non demon, allora l'applicazione stessa chiude
baracca.
Dunque  quello che vuoi fare  é impossibile, ma non é grave perché una cosa
del genere non serve proprio. Piuttosto prova a dire quale problema
intendevi risolvere e ti si potrà dare delle soluzioni piu' appropriate.
bye
Carlo

Niente, l'idea era quella di poter interrompere un Thread("controllato")
tramite un'eccezione sollevata in un altro Thread("controllore"),
risparmiandomi così l'onere di verificare periodicamente nel
Thread("controllato") la richiesta di terminare.
Tra l'altro sollevare un'eccezione avrebbe risolto anche il problema di
interrompere il Tread("controllato") mentre esegue un'operazione bloccante,
consentendomi comunque nel catch di ripristinare la consistenza dei dati.
Pace, inventerò qualcos'altro.
Grazie comunque,
Maurizio.
--
La forza di gravità è un falso mito, è la terra che SUCCHIA!


 consentendomi comunque nel catch di ripristinare la consistenza dei dati.
Ecco come interrompere un thread in modo sicuro, anche quando esegue
operazioni bloccanti.
Prima di tutto ricordati che il metodo stop() é deprecated, perché puo'
creare problemi di consistenza.
Dunque, per interrompere un thread devi usare il metodo interrupt()
sull'oggetto thread, cosi' da generare un eccezione InterruptedException nel
thread stesso. Il thread si interrompe se era bloccato su sleep() o wait().
Intercettando l'eccezione puoi gestire l'interruzione in modo consistente.
C'é una sottigliezza: se il thread *non* era bloccato con sleep() o wait()
allora l'eccezione non é generata. Puoi comunque testare se c'é stato un
tentativo d'interruzione usando il metodo statico interrupted().
Ecco lo schema generale per programmare un thread "interrompibile":
public void run() {
    try {
        while( !interrupted() && hoAncoraDaFare) {
            faiQualcosa();
        }
    }
    catch(InterruptedException e) {
        /* thread interrotto durante sleep() o wait() */
    }
}
E in un altro thread, fai: mioThread.interrupt();
spero ti aiuti.
bye
Carlo

PERCHE' non succede?C'è modo per farlo succedere?
Tieni presente che "thread" significa due cose, in Java: uno "un flusso
di controllo che gira in parallelo col flusso di controllo principale";
due, "un oggetto di classe Thread". Le due cose sono correlate,
ovviamente, nel senso che l'unico modo per costruire e attivare un flusso
di controllo parallelo consiste nel creare un oggetto Thread e invocare
il suo metodo start(); che il flusso di controllo esegue le istruzioni
definite in Thread.run() (o nell'oggetto Runnable associato al thread); e
che il flusso termina quando l'esecuzione di run() termina. 
Detto questo, il tuo problema in dettaglio: l'eccezione e' sollevata nel
thread in cui gira Esempio.run(). Come ogni eccezione non trattata
localmente, causa l'uscita dal del metodo. Siccome per definizione un
user thread termina quando si esce run(), il tuo secondo thread si limita
a terminare. 
Se quello che vuoi fare e' comunicare al primo thread che si e'
verificata un'eccezione nel secondo, devi realizzare un supporto
esplicito per questo comportamento. Ci sono vari modi - uno dei
piu' efficaci e' un pattern di listening o observation. 
Prova a dare un'occhiata a 
http://www.sadun.org/software/lf
 per un
piccolo framework e una discussione in merito.
-- 
God is Real, unless declared Integer.
ObjectZone - 
http://space.tin.it/computer/csadun