Best practices for checked exceptions in Runnable.run

Question

Runnable.run cannot be modified to pass a checked exception to its parent, so it must deal with any checked exceptions that occur. Simply logging the error is inadequate, and I am wondering if there are any "best practices" on how to deal with this situation.
Let me give a real-world example of what I'm talking about.
When writing I/O code for a single-threaded app, I'll break the logic into methods, and declare these methods as throwing an IOException. Basically, I'll ignore all exceptions and simply pass them up the stack, knowing that Java's checked exception facility will force the caller to deal with error conditions.
Some time later, I might try to improve performance by making the I/O code multithreaded. But now things get tricky because I can no longer ignore exceptions. When I refactor the code into a Runnable, it cannot simply toss IOExceptions to some future unnamed caller. It must now catch and handle the IOException. Of course, dealing with the problem by simply catching and logging the exception is bad, because the code that spawned the I/O thread won't know that anything went wrong. Instead, the I/O thread must somehow notify its parent that the exception occurred. But just how to do this is not straightforward.
Any thoughts? Thanks.

Answer 1

My suggestion: don't use Threads and Runnables like this.
Instead implement Callable which can throw any Exception.
Then use an ExecutorService to run that Callable.
This will return a Future object which can throw an ExecutionException on get(), which you can then handle.
This has the additional advantage that you can easily switch from a single-threaded serialized execution to a multi-threaded one by switching ExecutorService implementations (or even by tweaking the parameters of the ExecutorService implementation).