De call-stack en het opvangen van fouten

"Hallo Amigo!

"Ik wil je vertellen over iets kleins, maar interessants."

"Ik luister. Ik hou van dingen die klein en interessant zijn."

"Nou, je weet dat elk Thread-object een run()-methode heeft. En dat je het op een aparte thread kunt uitvoeren met behulp van de start()-methode."

"Ja natuurlijk."

"Maar stel je nu deze situatie voor: je start een thread om wat werk uit te voeren, maar er wordt een uitzondering gegenereerd en de thread stopt met werken omdat hij niet weet wat hij moet doen. Zou je deze fout niet op de een of andere manier moeten weten?"

"Ik ben het ermee eens. Ik zou op de een of andere manier de uitzondering moeten opvangen die zich voordeed op de andere lopende thread. Ondersteunt Java dat zelfs?"

'Je beledigt me. Natuurlijk wel.'

"De makers van Java hebben een speciale interface uitgevonden met de naam UncaughtExceptionHandler. Hier leest u hoe u een uitzondering op een andere thread kunt opvangen en afhandelen, als die thread deze niet opvangt:"

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();
}

"Het Thread-object heeft een speciale setUncaughtExceptionHandler- methode. U moet het doorgeven aan een object dat de Thread.UncaughtExceptionHandler- interface implementeert. Deze interface heeft slechts één methode: uncaughtException(Thread t, Throwable e) . Dit is de methode die wordt aangeroepen het doorgegeven object als er een niet-afgevangen uitzondering optreedt in de run-methode."

"In mijn voorbeeld hierboven verklaar ik gewoon een anonieme innerlijke klasse (rood gemarkeerd) die de Thread. Thread.UncaughtExceptionHandler- interface implementeert. En ik overschrijf de methode uncaughtException (Thread t, Throwable e) ."

"Zoals je kunt zien in de parameterlijst van de methode, worden er twee argumenten doorgegeven: een verwijzing naar het Thread-object waar de uitzondering optrad, en de uitzondering zelf, doorgegeven als Throwable e."

"Nou, waarom heb ik de Thread-variabele t nodig? Weten we niet al in welke Thread we een Thread.UncaughtExceptionHandler- object plaatsen ?"

"Ze deden dit zodat je een universele handler voor deze situaties kunt schrijven. Dat wil zeggen dat je een enkel object kunt maken en dit kunt doorgeven aan tientallen verschillende threads. Vervolgens geeft de methode uncaughtException (Thread t, Throwable e) je altijd een verwijzing naar de Thread-object waar de uitzondering optrad."

"Bovendien kun je bijvoorbeeld tientallen threads in een lus maken om specifieke taken uit te voeren. Over het algemeen is deze verwijzing naar het Thread-object niet overbodig. Dat beloof ik je."

'Ik geloof je. Je hebt je nooit vergist.'