[转载]ScheduledThreadPoolExecutor and exception handling

1. Original Question: https://forums.oracle.com/forums/thread.jspa?threadID=1142455

Hi All,
i'm using ScheduledThreadPoolExecutor (with jdk 1.5) and I'm
wondering about exception handling. My first goal is to handle the exceptions
thrown by my Runnable task during its executions. I tried doing my ThreadFactory
in order to add an Thread.UncaughtExceptionHandler to all created threads. This
doesn't work because the exception is always caught by the FutureTask (see
FutureTask$Sync.innerRun()) so my handler is never called.

I tried doing
my Executor:

public class MyExecutor extends ScheduledThreadPoolExecutor {
 
    private Thread.UncaughtExceptionHandler exceptionHandler = null;
 
    MyExecutor (int maxThreadPoolSize,
                            Thread.UncaughtExceptionHandler exceptionHandler) {
        super(maxThreadPoolSize);
        this.exceptionHandler = exceptionHandler;
    }
 
    MyExecutor (int maxThreadPoolSize,
                            ThreadFactory threadFactory,
                            Thread.UncaughtExceptionHandler exceptionHandler) {
        super(maxThreadPoolSize, threadFactory);
        this.exceptionHandler = exceptionHandler;
    }
 
    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        super.afterExecute(r, t);
        if (r instanceof Future<?>) {
            try {
                if (((Future<?>) r).isDone()) {
                    Object result = ((Future<?>) r).get();
                }
            } catch (InterruptedException ie) {
            } catch (ExecutionException ee) {
                Throwable realThrowable = ee.getCause();
                MyException e = new MyException (realThrowable);
                exceptionHandler.uncaughtException(Thread.currentThread(), e);
            } catch (CancellationException ce) {
            }
        }
    }
}

and it seems to work fine.
What do you think about that ?
Done this, my second goal is to re-schedule a task that threw an exception.

Has anyone has an idea ?
A thing I could do is to re-schedule the task in my exception handling, but in that method I don't have any reference to my Runnable object; I have just a ScheduledFuture but I didn't find a way to get my Runnable object and I need a reference to my object because I have different objects run and without that infomation I don't know what to re-schedule.
Can any body shed light on it?
Thanks a lot Stefano

Re: ScheduledThreadPoolExecutor and exception handling

There is always an issue with granularity when it comes to uncaught exceptions.
The UncaughtExceptionHandler acts at the Thread-level such that if the Thread's
run() method terminates due to an exception then the UEH is called. However
there is no mechanism for dealing with uncaught exceptions at the level of
Runnable's. As you discovered FutureTask never lets exceptions escape so the UEH
never comes into play.

One way to deal with it is as you have by
subclassing ScheduledThreadPoolExecutor and using afterExecute to see if you
have a Future and call Future.get which will throw the exception. It is a bit
kludgy to force the exception to be thrown and immediately catch it but you
don't have a choice.

The other option is use a concrete Runnable class
that encapsulates the real Runnable so that it catches all exceptions - that way
the FutureTask never gets them. I prefer this way if you can control submission
to the executor. This way also allows you to re-submit to the executor more
easily - otherwise you have to maintain the association between Runnables and
FutureTasks yourself.

2. Original Question: http://stackoverflow.com/questions/3875739/exception-handling-in-threadpools/3875784#3875784

Solution 1:

Decorator pattern, for example:

public class CatcherRunnable implements Runnable {
    private Runnable runMe;

    public CatcherRunnable(Runnable runMe) {
        this.runMe = runMe;
    }

    public void run() {
        try {
            runMe.run();
        } catch (Exception ex){
            ex.printStackTrace();
        }
    }
}

Wrap all your Runnables with this CatcherRunnable.

Solution2: (doesn't work with ScheduledThreadPoolExecutor)

Provide this factory to the Executor you use.

private static class ExceptionCatchingThreadFactory implements ThreadFactory {
    private final ThreadFactory delegate;

    private ExceptionCatchingThreadFactory(ThreadFactory delegate) {
        this.delegate = delegate;
    }

    public Thread newThread(final Runnable r) {
        Thread t = delegate.newThread(r);
        t.setUncaughtExceptionHandler(new UncaughtExceptionHandler() {
            @Override
            public void uncaughtException(Thread t, Throwable e) {
                e.printStackTrace();  //replace with your handling logic.
            }
        });
        return t;
    }
}