ThreadFactory usage in Java

Question

Can someone briefly explain on HOW and WHEN to use a ThreadFactory? An example with and without using ThreadFactory might be really helpful to understand the differences.

Answer 1

Here's one possible usage:

Assume you have an ExecutorService which executes your Runnable tasks in a multithreaded fashion, and once in a while a thread dies from an uncaught exception. Let's also assume that you want to log all of these exceptions. ThreadFactory solves this problem by allowing you to define a uniform logger for uncaught exceptions in the Runnable that the thread was executing:

ExecutorService executor = Executors.newSingleThreadExecutor(new LoggingThreadFactory());

executor.submit(new Runnable() {
   @Override
   public void run() {
      someObject.someMethodThatThrowsRuntimeException();
   }
});

LoggingThreadFactory can be implemented like this one:

public class LoggingThreadFactory implements ThreadFactory
{

    @Override
    public Thread newThread(Runnable r)
    {
        Thread t = new Thread(r);

        t.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler()
        {
            @Override
            public void uncaughtException(Thread t, Throwable e)
            {
                LoggerFactory.getLogger(t.getName()).error(e.getMessage(), e);
            }
        });

        return t;
    }
}

---

The ThreadFactory interface is a flexible interface that allows the programmer to handle uncaught exceptions as shown above, but also allows much more control over the creation details of a Thread (like defining a pattern for the thread name) making it quite useful for debugging purposes and production environments alike.