Table of Contents

Given problem

Normally, when we are working with multithreading in Java project, we will use a class that implements Runnable interface, or extends Thread class. But it has some disadvantages that we need to take care.

  • Do not setup thread priority.
  • Do not provide the thread’s name.

Solution with ThreadFactory

  1. Syntax of ThreadFactory

     public interface ThreadFactory {
         Thread newThread(Runnable r);

Source code

  1. Defines our custom class that implements ThreadFactory interface

     public class MpThreadFactory implements ThreadFactory {
         private String name;
         public MpThreadFactory(String name) {
    = name;
         public Thread newThread(Runnable r) {
             Thread t = new Thread(r,;
  2. Using ThreadFactoryBuilder in Guava concurrent library.

     ThreadFactory threadFactory = new ThreadFactoryBuilder()
  3. Using VerboseThread class in JCabi Log library.

    To use JCabi Log library, insert the below dependency.


    The VerboseThread class will log all runtime exceptions through SLF4J. VerboseThreads factory should be used together with executor services from java.util.concurrent package.

     ThreadFactory factory = new VerboseThreads();
     Executors.newScheduledThreadPool(2, factory).scheduleAtFixedRate(
         new Runnable() {
             public void run() {
             // the same sensitive operation that may throw
             // a runtime exception
         }, 1L, 1L, TimeUnit.SECONDS

Benefits and Drawbacks

  1. Benefits

    • Enable application to use special thread subclasses.

    • Adding the priority for each thread.

    • Support to fill the thread’s name.

      It’s really helpful when we cope with the bug in our program, we can see the thread’s name.

    • We can use factory pattern with ThreadFactory, and then use statistic for our threads.

  2. Drawbacks

Wrapping up

  • Understanding about why we should use ThreadFactory over Runnable interface or Thread class.