Part 12: java.util.concurrent : SingleThreadPool Example

This article will discuss about Thread pool that uses single thread to execute tasks. From Java 5.0+ one can get such pool from Executors using following method –

public static ExecutorService newSingleThreadExecutor()

    Creates an Executor that uses a single worker thread operating off an unbounded queue. (Note however that if this single thread terminates due to a failure during execution prior to shutdown, a new one will take its place if needed to execute subsequent tasks.) Tasks are guaranteed to execute sequentially, and no more than one task will be active at any given time. Unlike the otherwise equivalent newFixedThreadPool(1) the returned executor is guaranteed not to be reconfigurable to use additional threads.

Example-

Suppose we have 100 properties files in an application. We have one thread that can read properties file and return a map value.

Pseudo code – READER THREAD

Config Reader implements Callable<Map<String, String>

try{

    // Get the file name in the constructor of thread

    // Check if File exists

    // Read the file and retrun the map object

}catch(Exception e){

        //release all the resource

        //return null

}

Main THREAD-

        // Get a Single thread pool from Executors

 try{

    // Get the list of all properties file in the directory

    // Create a READER THREAD by passing the name of file

    // store the READER thread in the a list

    //release all the thread in one go and get the Map objects

}catch(Exception e){

                //release all the resources

                // print the stack trace

}finally{

        //shutdown the thread pool

}

package com.jovialjava.blog.threads;

import java.io.File;
import java.io.FileInputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;


class SingleReader implements Callable  <  Properties  > {
   
  private String name = null; 
  public SingleReader(String name){
   this.name = name;  
  } 
  public Properties call(){
   try{
    File f = new File(name); 
    Properties prop = new Properties();
          if(f.exists() && f.canRead() && f.isFile()){
           FileInputStream in = new FileInputStream(f);         
           prop.load(in);          
           return prop;
          }else{
           System.err.println("Please check about this file:["+ f.getAbsolutePath()+"]");
           return null;
          }   
   }catch(Exception e){
     e.printStackTrace();
     return null;
   }
  }
 }
public class SingleThreadPoolExample {
 public static String directory = "config";
   private static ExecutorService executorPool=null;
       
   public static void main(String...args){
    try{
     File dir = new File(directory);
     if(dir.isDirectory()){
       List < Callable < Properties >  >  fileList = new ArrayList < Callable < Properties >  > ();
       String[] files = dir.list();
       /**
        * Optimization - Single thread executor.
        */
       executorPool = Executors.newSingleThreadExecutor();
       
      for(String file : files){
        Callable < Properties >  reader = new SingleReader(dir.getAbsolutePath()+ File.separator+ file);
        fileList.add(reader);      
      }
      List < Future < Properties >  >  results = executorPool.invokeAll(fileList);
      /**
       * Check how many success and how many failure
       */
      int success =0, failure = 0;
      for(Future < Properties >  result : results){
       if(result.get() == null){
        failure++;
       }else{
        success++;
       }
      }
      System.out.println("Total number of files ["+ fileList.size()+"]");
      System.out.println("Success Count ["+ success+"]");
      System.out.println("Failure Count ["+ failure+"]");
     }else{
       throw new IllegalArgumentException("There is no such directory name -"+ directory);
     }
    }catch(Exception e){
      e.printStackTrace();
    }finally{
     if(executorPool!=null){
       executorPool.shutdown();
     }
     }
   }

}