Jovial Java

Part 2: Apache Velocity - Setting up the classpath

2011-10-08T21:28:00.000-07:00

In this article we will learn to set up the class path for Apache velocity. This will help us to understand the code example in the upcoming articles. Basically Apache velocity comes into various flavors but we will cover only velocity engine. Only 2 external jars are required to set up the required class path. These jars are 

1) velocity-1.6.2.jar 

2) velocity-1.6.2-dep.jar

You can download the latest jar from this location-

http: //velocity.apache.org/download.cgi 

Setting up the class path   

(Assuming that one is setting class path in Eclipse)

Step 1:

Make a new folder name "classpath" under your project node.

Copy the jars in the folder.

Step 2:

Add the jar files in your class path.

That's all. We are ready to experience some coding example.

Part 1- Apache Velocity - ( Introduction )

2011-10-08T05:38:00.000-07:00

 Introduction

In simple terms – Apache velocity is open source software that can be used to generate dynamic content for email, sms etc. For example –One wants to write an application which will send the “password” or “account activation link”.  Normally the content of such email is fixed only certain sections such as “Password value”, “Salvation – Mr. or Ms.” change for each email. Using apache velocity, one can use a normal text file, to define the fixed content, and dynamic data, password value, to generate the email content. The Integration of text file and dynamic data is quite fast. On top of that one can define rules within the text file.  So overall one can code with in a text file. 

Example of template – 

Hi  $data.get(“UserName”) 

Your password is $data.get(“password”) 

Thanks, 

Jovialjava team
 

This is the text from Wiki-
Apache Velocity (formerly known as Jakarta Velocity) is an open source software project directed by the Apache Software Foundation. Velocity is a Java-based template engine that provides a simple yet powerful template language to reference objects defined in Java code. Its aim is to ensure clean separation between the presentation tier and business tiers in a Web application (the model–view–controller design pattern).

Part 13: java.util.concurrent - Atomic Variables

2011-01-31T07:41:00.000-08:00

In this article we will look into Atomic Variables which can help us to write lock free and wait free algorithms which were not possible prior to Java 5.0.

Two main points about Atomic Variables are

1. Help to write lock free and wait free algorithm –

Under high contention ( lots of thread are fighting for lock ), JVM spends more time with scheduling of threads, managing contention, queues of waiting threads and less time in doing the real work.

This dramatically reduces the throughput of the process.

Problem with locking:

1) Thread in block state cannot do anything else.

2) If the blocked thread is high priority, then its a big disaster.

3) Can cause Dead lock

4) Managing a Block thread is a heavy weight process, so throughput decreases.

Soon we will see how can we write lock free algorithms using atomic variables

2. Implement very light weight process like CAS –

CAS (compares and swap):

Let’s take an example to understand the concept of CAS. Suppose we have once variable “i” and we are doing some calculation over “I” and storing the result back into “i”. In a nutshell-

i = someComplicateComputation( i )

for “i” = 1,

someComplicatedComputation(i) è 1234

In CAS Process following happens-

A memory location V will be defined.

A local variable A will be defined.

A local variable B will be defined.

V will hold the initial value of “i”. So

V = i =1

A = V = 1

B = result of that computation = 1234

compare ( V , A )

both values are same --> replace V with B's value.

else

this means in the mean while someone has changed the value of V, so repeat the whole process again. Lets someone changes the value of “i”, hence V to 2.

V = 2;

A = V = 2

B = result = 3246;

compare ( V , A )

and so on...!!

This is very light weight process. This CAS technique is implemented by atomic package classes.

Example – Lets write a simple program which first increase the number by 1, then decrease the number by 1, and then increase again by 1. So overall effect is increase the number by 1. Lets run 4 threads concurrently access the method and compare the performance of AtomicInteger Vs Integer.

package com.jovialjava.blog.threads;

import java.util.concurrent.atomic.*;

public class AtomicVariableExample implements Runnable {
 AtomicInteger atomic_int_1 = new AtomicInteger();
 AtomicInteger atomic_int_2 = new AtomicInteger();
 int int_1;
 int int_2;
 private static int count = 0;

 
 public static void main(String[] args) {
  AtomicVariableExample pr = new AtomicVariableExample();
  new Thread(pr).start();// 1 0 1
  new Thread(pr).start();// 2 1 2
  new Thread(pr).start(); // 3 2 3
  new Thread(pr).start(); // 4 3 4
  while (true) {
   if (count == 4) {
    System.out.println(pr.atomic_int_1.get());
    System.out.println(pr.int_1);
    break;
   }
  }

 }

 public void run() {
  System.out.println("Inside run method...");
  doCalc();

 }

 private void doCalc() {
  try {
   atomic_int_2 = atomic_int_1;
   int_2 = int_1;
   atomic_int_2.incrementAndGet();
   int_2 = int_2 + 1;
   Thread.sleep(1000);
   atomic_int_2.decrementAndGet();
   int_2 = int_2-1;
   Thread.sleep(1000);
   atomic_int_2.incrementAndGet();
   int_2 = int_2 + 1;
   Thread.sleep(1000);
   atomic_int_1 = atomic_int_2;
   int_1 = int_2;
   synchronized (this) {
    count++;
   }
  } catch (InterruptedException e) {   
   e.printStackTrace();
  }
 }

}

Part 12: java.util.concurrent : SingleThreadPool Example

2011-01-28T22:31:00.000-08:00

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();
     }
     }
   }

}

Part 11: java.util.concurrent - CachedThreadPool Example

2011-01-28T21:15:00.000-08:00

This article will discuss about Thread pool that can reuse previously constructed threads when they are available. From Java 5.0+ one can get such pool from Executors using following method –

public static ExecutorService newCachedThreadPool()

Creates a thread pool that creates new threads as needed, but will reuse previously constructed threads when they are available. These pools will typically improve the performance of programs that execute many short-lived asynchronous tasks. Calls to execute will reuse previously constructed threads if available. If no existing thread is available, a new thread will be created and added to the pool. Threads that have not been used for sixty seconds are terminated and removed from the cache. Thus, a pool that remains idle for long enough will not consume any resources. Note that pools with similar properties but different details (for example, timeout parameters) may be created using ThreadPoolExecutor constructors.

Example-

Suppose we have 100 properties files in an application. We have one thread that can read properties file and return a map value. We want to optimize the time to read all 100 properties file by using concurrent reading. Here optimize means – we need a perfect balance between CPU Utilization and total time consumed by reading process.

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 Cached 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 CachedReader implements Callable  <  Properties  > {
   
  private String name = null; 
  public CachedReader(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 CachedThreadPoolExample {
 public static String directory = "config";
   private static ExecutorService executorPool=null;
   private static int MAX_THREADS = 20;
    
   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 - Reuse the the threads.
        */
       executorPool = Executors.newCachedThreadPool();
       
      for(String file : files){
        Callable < Properties >  reader = new CachedReader(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();
     }
     }
   }
}

Part 10: java.util.concurrent - ScheduledThreadPool Example

2011-01-28T08:35:00.000-08:00

This article will discuss about Thread pool that can schedule threads to run after a specified interval of time. From Java 5.0+ one can get such pool from Executors using following method –

public static ScheduledExecutorService

newScheduledThreadPool(int corePoolSize)

Creates a thread pool that can schedule commands to run after a given delay, or to execute periodically.

The return type of this method (return type of thread pool) is ScheduledExecutorService.Some of the salient features of ScheduledExecutorService are –

Schedule a Callable or Runnable to run once with a fixed delay after submission
Schedule a Runnable to run periodically at a fixed rate
Schedule a Runnable to run periodically with a fixed delay between executions
Submission returns a ScheduledFutureTask handle which can be used to cancel the task
.Like Timer, but supports pooling

Example:

Suppose we are building a Bank check processing system. Here is the process –
Every local branch collect cheques and create a txt file contain cheque info.
A service runs which copy the cheque txt file from local branch to main server.
A Local service runs on server which check if any file has received and notify the cheque Clearing process.

We will try to make “Local Service”, which check the file reception and “Copying process” Which copy file from client machine to Server.

Pseudo Code-

//Define Local & Copying service running interval time in Seconds

//Make an ScheduledThreadPool with pool size 2

try{

// Make Local Service thread

// Make Copying process thread

// Scheduled Both thread to run at regular interval

}catch(Exception e){

//release all resources

}

LocalService Thread-

Try{

//Check if directory exists

//Check if any file exists in directory

//return status

}catch(Exception e){

//Print necessary exception

}

Copying Process Thread-

Try{

// Check if File existin on remote server

// Copy the file to main server

}catch(Exception e){

//Print necessary exception

}

package com.jovialjava.blog.threads;

import java.io.File;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;


//LOCAL SERVICE THREAD
class LocalService implements Runnable{
 
 private String DIRECTORY = null;
 
 public LocalService(String DIRECTORY){
  this.DIRECTORY = DIRECTORY;  
 } 
 public void run(){
  try{
   File dir = new File(this.DIRECTORY);
   if(dir.isDirectory()){
    if(dir.list().length > 0){
     System.out.println("FILE EXISTS");
    }
   }else{
    System.err.println("NO SUCH DIRECTORY ["+dir.getAbsolutePath()+"] exists");    
   }      
  }catch(Exception e){
   e.printStackTrace();
  }
 }
}

//COPYING SERVICE THREAD
class CopyService implements Runnable{
 
 private String REMOTE_DIR = null;
 private String LOCAL_DIR = null;
 
 public CopyService(String remoteDir, String localDir){
  this.REMOTE_DIR = remoteDir;
  this.LOCAL_DIR = localDir;
 } 
 public void run(){
  try{
   File remote = new File(this.REMOTE_DIR);
   File local = new File(this.LOCAL_DIR);
   if(remote.isDirectory() && local.isDirectory()){
    if(remote.list().length > 0){
     System.out.println("REMOTE FILE FOUND, COPYING");
     //--- Call the file copying method.     
    }else{
     System.out.println("NO REMOTE FILE FOUND");     
    }    
   }else{
    System.err.println("PLEASE CHECK DIRECTORY ["+remote.getAbsolutePath()+" OR/AND"
      +local.getAbsolutePath()+"] existence");    
   }
  }catch(Exception e){
   e.printStackTrace();
  }
 }
}

public class ScheduledExample {

 private static final ScheduledExecutorService executor = Executors.newScheduledThreadPool(2);
 private static final int LOCAL_INTERVAL = 5, COPY_INTERVAL= 2;
 private static final String REMOTE_DIR="REMOTE", LOCAL_DIR= "LOCAL";
 
 public static void main(String... args){
  Runnable localService = new LocalService(LOCAL_DIR);
  Runnable remoteService = new CopyService(REMOTE_DIR, LOCAL_DIR);
  try{
   executor.scheduleWithFixedDelay(localService, 0, LOCAL_INTERVAL, TimeUnit.SECONDS);
   executor.scheduleWithFixedDelay(remoteService,0, COPY_INTERVAL, TimeUnit.SECONDS);   
  }catch(Exception e){
   e.printStackTrace();
  }
 } 
}

Part 9: java.util.concurrent : FixedThreadPool Example

2011-01-27T07:38:00.000-08:00

This article will discuss about Thread pool with fixed number of thread. From Java 5.0+ one can get such pool from Executors using following method –

public static ExecutorService

newFixedThreadPool(int nThreads)

Creates a thread pool that reuses a fixed number of threads operating off a shared unbounded queue. At any point, at most nThreads threads will be active processing tasks. If additional tasks are submitted when all threads are active, they will wait in the queue until a thread is available. If any thread terminates due to a failure during execution prior to shutdown, a new one will take its place if needed to execute subsequent tasks. The threads in the pool will exist until it is explicitly shutdown.

Example-

Suppose we have 100 properties files in an application. We have one thread that can read properties file and return a map value. We want to optimize the time to read all 10 properties file by using concurrent reading. Here optimize means – we need a perfect balance between CPU Utilization and total time consumed by reading process.

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 fixed 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 Reader implements Callable  <  Properties  > {
 
 private String name = null; 
 public Reader(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 FixedThreadPoolExample {
  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 - just 20% of number of files.
      */
     executorPool = Executors.newFixedThreadPool(files.length/5);
     
     for(String file : files){
      Callable < Properties >  reader = new Reader(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();
    }
   }
  } 
}

Part 8: java.util.concurrent - "Executors" Factory Threads Pool

2011-01-26T00:05:00.000-08:00

Today in this article we will see some of threads pool available in “Executors” Factory -

public static ExecutorService

newFixedThreadPool(int nThreads)

public static ScheduledExecutorService

newScheduledThreadPool(int corePoolSize)

Creates a thread pool that can schedule commands to run after a given delay, or to execute periodically.

public static ExecutorService newCachedThreadPool()

public static ExecutorService newSingleThreadExecutor()

Part 7: java.util.concurrent - invokeAll via ExecutorService

2011-01-25T00:07:00.000-08:00

Submit Collection of Threads via ExecutorService

Today in next part of the series we will talk about How we can release multiple threads via Executor Interface.

As per JAVA 6.0 docs –

<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException

In traditional Java – If we have to release multiple threads- we have to create Thread objects and call

Start method one by one.

In Java 5.0 and above – If we can put all callable objects in a collection object and pass the collection objects to ExecutorService to release.

For example – If we have 1000 thread object to be released, we can create an array list and an ExecutorService object with thread pool size of 20.

// create an ExecutorService object with thread pool size = 20

// create an array List with 1000 callable objects.

// Release all threads by ExecutorService.

Some important points to note here are

Ø As ExecutorService has thread pool of 20, it will internally manage queuing and releasing of 1000 threads.
Ø invokeAll is a blocking method. It means – JVM won’t proceed to next line until all the 1000 threads are complete.
Ø All the 1000 threads must have same Return Type < T >.
Ø Future.isDone() is true for each element of the returned list
Ø A completed thread could have terminated either normally or by throwing an exception. In both the case return type of Future.isDone( ) is true.
Ø The results of this method are undefined if the given collection is modified while this operation is in progress
Ø It can throw following exceptions –
InterruptedException - if interrupted while waiting, in which case unfinished tasks are cancelled.
NullPointerException - if tasks or any of its elements are null.
RejectedExecutionException - if any task cannot be scheduled for execution.

EXAMPLE –

Imagine a scenario, one needs to write create a txn file of each request coming to system. Following are the requirements-

Ø File name will be the client name.
Ø At a time, almost 1000 clients could be connected at a time, so system must be capable of creating 1000 files in one go.
Ø Process of creating one file should be less than 5 ms.
Ø Total time of creating all the files should be less than 300 ms.

Let’s write the pseudo code for this case –

File creation Thread – implements CALLABLE<Boolean>

// GET the File name and Raw Data in Constructor

Try{

// Create a File Object

// Create a print Writer Object

// Prepare the data and Write in the File

// Close the print Writer and File Object

// Return TRUE

} catch Exception {

return FALSE

}

Main Parent Thread

// -- In the Loop for whole Client list ---
try{

// create a file creator thread – Pass filename and raw Data

// add the thread object into an Array List

// Pass the array list to Executor Service interface and invokeAll.

// Loop in the Future<Boolean> and check how many threads completed successfully.

}catch Exception{

// Take necessary action

}finally{

// Shut down the ExecutorService
}

package com.jovialjava.blog.threads;

import java.io.File;
import java.io.PrintWriter;
import java.util.*;
import java.util.concurrent.*;


// FILE CREATOR THREAD
class FileTask implements Callable< Boolean >{
 
 private String name = null;
 private String data = null;
 public FileTask(String name, String data){
  this.name = name;
  this.data = data;
 }
 
 public Boolean call(){
  try{
   File file = new File(this.name);
   PrintWriter writer = new PrintWriter(file);
   writer.write(this.data);
   writer.close();
   return true;   
  }catch(Exception e){
   return false;
  }
 }
}

// MAIN THREAD
public class InvokeAllExample {
 
 private static final ExecutorService executorPool=Executors.newFixedThreadPool(20);
 private static final int NO_OF_CLIENT = 1000;
 private static final String FILE_EXT = ".txt";
 private static String TXN_DATA = "SOME RANDOM TXN DATA FOR CLIENT --> ";
 private static String DIRECTORY = "EXAMPLE" + File.separator;
 
 static{
  if(!new File(DIRECTORY).isDirectory()){
   new File(DIRECTORY).mkdir();
  }
 }
 
 public static void main(String[] args) {
  int success = 0;
  int failure = 0;
  /**
   * Lets assume we have 1000 clients connected and sending request at a time.
   */
  Collection collection = new ArrayList( );
  for(int i=0; i< NO_OF_CLIENT; i++){
   FileTask task = new FileTask(DIRECTORY+ Integer.toString(i)+ FILE_EXT, TXN_DATA+ i);
   collection.add(task);
  }
  long startTime = new Date().getTime();
  try {   
   List< Future< Boolean > > list = executorPool.invokeAll(collection);   
    for(Future< Boolean > fut : list){
     int ignore = fut.get()? success++ : failure++;
    }
   
   } catch (Exception e) {
     e.printStackTrace();
   }finally{
     System.out.println("TOTAL SUCCESS - "+ success);
     System.out.println("TOTAL FAILURE - "+ failure);
     System.out.println("Total time - " + (new Date().getTime() - startTime) + " ms");
     executorPool.shutdown();
   }
 } // End of Main

}

Part 6: java.util.concurrent - Lock and Condition Object

2011-01-22T10:21:00.000-08:00

Today in next part of the series we will talk about How to communicate among threads using Lock and Condition Objects.

In traditional Java - If we need to communicate among threads, we syncronize code and use "wait" and "notify" methods of Object class.
From Java 5.0 and above - Lock interface provides an easier implmentation for synchronization and Condition class can be used to wait and notify threads.

Lock has several important methods such as "lock", "tryLock", "lockInterruptibly" etc, whereas Condition has "await", "signal", 'signalAll" etc. In this article we will demonstrate the usage of 3 methods - "lock" (from Lock interface), "await", "signal" (from Condition Class).

Lets try to visualize a scenario here - Assume we have 2 process "Reader" and "Writer". Writer writes on a file and Reader reads from a file. we want to add a listener to writer object so that whenever writer writes anything on a file, "Reader" will be called and it will read the same data. Before we look into codes lets look at the some important points to use Lock and Condition-

1) Lock is an Interface, the most common implementation class is ReentrantLock. Others two are - ReentrantReadWriteLock.ReadLock, ReentrantReadWriteLock.WriteLock
2) Condition Object is always retrieved from Lock object. For example - Condition condition = lock.newCondition( );
3) One of the best practice to use Lock is-

Lock lockObj = new ReentrantLock( );

lockObj.lock( );

try{

.... code..

}finally{

lockObj.unlock( );

}

4) condition.await, condition.signal, condition.signalAll methods should only be called once you have acquired the lock by - lockObj.lock( ).
In our example, the design of the class will be something like this -
> One lock Object == fileLock
> One condition Object = condition = fileLock.newCondition

Pseudo code for Writer Thread

// GET the LOCK
try{
  // -- In the Loop untill EXIT---
   //Write on the file
   // Signal the READER
   //If EXIT signal then exit else "WAIT for READER to SIGNAL"
}finally{
  // RELEASE the LOCK
}

pseudo code for Reader Thread

// GET the LOCK
try{
  // -- In the Loop untill EXIT---
   //Read from the file
   // Signal the WRITER
   // If EXIT signal - then exit else "WAIT for WRITER to SIGNAL"
}finally{
  // RELEASE the LOCK
}

package com.jovialjava.blog.threads;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.PrintWriter;
import java.security.SecureRandom;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockExample {
 
 private static final String fileName = "LockExample.txt";
 private static final String EXIT_FLAG = "BYE";
 private static final int NO_OF_LINES = 10;
 private static final Lock fileLock = new ReentrantLock();
 private static final Condition condition = fileLock.newCondition();
 private static final ExecutorService executorPool=Executors.newFixedThreadPool(2);
 
 public static void main(String...args){  
  Runnable fileWriter = new FileWrite();
  Runnable fileReader = new FileRead();  
  executorPool.submit(fileReader);
  executorPool.submit(fileWriter); 
  executorPool.shutdown();
 }
 
 /**
  * This thread will write on a file and inform the reader thread to
  * read it. If it has not written the EXIT flag then it will go into 
  * wait stage and will wait for READER to signal that it safe to write
  * now. 
  */
 public static class FileWrite implements Runnable{
  
  public void run( ){   
   try{
    fileLock.lock();
   for(int i=0; i< NO_OF_LINES; i++){    
    PrintWriter writer = new PrintWriter(new File(fileName));    
    if(i != NO_OF_LINES - 1){
     int random = new SecureRandom().nextInt();
     System.out.println("WRITER WRITING " + random);
     writer.println(random);
     writer.close();
     //signallng to READER that its safe to read now.
     condition.signal();
     System.out.println("Writer waiting");
     condition.await();
    }else{
     writer.println(EXIT_FLAG);
     System.out.println("WRITER EXITING ");
     writer.close();
     //AS it was an exit flag so no need to wait, just signal the reader.
     condition.signal();
    }   
   }   
   }catch(Exception e){
    System.out.println("!!!!!!!!!!!!!!!!!!!!!!!!EXCEPTION!!!!!!!!!!!!!!!!!!!!!!!!");
    e.printStackTrace();
   }finally{
    fileLock.unlock();
    // Delete the file, require in case if one wants to run demo again.
    File file = new File(fileName);
    file.delete();
    try{
     file.createNewFile();
    }catch(Exception e){}
   }
  }
 } 
 /**
  * This thread will read from the file and inform the writer thread to
  * write again. If it has not read the EXIT flag then it will go into 
  * wait stage and will wait for WRITER to signal that it safe to read
  * now. 
  */
 public static class FileRead implements Runnable{
    
  public void run( ){
   String data = null;   
   fileLock.lock();   
  try{   
   while(true){    
    BufferedReader reader = new BufferedReader(new FileReader(fileName));
    data = reader.readLine();
    System.out.println("READ DATA - " + data);        
    reader.close();
    if(data == null || !data.equals(EXIT_FLAG)){
     condition.signalAll();
     System.out.println("Reader Waiting");
     condition.await();
    }else{
     System.out.println("READER EXITING");
     condition.signal();
     break;
    }    
   }
   }catch(Exception e){
    System.out.println("!!!!!!!!!!!!!!!!!!!!!!!!EXCEPTION!!!!!!!!!!!!!!!!!!!!!!!!");
    e.printStackTrace();
   }finally{
    fileLock.unlock();
   }
  }
 }
}

Part 5: java.util.concurrent - Submit Callable< T > via ExecutorService

2011-01-21T19:49:00.000-08:00

Future<T> submit(Callable<T> c)

Today in next part of the series we will talk about submission of callable task via executor service.

As per JAVA version 6.0, ExecutorService Interface has following method -
Future< T > submit( callable c )

Submits a Callable task for execution and returns a Future representing that task computation.
Future< T > will return T on successful completion of the process, otherwise result will not be T.

Lets start with Callable task - As we know that Callable<T> interface has following method - public T call()
So when we say - ExecutorService.submit(Callable Task) --> It starts a new stack starting with call method of callable task, as call method can return T so does future object. Due to this reason the signature of submit(Callable c) is Future< T >.
T --> means anything that extends Object.

you can >>download<< the program from here.

/**
*Copyright (C) 2010  Jovial Java Admin [email: jovialjava.blogspot@gmail.com]
*
*This program is free software: you can redistribute it and/or modify
*it under the terms of the GNU General Public License as published by
*the Free Software Foundation, version 3 of the License.
*
*This program is distributed in the hope that it will be useful,
*but WITHOUT ANY WARRANTY; without even the implied warranty of
*MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*GNU General Public License for more details.
*
*You should have received a copy of the GNU General Public License
*along with this program.  If not, see .
*@date Jan 22, 2011
*@author JovialJava
*/
package com.jovialjava.blog.threads;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;


public class CallableExample {

 private static final ExecutorService executorPool=Executors.newFixedThreadPool(2);
 
 public static void main(String[] args) {
  CallableTask_1 task_1 = new CallableTask_1();
  CallableTask_2 task_2 = new CallableTask_2();
  
  /**
   * Submit the first task
   */
  Future fut_1 = executorPool.submit(task_1);
  Future fut_2 = executorPool.submit(task_2);
  
  try{
   if(fut_1.get()){
    System.out.println("TASK 1 completed SUCCESSFULLY");
   }
   if(fut_2.get()){
    System.out.println("TASK 2 completed SUCCESSFULLY");
   }
  }catch(ExecutionException e){   
   System.out.println(e.getMessage());
  }catch(InterruptedException e){
   System.out.println(e.getMessage());
  }finally{
   /**====VERY IMPORTANT===
    * This is required to stop the executor pool to
    * stop accepting new request.
    */
   executorPool.shutdown();
  }

 }

 
 /**
  * This task will complete successfully
  */
 public static class CallableTask_1 implements Callable{
  public Boolean call()throws NullPointerException{
   System.out.println("Hi, Inside Callable Task 1");
   return true;
  }  

 }
 
 /**
  * This task will result in error.
  */
 public static class CallableTask_2 implements Callable{
  public Boolean call()throws NullPointerException{
   System.out.println("Hi, Inside Callable Task 2");
   throw new IllegalStateException("Callable Task Exception");
  }  

 }
}

Multithreading in JAVA.

Part 4: java.util.concurrent - Submit Runnable via ExecutorService

2011-01-21T08:17:00.000-08:00

Future<?> submit( Runnable r )

Today in part 4 of the series we will talk about submission of runnable task via executor service. This method can be very beneficial if someone wants to upgrade legacy code from 1.4 to 1.5 onwards.
As per JAVA version 6.0, ExecutorService Interface has following method -

Future< ? > submit( Runnable r )

> Submits a Runnable task for execution and returns a Future representing that task.
> This method will return NULL on successful completeion of the process, otherwise result will not be null.

Lets start with Runnable task - As we know that Runnable interface has following method - public void run()
So when we say - ExecutorService.submit(Runnable Task) --> It starts a new stack starting with run method of runnable task, but as run method can not return any value so does future object. Due to this reason the signature of submit(Runnable r) is Future< ? >.
? --> means anything that extends Object, has no lower limit

/**
*Copyright (C) 2010  Jovial Java Admin [email: jovialjava.blogspot@gmail.com]
*
*This program is free software: you can redistribute it and/or modify
*it under the terms of the GNU General Public License as published by
*the Free Software Foundation, version 3 of the License.
*
*This program is distributed in the hope that it will be useful,
*but WITHOUT ANY WARRANTY; without even the implied warranty of
*MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*GNU General Public License for more details.
*
*You should have received a copy of the GNU General Public License
*along with this program.  If not, see .
*@date Jan 21, 2011
*@author JovialJava
*/
package com.jovialjava.blog.threads;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class RunnableExample {
 
 private static final ExecutorService executorPool=Executors.newFixedThreadPool(2);
 
 public static void main(String[] args) {
  RunnableTask_1 task_1 = new RunnableTask_1();
  RunnableTask_2 task_2 = new RunnableTask_2();
  
  /**
   * Submit the first task
   */
  Future< ? > fut_1 = executorPool.submit(task_1);
  Future< ? > fut_2 = executorPool.submit(task_2);
  
  try{
   if(fut_1.get() == null){
    System.out.println("TASK 1 completed SUCCESSFULLY");
     }
   if(fut_2.get() == null){
    System.out.println("TASK 2 completed SUCCESSFULLY");
     }
  }catch(ExecutionException e){   
   System.out.println(e.getMessage());
  }catch(InterruptedException e){
   System.out.println(e.getMessage());
  }finally{
   /**====VERY IMPORTANT===
    * This is required to stop the executor pool to
    * stop accepting new request.
    */
   executorPool.shutdown();
  }

 }
 /**
  * This task will complete successfully
  */
 public static class RunnableTask_1 implements Runnable{
  public void run()throws NullPointerException{
   System.out.println("Hi, Inside Runnable Task 1");   
  }  

 }
 /**
  * This task will result in error.
  */
 public static class RunnableTask_2 implements Runnable{
  public void run()throws NullPointerException{
   System.out.println("Hi, Inside Runnable Task 2");
   throw new IllegalStateException("Runnable Task Exception");
  }  

 }
}

Part 3:java.util.concurrent- ExecutorService Interface

2011-01-20T07:06:00.000-08:00

xecutorService interface provide us a base to release threads. It maintains everything related to threads.
Analogy:
This is very much similar to a small IT organization where a project manager handles all activities related to developers. Activities such as -how many person will be there in each team, if one team has less work then releasing some person from that team and shifting to another team, generate weekly report to submit to company etc.
If we see deeply -functions of ExecutorService are nothing but an exact replica of what a project manager does in a company.
We create thread task , ExecutorService helps to release a thread and give the result back to us similarly company hires a person and project manager takes out the work from that person and company gets benefited.
Threads Pool in ExecutorService Implementation:
Most of the executor implementations in java.util.concurrent use thread pools, which consist of worker threads. This kind of thread exists separately from the Runnable and Callable tasks it executes and is often used to execute multiple tasks.
Using worker threads minimizes the overhead due to thread creation. Thread objects use a significant amount of memory, and in a large-scale application, allocating and deallocating many thread objects creates a significant memory management overhead.
Analogy:
This is very much similar to big organizations in which a project manager have project leaders working under him to take care of developers. so project leaders are nothing but acting as thread POOL.
Fixed Thread POOL:
One common type of thread pool is the fixed thread pool. This type of pool always has a specified number of threads running; if a thread is somehow terminated while it is still in use, it is automatically replaced with a new thread. Tasks are submitted to the pool via an internal queue, which holds extra tasks whenever there are more active tasks than threads.
Advantage:
An important advantage of the fixed thread pool is that applications using it degrade gracefully. To understand this, consider a web server application where each HTTP request is handled by a separate thread. If the application simply creates a new thread for every new HTTP request, and the system receives more requests than it can handle immediately, the application will suddenly stop responding to all requests when the overhead of all those threads exceed the capacity of the system. With a limit on the number of the threads that can be created, the application will not be servicing HTTP requests as quickly as they come in, but it will be servicing them as quickly as the system can sustain.
Example-
Suppose there are 8 threads in the Thread Pool.
First request comes in the queue : check if there is any Thread in the pool --> Yes , execute the task.
9th request comes in : No thread in pool currently --> Hold the task in the queue( Degrading the performance) --> wait until one among the currently running 8 task finishes --> as soon as one finished, run the ninth task ( graceful work)

ExecutorServiceInterface -Important Methods

Provide submit(…) in spite of execute(…)
submit( Runnable r) --> return Future< ? >
submit( Callable<V> c) --> return Future<T>
invokeAll( Collection< ? extends Callable<T>> task ) --> List<Future<T>>
shutdownNow( ) --> List<Runnable>

Part 2: java.util.concurrent - Future <T>

2011-01-19T02:56:00.000-08:00

Future<T>:
A Future represents the result of an asynchronous computation. Future has been provide with some really powerful methods. For Instance -
1) We can check whether a task has been completed or not.
2) We can cancel a task.
3) Check whether task was cancelled or complete normally.

Methods-

boolean cancel(boolean mayInterruptIfRunning) -
This method does following -
1) If the process(Thread) has not started, then cancel the thread.
2) If the process has started, then check if
mayInterruptIfRunning = true ==> Inturrept the thread and cancel it
mayInterruptIfRunning = false ==> Let it run
This attempt will fail if the task has already completed, has already been cancelled, or could not be cancelled for some other reason.
After this method returns, subsequent calls to isDone() will always return true.
Subsequent calls to isCancelled() will always return true if this method returned true.

boolean isCancelled()
Returns true if this task was cancelled before it completed normally

V get() throws InterruptedException, ExecutionException
This method is a blocking call. It will cause JVM to wait if necessary for the computation to complete, and then retrieves its result.

boolean isDone()
Returns true if this task completed. Completion may be due to normal termination, an exception, or cancellation - in all of these cases, this method will return true.
Please >>download<< the program from here.

/**
*Copyright (C) 2010  Jovial Java Admin [email: jovialjava.blogspot@gmail.com]
*
*This program is free software: you can redistribute it and/or modify
*it under the terms of the GNU General Public License as published by
*the Free Software Foundation, version 3 of the License.
*
*This program is distributed in the hope that it will be useful,
*but WITHOUT ANY WARRANTY; without even the implied warranty of
*MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*GNU General Public License for more details.
*
*You should have received a copy of the GNU General Public License
*along with this program.  If not, see .
*@date Jan 19, 2011
*@author JovialJava
*/
package com.jovialjava.blog.threads;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class FutureExample {
 /**
  * Executor pool is a new concept in JAVA 5+, it can help to release 
  * a thread. It maintains a pool of threads, It reuses them, also align them in 
  * a queue. Here we are creating pool of 1 thread.
  */
 private static final ExecutorService executorPool=Executors.newFixedThreadPool(5);
 
 public static void main(String... args){
  CallableTask call = new CallableTask();  
  try{
   /**
    * Future is result of asynchronous computation.
    * It may possible that CallableTask has not started yet
    * but 'ExecutorService' gives the result via Future
    * Object.
    */
   Future future = executorPool.submit(call);
   /**
    * We can check if CallableTask has been completed.
    */
   System.out.println("Status of Callable Task [Is Completed ? "+ future.isDone()+ "]");
   /**
    * We can get the result of callable Task.
    * Note : future.get() is a blocking call, It will wait until the associated process finishes.
    */
   System.out.println("Result of callable task ["+ future.get()+"]");
   /**
    * We can cancel the task.
    */
   System.out.println("Trying to cancel the task [Is Cancelled ? "+ future.cancel(false)+ "]");
   /**
    * We can see if the task was canceled.
    * Returns true if this task was canceled before it completed normally
    */
   System.out.println("Was task canceled before normal complition ? -"+ future.isCancelled());
   
   
  }catch(Exception e){
   e.printStackTrace();
  }finally{
   executorPool.shutdownNow();
  }
  
 }

 
 /*
  *Callable is defined as Callable
  *
  */
 public static class CallableTask implements Callable{
    
  public String call( ){
   System.out.println("Inside CALLABLE TASK");
   return "~~JOVIAL JAVA~~";
  }
 } 
}

Part 1: java.util.concurrent - Runnable Vs Callable in Java

2011-01-17T06:57:00.000-08:00

About Runnable:

Runnable interface is implemented by the Thread class as well and it's a common protocol for all the objects who wish to execute in a different thread. It's one of the ways of creating threads in Java. The other way to create a thread is by subclassing the Thread class. A class implementing Runnable interface can simply pass itself to create a Thread instance and can run thereafter. This eliminates the need of subclassing the Thread class for the purpose of executing the code in a separate thread.

As long as we don't wish to override other methods of the Thread class, it may be a better idea to implement the Runnable interface to enable multithreading capabilities to a class than enabling the same by extending the Thread class.

About Callable:

The designers of Java felt a need of extending the capabilities of the Runnable interface, but they didn't want to affect the uses of the Runnable interface and probably that was the reason why they went for having a separate interface named Callable in Java 1.5 than changing the already existing Runnable interface which has been a part of Java since Java 1.0.

Similarities:

1) Both threads can be used to cause a separate stack for a thread. 

2) Both has only one method : Inside Runnable it is called as 

public abstract void run( );

Inside callable the method is being called as 

public abstract  call() ;

(Note : V can be any valid object in JAVA)

Differences:

1) Return Type -

public abstract void run()  --> Return type "void"

public abstract  call()  --> Return type "Any valid JAVA Object"

2) Run method can not throw any checked Exception, whereas

public abstract  call() throw checkedException

Call method can throw any checked Exception.

Note: You can also >> DOWNLOAD << the program from here.


Copyright (c) 2011 http://www.jovialjava.blogspot.com

java.util.concurrent tutorial Index

2011-01-16T00:02:00.000-08:00

CommunicationFlow.java

2011-01-03T07:08:00.000-08:00

FOR FIRST PART - CLICK HERE { PART 1 }

package com.jovialjava.example;

public class Common {
    
    public static String appendSTX_ETX_LRC(String request){
        String LRCString = calculateLRC(request + "03");
        System.out.println(LRCString);
        return "02" + request + "03" + LRCString ;
    }
    
    public static String calculateLRC(String inputString){
        /*
         * String is Hex String, need to convert in ASCII.
         */
        inputString = convertHexToString(inputString);
        int checksum = 0;
        char[] chars = inputString.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            checksum ^= chars[i];
        }    
        String val = Integer.toHexString(checksum);        
        if(val.length()< 2){
            val = "0"+ val;
        }
        
        return val;       
    }
    public static String convertHexToString(String hex){
         
          StringBuilder sb = new StringBuilder();
          StringBuilder temp = new StringBuilder();             
          //49204c6f7665204a617661 split into two characters 49, 20, 4c...
          for( int i=0; i<hex.length()-1; i+=2 ){
               //grab the hex in pairs
              String output = hex.substring(i, (i + 2));
              //convert hex to decimal
              int decimal = Integer.parseInt(output, 16);                  
                  sb.append((char)decimal);
//              }
              temp.append(decimal);
          }         
     
          return sb.toString();
      }

    public static String asciiToHex(String ascii){
        StringBuilder hex = new StringBuilder();
        
        for (int i=0; i < ascii.length(); i++) {
            hex.append(Integer.toHexString(ascii.charAt(i)));
        }       
        return hex.toString();
    } 
    
    /*
     * This method will check if LRC received is ok.
     */
    public static boolean verify(String response){
        try {
            String newResponse = Common.convertHexToString(response);
            int lrc = getLRCValue(newResponse);
            response = getLRCString(response);    
            System.out.println(response);
            return verifyLrc(response, lrc);
        } catch (Exception e) {
            System.err.println("!!!ERROR!!! -Exception while calcualting LRC");
            e.printStackTrace();
            return false;
        }
    }
    private static int getLRCValue(String response){        
        byte[] bytes = response.getBytes();
        int tmp=-1;
        boolean flag = false;        
        for(byte b : bytes){            
            if(b == 3){
                flag = true;                
                continue;
            }
            if(flag){
            tmp = b;
            break;
            }            
        }        
        return tmp; 
    }
    
    private static String getLRCString(String response) throws Exception{
        if(response.length() % 2 != 0){
            System.err.println("Response MSG doesn't have even number of chars");
            throw new IllegalArgumentException();
        }
        boolean exit = false;
        boolean start = false;
        String LRCStr = "";
        for( int i=0; i<response.length()-1; i+=2 ){
               //grab the hex in pairs
              String output = response.substring(i, (i + 2));
              if(output.equals("03")){    
                  LRCStr = LRCStr + output;
                  exit = true;
              }else if(output.equals("02")){
                  start = true;
                  continue;
              }
              
              if(!exit){
                  if(start){
                      LRCStr = LRCStr + output;
                  }
              }else{
                  break;
              }
        }
        return LRCStr;
    }
    
    private static boolean verifyLrc(String resp, int lrcVal)
    {
        if(resp == null || resp.length() == 0)
            return false;
            //int lrc_encountered = calculate1byteLRC(resp);
        int lrc_encountered = Integer.parseInt(calculateLRC(resp),16);

            if( lrcVal != lrc_encountered ) {
                System.err.println("Mismatched LRC (expected [" + lrc_encountered + "], encountered ["
                    + lrcVal + "])");
                return false;
            }else{    
                System.out.println("LRC Matched (expected [" + lrc_encountered + "], encountered ["
                    + lrcVal + "])");
                return true;
            }
        
    }
    

}

===========================================================================
Download Both Files from Here

Part 6 of 6: CommunicationFlow.java

2011-01-03T06:27:00.000-08:00

================================================================
PLEASE DOWNLOAD THE JAVA PROGRAM FROM HERE - DOWNLOAD THIS PROGRAM
================================================================

package com.jovialjava.example;

import com.jovialjava.DataOperation;
import com.jovialjava.DataResult;
import com.jovialjava.RS232Executor;
import com.jovialjava.DTO.Instruction;
import com.jovialjava.DTO.SerialConfiguration;
import com.jovialjava.exceptions.RS232Exception;

public class CommunicationFlow {    
    /*
     * We need two Objects to interact with Serial Device (D)
     */
    private Instruction instruction = null;
    private SerialConfiguration config = null;
    private RS232Executor executor = null;    
    /*
     * This is required to collect response from Serial Device
     */
    private String response = new String("");
    /*
     * Universal Values
     */
    public static final Byte ACK = new Byte((byte)6);
    public static final Byte NACK = new Byte((byte)21);    
    /*
     * Default Constructor
     */
    public CommunicationFlow(){
        /*
         * Setting up Serial Device Configuration.
         */
        this.config = new SerialConfiguration();
        this.config.setComPort("COM1");
        this.config.setBaud("9600");
        this.config.setDataBits("8");
        this.config.setFlowControl("none");
        this.config.setParity("none");
        this.config.setStopBits("1");
        /*
         * Preparing Instrcutor by passing this configuration to it.
         */
        this.instruction = new Instruction();
        this.instruction.setConfig(this.config);
        /*
         * Preparing the executor by passing the instructor to it.
         */
        this.executor = new RS232Executor();
        this.executor.init(instruction);        
    }
    
    /**
     * Main method to execute the Sample Example
     */
    public static void main(String... args){
        try {
            String request ="COM PORT COMMUNICATION USING JAVA BY JOVIAL JAVA";
            CommunicationFlow commFlow = new CommunicationFlow();
            request = Common.asciiToHex(request);
            commFlow.send(Common.appendSTX_ETX_LRC(request));
            System.out.println("___________________________________");
            System.out.println("RESPONSE -["+ commFlow.response+"]");
        } catch (RS232Exception e) {
            e.printStackTrace();
        }
    }
    
    /**
     * This is the main method which implements the flow.
     */
    public void send(String hexRequestData) throws RS232Exception /* this is the only exception thrown by RS232Java */{
        /*
         * STEP 1 : Connect to Serial DEVICE and check if operation was successful
         */
        this.instruction.setOperation(DataOperation.INITIALIZE);
        this.executor.execute();
        this.checkInitResult(this.instruction.getResult());
        /*
         * STEP 2: If we reach here, means Computer (C) is SUCCESSFULLY CONNECTED TO Serial Device (D)
         * Our next target it to send data to serial device and wait for Serial Device to respond with ACK/NAK
         * Maximum Retry Count = 3
         * Waiting time for Serial Device to send ACK = 2000 ms
         * Data to send : request Data
         */
        this.SendRequest(hexRequestData, 2000, 3);
        /*
         * STEP 3: If we reach here, means serial device has SUCCESSFULLY SENT ACK.
         * Our next Target it to wait for SERIAL DEVICE TO SEND RESPONSE.
         * Waiting time for response = 30,000 ms
         * Maximum Retry Count = 3 ( In case of LRC is not correct)
         */
        this.performResponse(30000, 3);
        /*
         * STEP 4: If we reach here means RESPONSE HAS Been Received
         * Our next target it too close the connection with Serial Device.
         */
        this.instruction.setOperation(DataOperation.CLOSE_PORT);
        this.executor.execute();
        /*
         * If one wants, one can check the result of closing of operation by
         * this.instruction.getResult()
         */
        //=============MISSION ACCOMPLISHED=============================    
    }
    /*
     * This method checks the Initialization request
     */
    private void checkInitResult(DataResult result) {
        switch (result) {
        case SUCCESS:
            System.out.println("SERIAL DEVICE SUCCESSFUL INITIALIZED");
            break;
        case FAILED:
            System.err.println("____________________________________________");
            System.err.println(" SERIAL DEVICE FAILED TO INITALIZE ");
            System.err.println("____________________________________________");
            System.exit(1);        
        }
    }    
    /*
     * this method will send the DATA to Serial DEVICE and will wait for ACK/NAK
     */
    private void SendRequest(String requestData, Integer ackWaitTime, int retryCount) throws RS232Exception{
            this.instruction.setOperation(DataOperation.SEND_N_WAIT_FOR_ACK);
            this.instruction.setTimeOutInMilliSeconds(ackWaitTime);
            this.instruction.setRequest(requestData, null);
            executor.execute();            
            int NAKcounter = 0;
            int noDataCounter = 0;
            boolean breakFlag = false;            
while(!breakFlag){
            DataResult result = instruction.getResult();
                switch (result) {
                case ACK:{
                    System.out.println("SERIAL DEVICE COMMUNICATED SUCCESSFULLY");
                    breakFlag = true;
                    break;
                }
                case NACK:{
                    if(NAKcounter < retryCount){
                        NAKcounter++;
                        System.err.println("NACK Received, Retrying count["+NAKcounter+"]");
                        executor.execute();                
                    }else{
                        System.err.println("NACK Recieved more than "+ NAKcounter + " times");
                        System.exit(1);
                    }
                    break;
                }            
                case NO_DATA:{
                    if(noDataCounter < retryCount){
                        noDataCounter++;
                        System.err.println("NO Data Received, Retrying count["+noDataCounter+"]");
                        executor.execute();                                            
                    }else{
                        System.err.println("No Data Recieved more than "+ noDataCounter + " times");
                        System.exit(1);
                    }
                    break;
                }
                case FAILED:{
                    System.err.println("____________________________________________");
                    System.err.println(" SERIAL DEVICE FAILED TO COMMUNICATE ");
                    System.err.println("____________________________________________");
                    System.exit(1);
                }
                }
            }        
    }
    
    
private void performResponse(Integer responseTimeOut, Integer retryCount) throws RS232Exception{
        instruction.setOperation(DataOperation.WAIT_FOR_ETX_LRC);
        instruction.setTimeOutInMilliSeconds(responseTimeOut);
        executor.execute();        
        int NAKCounter = 0 ;        
        boolean breakFlag = false;
        
    while(!breakFlag){    
        DataResult result = instruction.getResult();
            switch (result) {
                case RESPONSE:{
                     this.response = instruction.getHexResponse();                                                          
                    // CHECK THE LRC value here    
                    if(!this.verifyLRC(this.response)){
                            if(NAKCounter < retryCount){                                
                                instruction.setRequest(null,new byte[]{NACK});
                                instruction.setOperation(DataOperation.CLR_SEND_N_WAIT_FOR_ETX_LRC);                                
                                executor.execute();        
                                NAKCounter++;
                                continue;
                            }else{
                                System.err.println("!!!ERROR!!! - BAD LRC IN RESPONSE");
                                System.exit(1);
                            }
                        }else{
                            /*
                             * Means LRC is OK, SEND ACK and RETURN
                             */
                            instruction.setRequest(null,new byte[]{ACK});
                            instruction.setOperation(DataOperation.SEND);
                            executor.execute();    
                            breakFlag = true;
                        }
                    break;                
                }case NO_DATA:{
                    System.err.println("____________________________________________");
                    System.err.println(" SERIAL DEVICE FAILED TO SEND RESPONSE ");
                    System.err.println("____________________________________________");
                    System.exit(1);                    
                }case FAILED:{
                    System.err.println("____________________________________________");
                    System.err.println(" SERIAL DEVICE FAILED TO COMMUNICATE ");
                    System.err.println("____________________________________________");
                    System.exit(1);                
                }
            }
    }
        
    }

    private boolean verifyLRC(String hexResponse){
        return Common.verify(response);        
    }
}

. . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Another Required File

Part 5 of 6: Java Program to implement the Flow

2011-01-03T05:50:00.000-08:00

====================================================================

Click Here - Part 6 Of 6

====================================================================

Part 4 of 6: A Programmtic Example

2011-01-03T05:43:00.000-08:00

=======================================================================

Click Here - PART 5 OF 6

=======================================================================
Lets Suppose we have following flow to be implemented -

=======================================================================

Click Here - PART 5 OF 6

=======================================================================

Part 3 of 6: Setting up CLASSPATH for RS232 Jar

2011-01-02T06:48:00.000-08:00

=============================================================================

Click Here -PART 4 OF 6

=============================================================================
Step 1:Please download Rxtxcomm.jar from this location-

Download RxTx Jar

There will be 3 files-

1) RXTXcomm.jar : Please keep this jar in your classpath.
2) rxtxParallel.dll : Please copy this path also in your classpath or else one can copy this file in
{java install directory}/bin/ directory.
for example- on my system- these files are at this location -
C:\Program Files\Java\jre6\bin
some of other files available in this folder are - java.exe, rmid.exe etc.
3) rxtxSerial.dll - Same as rxtxParallel.dll.

Step 2 – Please download the RS232java1.0.0.jar and java docs from this location
Download RS232Java-1.0.0.jar

Please copy this file in your classpath.

Download RS232Java-1.0.0docs.zip

=============================================================================

Click Here -PART 4 OF 6

=============================================================================

Part 2 of 6: Architecture of RS232Java

2011-01-02T06:41:00.000-08:00

===================================================================
Click Here - PART 3 OF 6
===================================================================
First of all there are only 2 known APIs are available in the market for Serial Communication in JAVA.

JavaComm - It is provided by Sun Microsystems and in 2005 Sun silently withdrew Java Comm support for Windows.

RxTx - This is a very good API which provide support for windows as well as Linux. But in my opinion in order to properly use this API, you need intermediate level of knowledge of Serial communication. Rx-Tx - if not used as a Java Comm driver - provides a richer interface, but one which is not standardized.

RS232Java -This API has been built on top of RXTXcomm to provide a richer and better interface. It can support both 32 and 64 bit machine. In Serial programming flows are complex but similar most of time. This API has lots of in built flows, so user can decide which flow to execute. Everything will be handled by this API.

Architecture:
This API reflects replica of Instructor-Executor based relationship, in which user of the API will act as Instructor and API will be executor. You decide which flow to be executed and executor will do that.

===================================================================
Click Here - PART 3 OF 6
===================================================================

Part 1 of 6: RS232 Communication Using JAVA

2010-12-06T19:31:00.001-08:00

===============================================================

Click HERE -PART 2 of 6

===============================================================

If you are not sure about –

Ø What is the difference between DCE and DTE?
Ø What is the significance of RTS, DTS, CS, ACK, NACK, STX, ETX etc in Serial Communication?
Ø Whether to implement event based or time based communication?
Ø Whether to transmit data in Hex, ASCII or Hex dumps?
Ø Which combination of Baud rate, data bits, parity bit, hardware flow, and stop bit one should use?

And

> If you don’t know that native JAVA doesn’t have unsigned bytes and serial communication is less error prone if you transmit data in unsigned bytes.

And

If you are looking for a very simple solution to implement the complex flow of serial communication?
Ø If you are looking for a JAVA based solution of serial communication?

If answers to most of questions are YES, then you are at right page. Here we will go through a small tutorial to make you master of serial communication in JAVA.

Note:

Ø This tutorial assumes that you have eclipse install on your system.

Ø You have basic knowledge of JAVA.

XML to HashMap in JAVA

2010-06-24T01:12:00.000-07:00

Hi Guys,

This program will convert any XML document to a HashMap in Java.
Download - Please download it from here-
http://code.google.com/a/eclipselabs.org/p/java-utility/downloads/list

1) Program 1: XMLToMap.java
This is the main java program. It has public static void main method.
2) Program 2: ValueHandler.java
This is the program which will actually do the conversion.
3) Prgram 3: StringToSteam.java
This is just a small util which will convert String to InputStream.

How to use?
1) Please unzip the zip file.
2) Copy all the 3 files in same folder
3) Run XMLToMap.java

The program will run on Java 1.5 and higher.

com port communication using java

2010-06-10T04:54:00.000-07:00

NOTE: For step by step tutorial please click on this link -
COM PORT COMMUNICATION USING JAVA (RS232JAVA-1.0.0 API)

import gnu.io.*;
import java.io.*;

public class ComPortTest
{

/*
 * This program will connect to COM PORT Device and send TEST MESSAGE to it.
 * After sleeping for 500ms , It will read the response from SAME DEVICE.
 * copyright (c) 2011 http://www.jovialjava.blogspot.com
 * For detailed Tutorial please check it out - 
 * http://jovialjava.blogspot.com/2010/12/rs232-communication-using-java.html
 */
public boolean testComPort(String comPort, String testMessage){
    CommPortIdentifier portIdentifier = null;
    try{
        portIdentifier = CommPortIdentifier.getPortIdentifier(comPort);
        if (portIdentifier.isCurrentlyOwned())
        {
            System.out.println("Port in already in use, owner ["+ portIdentifier.getCurrentOwner()+"]");
            return false;
        }else{
            SerialPort serialPort = (SerialPort) portIdentifier.open("ListPortClass", 300);
            System.out.println("COM PORT NAME -["+portIdentifier.getName()+"] BAUD RATE ["+serialPort.getBaudRate()+"]" );
            serialPort.setSerialPortParams(300, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
            OutputStream mOutputToPort = serialPort.getOutputStream();
            InputStream mInputFromPort = serialPort.getInputStream();
            mOutputToPort.write(testMessage.getBytes());
            System.out.println("Byte Sent");
            mOutputToPort.flush();
            System.out.println("Waiting for response");
            Thread.sleep(500);
            byte mBytesIn [] = new byte[20];
            mInputFromPort.read(mBytesIn);
            String value = new String(mBytesIn);
            System.out.println("Response from Serial Device: "+value);
            mOutputToPort.close();
            mInputFromPort.close();
            serialPort.close();
            System.out.println("!!! ======================== COM PORT TEST - PASS =============================!!!");
            return true;
        }
    }catch(NoSuchPortException nspe){
            System.out.println("No such port ["+comPort+"] found on system "+ nspe.getMessage());
    }catch(PortInUseException piue){
            System.out.println("port ["+comPort+"] is already in use, owner["+ portIdentifier.getCurrentOwner()+"] "+piue.getMessage());
    }catch(UnsupportedCommOperationException ucoe){
            System.out.println("Setting Communciation Operations - 300, DataBits -"+ SerialPort.DATABITS_8+", StopBits "+ SerialPort.STOPBITS_1+", Parity "+ SerialPort.PARITY_NONE);
            System.out.println("Communication Operations are not supported on port ["+comPort+"] "+ ucoe.getMessage());            
    }catch(IOException ioe){
            System.out.println("IOExceptin while trying to communicate with COM PORT device "+ ioe.getMessage());
    }catch(InterruptedException ie){
            System.out.println("Interruption while waiting for response from COM Device "+ ie.getMessage());
    }
    return false;
}

    public static void main(String... args){
            new ComPortTest().testComPort("COM1", "JOVIAL JAVA");    
    }
}