Lo stack di chiamate e la cattura degli errori

"Ciao Amico!

"Voglio parlarti di qualcosa di piccolo, ma interessante."

"Sto ascoltando. Amo le cose piccole e interessanti."

"Beh, sai che ogni oggetto Thread ha un metodo run(). E che puoi eseguirlo su un thread separato usando il metodo start()."

"Sì, naturalmente."

"Ma ora immagina questa situazione: avvii un thread per eseguire del lavoro, ma viene generata un'eccezione e il thread smette di funzionare perché non sa cosa fare. Non avresti bisogno di sapere di questo errore in qualche modo?"

"Sono d'accordo. Avrei bisogno di catturare in qualche modo l'eccezione che si è verificata sull'altro thread in esecuzione. Java lo supporta anche?"

"Mi insulti. Certo che lo fa."

"I creatori di Java hanno inventato un'interfaccia speciale chiamata UncaughtExceptionHandler. Ecco come rilevare e gestire un'eccezione che si verifica su un altro thread, se quel thread non la rileva:"

public class DownloadManager
{
 public static void main(String[] args)
 {
   Thread thread = new DownloadThread();
   thread.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler()
   {
    @Override
    public void uncaughtException(Thread t, Throwable e)
    {

    }
 });

 thread.start();
}

"L'oggetto Thread ha un metodo speciale setUncaughtExceptionHandler . Devi passargli un oggetto che implementa l' interfaccia Thread.UncaughtExceptionHandler . Questa interfaccia ha un solo metodo: uncaughtException(Thread t, Throwable e) . Questo è il metodo che verrà chiamato l'oggetto passato se si verifica un'eccezione non rilevata nel metodo run."

"Nel mio esempio sopra, dichiaro semplicemente una classe interna anonima (evidenziata in rosso) che implementa l'interfaccia Thread. Thread.UncaughtExceptionHandler . E sovrascrivo il suo metodo uncaughtException(Thread t, Throwable e) ."

"Come puoi vedere dall'elenco dei parametri del metodo, verranno passati due argomenti: un riferimento all'oggetto Thread in cui si è verificata l'eccezione e l'eccezione stessa, passata come Throwable e."

"Bene, perché ho bisogno della variabile Thread t? Non sappiamo già in quale Thread stiamo inserendo un oggetto Thread.UncaughtExceptionHandler ?"

"L'hanno fatto in modo che tu possa scrivere un gestore universale per queste situazioni, ovvero puoi creare un singolo oggetto e passarlo a dozzine di thread diversi. Quindi il metodo uncaughtException(Thread t, Throwable e) ti dà sempre un riferimento al Oggetto thread in cui si è verificata l'eccezione."

"Inoltre, puoi creare dozzine di thread, ad esempio, in un ciclo per eseguire attività specifiche. In generale, questo riferimento all'oggetto Thread non sarà superfluo. Te lo prometto."

"Ti credo. Non hai mai sbagliato."