The example for this recipe has been implemented using the Eclipse IDE. If you use Eclipse or a different IDE, such as NetBeans, open it and create a new Java project.

Follow these steps to implement the example:

       public class MyThreadFactory implements ThreadFactory {

        private int counter; 
        private String name; 
        private List<String> stats; 

        public MyThreadFactory(String name){ 
          counter=0; 
          this.name=name; 
          stats=new ArrayList<String>(); 
        }

        @Override 
        public Thread newThread(Runnable r) { 
          Thread t=new Thread(r,name+"-Thread_"+counter); 
          counter++; 
          stats.add(String.format("Created thread %d with name %s on %s\n",
                                  t.getId(),t.getName(),new Date())); 
          return t; 
        }

        public String getStats(){ 
          StringBuffer buffer=new StringBuffer(); 
          Iterator<String> it=stats.iterator(); 

          while (it.hasNext()) { 
            buffer.append(it.next()); 
            buffer.append("\n"); 
          } 

          return buffer.toString(); 
        }

        public class Task implements Runnable { 
          @Override 
          public void run() { 
            try { 
              TimeUnit.SECONDS.sleep(1); 
            } catch (InterruptedException e) { 
              e.printStackTrace(); 
            } 
          } 
        }

        public class Main { 
          public static void main(String[] args) {

        MyThreadFactory factory=new MyThreadFactory("MyThreadFactory"); 
        Task task=new Task();

        Thread thread; 
        System.out.printf("Starting the Threads\n"); 
        for (int i=0; i<10; i++){ 
           thread=factory.newThread(task); 
          thread.start(); 
        }

        System.out.printf("Factory stats:\n"); 
        System.out.printf("%s\n",factory.getStats());

The ThreadFactory interface has only one method, called newThread(). It receives a Runnable object as a parameter and returns a Thread object. When you implement a ThreadFactory interface, you have to implement it and override the newThread method. The most basic ThreadFactory has only one line:

    return new Thread(r);

You can improve this implementation by adding some variants, as follows:

You can add anything else you can imagine to the preceding list. The use of the factory design pattern is a good programming practice, but if you implement a ThreadFactory interface to centralize the creation of threads, you will have to review the code to guarantee that all the threads are created using the same factory.