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

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 ) 

1. Submits a Callable task for execution and returns a Future representing that task computation.
2. 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.