Demonstration of Multi threading

This is just a code snippet which depicts how a multi-threaded application works.

There is N number of files; we need to perform same action on all the files. This code depicts how multiple files are read on simultaneous threads, processing and writing it to new files

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.List;


public class FileProcessorThread implements Runnable {

  /** The constant DONE. */
 private static final String CONSTANT_DONE = "DONE".trim();

  /** The file details list. */
 private List<FileDeatils> fileDeatilsList;

 /**
  * The constructor for the thread.
  * @param fileDeatilsList
  */
 public FileProcessorThread(List<FileDeatils> fileDeatilsList) {
  super();
  this.fileDeatilsList = fileDeatilsList;
 }

 @Override
 public void run() {

  Boolean stopIndicator = false;
  FileDeatils fileToProcess;
  while (!stopIndicator) {
   fileToProcess = getUnProcessedFile(fileDeatilsList);
   if (fileToProcess != null) {
    lockFile(fileToProcess);
    readProcessWrite(fileToProcess);
   } else {
    // if nothing to process stop indicator would be set to true and Thread will come to END.
    System.out.println(Thread.currentThread().getName() + "_ Thread Stopping..");
    stopIndicator = true;
   }
  }
 }
 
 /**
  * to check processed or not.
  * @param fileDeatils
  * @return boolean
  */
 private boolean isProcessedChkViaFlg(FileDeatils fileDeatils) {

  boolean isProcessed = false;
  synchronized (fileDeatils) {
   if (fileDeatils.isProcessed()) {
    isProcessed = true;
   }
   Thread t = Thread.currentThread();
   System.out.println("Scan to verify processed record " + t.getName()
     + "  Processed " + isProcessed);
  }
  return isProcessed;
 }

 /** get unprocessed file
  * @param fileDeatilsList
  * @return
  */
 private FileDeatils getUnProcessedFile(List<FileDeatils> fileDeatilsList) {

  FileDeatils fileToProcess = null;

  for (FileDeatils fileDeatils : fileDeatilsList) {
   if (!isProcessedChkViaFlg(fileDeatils)) {
    fileToProcess = fileDeatils;
    break;
   }
  }
  return fileToProcess;
 }

 /**
  * Lock the file by putting a DONE at the end of the file.
  * @param fileDeatils
  */
 public void lockFile(FileDeatils fileDeatils) {

  try {
   synchronized (fileDeatils) {
    if (!fileDeatils.isProcessed()) {
     Writer inPutFileWriter = new BufferedWriter(new FileWriter(
       fileDeatils.getInputFileName(), true));
     inPutFileWriter.append(CONSTANT_DONE+"_"+Thread.currentThread().getName());
     fileDeatils.setProcessed(true);
     inPutFileWriter.close();
    }
   }
  } catch (IOException e) {
   e.printStackTrace();
  } 
 }
 
 /**
  * Read the file and process.
  * @param fileDeatils
  * @return
  */
 public boolean readProcessWrite(FileDeatils fileDeatils) {

  boolean processed = true;
  File inputFile = new File(fileDeatils.getInputFileName());
  File outPutFile = new File(fileDeatils.getOutPutFileName());

  Writer output = null;
  BufferedReader input = null;
  try {
   output = new BufferedWriter(new FileWriter(outPutFile));
   input = new BufferedReader(new FileReader(inputFile));

   String line = null;
   while ((line = input.readLine()) != null) {
    if (line.contains("X")) {
     //Thread t = Thread.currentThread();
     //System.out.println(t.getName()+"_"+line);
     line = line.replace("X", "XXXXXXXXXXXXXX");
    }
    output.write(line);
    output.write("n");
   }
  } catch (IOException e) {
   e.printStackTrace();
   processed = false;
  } finally {
   try {
    output.close();
    input.close();
   } catch (IOException e) {
    e.printStackTrace();
    processed = false;
   }
  }
  return processed;
 }
}




import java.util.List;


public class ControllerThread implements Runnable{

 /** The file details list. */
 private List<FileDeatils> fileDeatilsList;
 
 /** To name the new thread. */
 private int count = 0;
 
 /** All files are processed or not. */
 private boolean isProcessCompleted = false;
 /**
  * The Constructor.
  * @param fileDeatilsList
  */
 public ControllerThread(List<FileDeatils> fileDeatilsList) {
  super();
  this.fileDeatilsList = fileDeatilsList;
 }


 @Override
 public void run() {

  while (!isProcessCompleted) {

   isProcessCompleted = isProcessingCompleted();
   /* Allow thread to sleep for 1.2 seconds */
   if (!isProcessCompleted) {
    try {
     Thread.sleep(1250);
    } catch (InterruptedException e) {
     e.printStackTrace();
    }

    if (noOfProcessedFiles() < 20) {
     System.out.println("File processed is less than 20 so starting one more thread");
     StringBuilder threadName = new StringBuilder();
     threadName.append("File Copy Adhoc_ThreadIndex:");
     threadName.append(count++);
     ThreadGroup threadGroup = new ThreadGroup("MultipleFileProcessingThread");
     FileProcessorThread fileProcessorThread = new FileProcessorThread(fileDeatilsList);
     Thread thread = new Thread(threadGroup, fileProcessorThread, threadName.toString());
     thread.start();
    }
   } else {
    System.out.println("Stopping Controller Thread !!! ...");
   }
  }
 }
 
 /**
  * to find the processing completed.
  * @return
  */
 private boolean isProcessingCompleted() {
  boolean isCompleted = true;
  synchronized (fileDeatilsList) {
   for (FileDeatils fileDeatils : fileDeatilsList) {
    if (!fileDeatils.isProcessed()) {
     isCompleted = false;
     break;
    }
   }
  }
  return isCompleted;
 }
 
 /**
  * to find the processing completed.
  * @return
  */
 private int noOfProcessedFiles() {
  int completedListCount = 0;
  synchronized (fileDeatilsList) {
   for (FileDeatils fileDeatils : fileDeatilsList) {
    if (fileDeatils.isProcessed()) {
     completedListCount++;
    }
   }
  }
  return completedListCount;
 }
}





public class FileDeatils {
 private String inputFileName;
 private String outPutFileName;
 private boolean processed;
 
 public String getInputFileName() {
  return inputFileName;
 }
 public void setInputFileName(String inputFileName) {
  this.inputFileName = inputFileName;
 }
 public String getOutPutFileName() {
  return outPutFileName;
 }
 public void setOutPutFileName(String outPutFileName) {
  this.outPutFileName = outPutFileName;
 }
 public boolean isProcessed() {
  return processed;
 }
 public void setProcessed(boolean processed) {
  this.processed = processed;
 }
}


/* the initiator which kiks of the action */ 


import java.util.List;


public class Initiator {

 /**
  * To initiate the action.
  * @param noOfConcurrentOperations
  * @param fileDeatilsList
  */
 public void initiate(int noOfConcurrentOperations, List<FileDeatils> fileDeatilsList) {

  for (int i = 1; i < noOfConcurrentOperations; i++) {
   StringBuilder threadName = new StringBuilder();
   threadName.append("File Copy_ThreadIndex:");
   threadName.append(i);
   ThreadGroup threadGroup = new ThreadGroup("MultipleFileProcessingThread");

   FileProcessorThread fileProcessorThread = new FileProcessorThread(fileDeatilsList);
   Thread thread = new Thread(threadGroup, fileProcessorThread, threadName.toString());
   thread.start();
  }
  
  ControllerThread controllerThread = new ControllerThread(fileDeatilsList);
  StringBuilder threadName = new StringBuilder();
  threadName.append("File Copy Control Thread_ThreadIndex ");
  ThreadGroup threadGroup = new ThreadGroup("MultipleFileProcessingThread");
  Thread thread = new Thread(threadGroup, controllerThread,
    threadName.toString());
  thread.start();

 }

}


import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;


public class Init {

 public static void main(String[] args) {
  System.out.println("Started.. creating input file to test");
  Init i = new Init();
  List<FileDeatils> fileDeatilsList = null;
  try {
   fileDeatilsList = i.createInputOutPut();
  } catch (IOException e) {
   e.printStackTrace();
  }
  writeToFile(fileDeatilsList);
  new Initiator().initiate(2, fileDeatilsList);
 }
 
 /**
  * just to create some data for testing, create 22 input files to c:InputTest Folder 
  * @return
  * @throws IOException
  */
 private List<FileDeatils> createInputOutPut() throws IOException {

  List<FileDeatils> fileDeatilsList = new ArrayList<FileDeatils>();
  int noOfInputFiles = 23;

  for (int i = 1; i < noOfInputFiles; i++) {
   FileDeatils fileDeatils = new FileDeatils();
   String inputFileName = "C:\InputTest\Input\INPUT" + i + ".txt";
   String outPutFileName = "C:\InputTest\Output\OUTPUT_" + i + ".txt";
   fileDeatils.setInputFileName(inputFileName);
   fileDeatils.setOutPutFileName(outPutFileName);
   fileDeatilsList.add(fileDeatils);

  }
  return fileDeatilsList;
 }
 
 
 /**
  * this writes some data to the test input file.
  * 
  * @param fileDeatilsList
  */
 public static void writeToFile(List<FileDeatils> fileDeatilsList) {
  String INPUT_STRING = "INPUT";
  int fileCount = 1;
  for (FileDeatils fileDeatils : fileDeatilsList) {
   File inputFile = new File(fileDeatils.getInputFileName());
   Writer output = null;
   int count = 1;
   try {
    output = new BufferedWriter(new FileWriter(inputFile));
    while (true) {
     output.write(INPUT_STRING + "_" + fileCount + "_X");
     output.write("n");
     count++;
     if ((count + (int) new Random().nextInt(5000)) > 1000000) {
      break;
     }
    }
    output.close();
    fileCount++;
   } catch (IOException e) {
    e.printStackTrace();
   }
  }
 }

}

[ Read More ]

Program for multithreaded file reading

import java.io.*;
import java.lang.*;
class MultiThreadedFileRead extends Thread
{
        InputStream in;
        MultiThreadedFileRead(String fname) throws Exception
        {
                in=new FileInputStream(fname);
                this.start();
        }
        public void run()
        {
                int i=0;
                while(i!=-1)
                {
                        try
                        {
                                i=in.read();
                                System.out.print((char)i);
                        }catch(Exception e){}
                }
                try
                {
                        in.close();
                }catch(Exception e){}
        }
        public static void main(String a[]) throws Exception
        {
                int n=2;
                System.out.print("Enter the number of files : ");
                BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
                try
                {
                        n=Integer.parseInt(br.readLine());
                }catch(Exception e){}
                MultiThreadedFileRead fr[]=new MultiThreadedFileRead[n];
                long tim;
                tim=System.currentTimeMillis();
                for(int i=0;i<n;i++)
                        fr[i]=new MultiThreadedFileRead(a[i]);
                for(int i=0;i<n;i++)
                {
                        try
                        {
                                fr[i].join();
                        }catch(Exception e){}
                }
                System.out.println("Time Required : "+(System.currentTimeMillis()-tim)+" miliseconds.");
        }
}

[ Read More ]

Suspending and Resuming a Thread

Here is a Java Program to Suspending and resuming a thread

class NewThread implements Runnable {
  String name; // name of thread
  Thread t;
  boolean suspendFlag;
  
  NewThread(String threadname) {
    name = threadname;
    t = new Thread(this, name);
    System.out.println("New thread: " + t);
    suspendFlag = false;
    t.start(); // Start the thread
  }

  // This is the entry point for thread.
  public void run() {
    try {
      for(int i = 15; i > 0; i--) {
        System.out.println(name + ": " + i);
        Thread.sleep(200);
        synchronized(this) {
          while(suspendFlag) {
            wait();
          }
        }
      }
    } catch (InterruptedException e) {
      System.out.println(name + " interrupted.");
    }
    System.out.println(name + " exiting.");
  }

  void mysuspend() {
    suspendFlag = true;
  }

  synchronized void myresume() {
    suspendFlag = false;
    notify();
  }
}

class SuspendResume {
  public static void main(String args[]) {
    NewThread ob1 = new NewThread("One");
    NewThread ob2 = new NewThread("Two");

    try {
      Thread.sleep(1000);
      ob1.mysuspend();
      System.out.println("Suspending thread One");
      Thread.sleep(1000);
      ob1.myresume();
      System.out.println("Resuming thread One");
      ob2.mysuspend();
      System.out.println("Suspending thread Two");
      Thread.sleep(1000);
      ob2.myresume();
      System.out.println("Resuming thread Two");
    } catch (InterruptedException e) {
      System.out.println("Main thread Interrupted");
    }

    // wait for threads to finish
    try {
      System.out.println("Waiting for threads to finish.");
      ob1.t.join();
      ob2.t.join();
    } catch (InterruptedException e) {
      System.out.println("Main thread Interrupted");
    }
 
    System.out.println("Main thread exiting.");
  }
}

Output of Above Java Program
New thread: Thread[One,5,main]
New thread: Thread[Two,5,main]
One: 15
Two: 15
Two: 14
One: 14
One: 13
Two: 13
Two: 12
One: 12
One: 11
Two: 11
One: 10
Two: 10
Suspending thread One
Two: 9
Two: 8
Two: 7
Two: 6
Resuming thread One
One: 9
Suspending thread Two
One: 8
One: 7
One: 6
One: 5
Two: 5
Resuming thread Two
One: 4
Waiting for threads to finish.
Two: 4
One: 3
One: 2
Two: 3
One: 1
Two: 2
Two: 1
One exiting.
Two exiting.
Main thread exiting.

[ Read More ]

Applying MultiThreading using Synchronization

Here is a Java Program to Applying MultiThreading using Synchronization.

class Callme {
  void call(String msg) {
    System.out.print("[" + msg);
    try {
      Thread.sleep(1000);
    } catch (InterruptedException e) {
      System.out.println("Interrupted");
    }
    System.out.println("]");
  }
}

class Caller implements Runnable {
  String msg;
  Callme target;
  Thread t;

  public Caller(Callme targ, String s) {
    target = targ;
    msg = s;
    t = new Thread(this);
    t.start();
  }

  // synchronize calls to call()
  public void run() {
    synchronized(target) { // synchronized block
      target.call(msg);
    }
  }
}

class Synch1 {
  public static void main(String args[]) {
    Callme target = new Callme();
    Caller ob1 = new Caller(target, "Hello");
    Caller ob2 = new Caller(target, "Synchronized");
    Caller ob3 = new Caller(target, "World");

    // wait for threads to end
    try {
      ob1.t.join();
      ob2.t.join();
      ob3.t.join();
    } catch(InterruptedException e) {
      System.out.println("Interrupted");
    }
  }
}

Output of Above Java Program
[Hello]
[Synchronized]
[World]

[ Read More ]

Demonstrating Thread Priorities by Changing their Priority

Here is a Java Program to Demonstrating Thread Priorities.

class clicker implements Runnable {
  int click = 0;
  Thread t;
  private volatile boolean running = true;

  public clicker(int p) {
    t = new Thread(this);
    t.setPriority(p);
  }

  public void run() {
    while (running) {
      click++;
    }
  }

  public void stop() {
    running = false;
  }

  public void start() {
    t.start();
  }
}

class HiLoPri {
  public static void main(String args[]) {
    Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
    clicker hi = new clicker(Thread.NORM_PRIORITY + 2);
    clicker lo = new clicker(Thread.NORM_PRIORITY - 2);

    lo.start();
    hi.start();
    try {
      Thread.sleep(10000);
    } catch (InterruptedException e) {
        System.out.println("Main thread interrupted.");
    }

    lo.stop();
    hi.stop();

    // Wait for child threads to terminate.
    try {
      hi.t.join();
      lo.t.join();
    } catch (InterruptedException e) {
      System.out.println("InterruptedException caught");
    }

    System.out.println("Low-priority thread: " + lo.click); 
    System.out.println("High-priority thread: " + hi.click);
  }
}

Output of Above Java Program
Low-priority thread: -992923544
High-priority thread: -320333802

[ Read More ]

Create multiple threads by Implementing Runnable Interface

Here is a Java Program to Create multiple threads

class NewThread implements Runnable {
  String name; // name of thread
  Thread t;

  NewThread(String threadname) {
    name = threadname;
    t = new Thread(this, name);
    System.out.println("New thread: " + t);
    t.start(); // Start the thread
  }

  // This is the entry point for thread.
  public void run() {
    try {
      for(int i = 5; i > 0; i--) {
        System.out.println(name + ": " + i);
        Thread.sleep(1000);
      }
    } catch (InterruptedException e) {
      System.out.println(name + "Interrupted");
    }
    System.out.println(name + " exiting.");
  }
}

class MultiThreadDemo {
  public static void main(String args[]) {
    new NewThread("One"); // start threads
    new NewThread("Two");
    new NewThread("Three");

    try {
      // wait for other threads to end
      Thread.sleep(10000);
    } catch (InterruptedException e) {
      System.out.println("Main thread Interrupted");
    }

    System.out.println("Main thread exiting.");
  }
}

Output of Above Java Program
New thread: Thread[One,5,main]
New thread: Thread[Two,5,main]
One: 5
New thread: Thread[Three,5,main]
Two: 5
Three: 5
One: 4
Two: 4
Three: 4
One: 3
Two: 3
Three: 3
One: 2
Three: 2
Two: 2
One: 1
Three: 1
Two: 1
One exiting.
Two exiting.
Three exiting.
Main thread exiting.

[ Read More ]

Demonstrate MultiThreading by Extending Thread Class

Here is a Java Program to Demonstrate the MultiThreading by Extending Thread Class

class NewThread extends Thread {

  NewThread() {
    super("Demo Thread");
    System.out.println("Child thread: " + this);
    start(); // Start the thread
  }

  public void run() {
    try {
      for(int i = 5; i > 0; i--) {
        System.out.println("Child Thread: " + i);
        Thread.sleep(500);
      }
    } catch (InterruptedException e) {
      System.out.println("Child interrupted.");
    }
    System.out.println("Exiting child thread.");
  }
}

class ExtendThread {
  public static void main(String args[]) {
    new NewThread(); // create a new thread

    try {
      for(int i = 5; i > 0; i--) {
        System.out.println("Main Thread: " + i);
        Thread.sleep(1000);
      }
    } catch (InterruptedException e) {
      System.out.println("Main thread interrupted.");
    }
    System.out.println("Main thread exiting.");
  }
}

Output of Above Java Program
Current thread: Thread[main,5,main]
After name change: Thread[My Thread,5,main]
5
4
3
2
1

[ Read More ]