Best-practice solution for exception-handling using threads/notifying parent thread about error in Java

I got a question regarding what is the best-practice solution for exception handling in threads:
My task is to implement a simplified version of SMTP on a TransferServer which receives a message and distributes it to the different mail servers associated with the recipient's domain.

So first I got a shared BlockedQueue where each client connection (in a separate thread) adds messages to send, and another ConsumerThread that works through the BlockedQueue, looks up domains and distributes each message to the right IP address.

In this consumer thread I have an ExecutorService which I submit the tasks of sending a message to a specified mail server. The problem now is the following: When message delivery to a mail server somehow fails, I need to send back a message to the sender informing them that the delivery failed. Additionally it can also happen in the consumer thread that a domain lookup fails and no mail server is found.

So I got two possible error cases:

1. Domain lookup fails
2. Message delivery fails

The first case happens right in the consumer thread and therefore it is very easy to just try to send another message back to the sender containing the error. The second case on the other hand is the one that keeps me stuck.

What would be best-practice to implement this error message sending in a separate message sending thread/task?

I thought of three different possible solutions:

1. Make my SenderTask implement Callable, not Runnable and return an error code, then periodically check for success (i somehow need to keep track of all Futures in this scenario) and if an error occurs, the parent ConsumerThread will initiate a new SenderTask which sends the error message back to the sender.
2. Pass ExecutorService to each SenderTask and let SenderTask submit a new error message SenderTask to the executor itself (feels weird to me)
3. Use an UncaughtExceptionHandler which handles the error message sending and create a ThreadFactory to use the handler with the executor

Which approach is the best suitable or is there even an easier way to achieve this?

For your case the best option is not to transfer exceptions between threads at all. What you can do is make error handling with the asynchronous operation it self, so that you need no any thread synchronization. Error handler can be injected to asynchronous operation as an interface. For example:

public interface ErrorHandler {
  void handleDomainLookup(DomainLookupException exc);
  void handleMessageDeliveryFails(MessageDeliveryFailsException exc);
}
.....    
public class AsynchronousEmailTask implements Runnable {
   private final ErrorHandler errorHandler;
   // you may need some another arguments for sending email
   public AsynchronousEmailTask(ErrorHandler errorHandler) {
     this.errorHandler = errorHandler;
   }
   @Override
   public void run() {
      try {
        sendEmail();
      } catch(MessageDeliveryFailsException exc) {
        this.errorHandler.handleMessageDeliveryFails(exc);
      } catch(DomainLookupException exc) {
        this.errorHandler.handleDomainLookup(exc);
      }
   }
   void sendEmail() throws DomainLookupException, MessageDeliveryFailsException {
    // TODO: implement me
   }
}
......
class Consumer implements ErrorHandler {
...
 public void handleDomainLookup(DomainLookupException exc) {
   // TODO: implement me
 }
 public void handleMessageDeliveryFails(MessageDeliveryFailsException exc) {
   // TODO: implement me
 }
...
 void consume() {
   ...
     pool.submit(new AsynchronousEmailTask(this) );
 }

}