Gestione eccezione con Thread.UncaughtExceptionHandler

[M@P]

Dato il seguente codice:

import java.util.*;
import java.util.concurrent.*;

class ExceptionThread implements Runnable {
    public void run() { throw new RuntimeException(); }
}

class Handler implements Thread.UncaughtExceptionHandler {
    public void uncaughtException(Thread t, Throwable e) {
        System.out.println("caught " + e);
    }
}

public class Test {
    public static void main(String[] args) {
	//Thread.setDefaultUncaughtExceptionHandler(new Handler());
		
        ExecutorService exec = Executors.newCachedThreadPool();
	Thread t = new Thread(new ExceptionThread());
	t.setUncaughtExceptionHandler(new Handler());
		
	exec.execute(t);
    }
}

Non riesco a capire perchè non viene gestita l'eccezione lanciata nel metodo run() della classe ExceptionThread, mentre invece funziona tutto se inserisco la linea di codice nel commento. Qualcuno sa dirmi qualcosa?

Grazie.

[andbin]

Originariamente inviato da M@P
Non riesco a capire perchè non viene gestita l'eccezione lanciata nel metodo run() della classe ExceptionThread, mentre invece funziona tutto se inserisco la linea di codice nel commento. Qualcuno sa dirmi qualcosa?

Prima questione tecnica sul "executor framework" disponibile da Java 5: i thread pool gestiti da questo framework gestiscono, almeno nel modo standard, i thread e la loro istanziazione in maniera autonoma. Tu quindi non devi passare un Thread ma solo dei "task" (dei "lavori") che tecnicamente sono rappresentati da un Runnable o per un submit() anche un Callable (una specializzazione di Runnable).

Pertanto che tu crei un java.lang.Thread

Thread t = new Thread(new ExceptionThread());
exec.execute(t);

non serve, basta solo che passi una istanza di ExceptionThread che è un Runnable:

exec.execute(new ExceptionThread());


Seconda questione, conseguente: anche se hai passato un java.lang.Thread e hai invocato setUncaughtExceptionHandler, come detto sopra il thread pool non lo tratta come Thread ... solo come Runnable. Ripeto, nel caso non ti fosse ancora chiaro: così facendo non fai partire un tuo thread ... ci pensa il thread pool a creare i thread e scegliere in quale di questi eseguire il tuo "lavoro".


Terza questione, soluzione: se vuoi gestire un UncaughtExceptionHandler per i pool hai 2 possibilità. Puoi settare un handler "globale" con Thread.setDefaultUncaughtExceptionHandler() ma essendo appunto a livello generale potrebbe non andarti bene (per questo o altri motivi).

Oppure puoi gestire tu la creazione dei thread per il pool tramite un ThreadFactory. Se guardi tra i metodi newXXX() di Executors ci sono le versioni che in più ricevono un ThreadFactory. In questo caso particolare verrebbe chiesto alla tua "factory" di creare un Thread e quindi puoi settare l'handler sul thread specifico che crei e fornisci al pool.

[M@P]

Adesso mi è decisamente tutto più chiaro. Grazie andbin per l'ennesima e ottima spiegazione.