Following on from my last post, where i explore doing Async with C++0x, in this one i try to accomplish the exact same thing with Java.

So first of all, before i say anything else, to me Java is first love and to some extent I still love the idea of writing anything in Java. However there are things that i have come to appreciate in other languages such as C++. So in case you are wondering, why the disclaimer? well when trying to do some Async stuff with Java, i found it to be a bit more complicated then what it was in C++. I honestly never ever imagined myself saying this, but yes it is true, i tried really hard to blame it on the tutorials that i found or my own thinking, but i must accept it for what it is.

## Problem

Given how boring my problem definition was in the last post, i will try to make this more exciting in this one.

So say, we have a shop and we are counting the cash at the end of the day to know how much we earned. A colleague will provide some help, by counting the 5\$ notes. So how do we go about this?

1. Start counting all the notes
2. While we are counting the colleague will start counting his 5\$ notes
3. At some point he will finish and tell us what his total is
4. We will compare that with the total we have and take a short break

## Solution

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

public class Async{
/*
think of callable as a Runnable that can return a value
unfortunately i have not been able to get a solution, where
we can simply just call a method asynchronously, it seems a
Callable class is a way to go.
*/
static class CountFiveNotes implements Callable<Integer>
{
//think of this as the run method that can return a value
@Override
public Integer call()throws Exception
{
int total = 0;
for(int fiveCounter = 0;fiveCounter<100;fiveCounter++)
{
total+=5;
}
}
}
public static void main(String args[])
{
//create a pool of 10 threads, it doesnt matter for this problem of how many
Callable<Integer> fiveNoteCounter = new CountFiveNotes();
/* this is where we are making the async call to the CountToFiveNotes
Future is very useful as we can use it to retrieve the value of a
callable and check if a callable has finished executing!
*/
Future<Integer> fiveNoteTotal = executor.submit(fiveNoteCounter);
int ourTotal =0;
for(int counter=0;counter<10000000;counter++)
{
ourTotal+=counter;
if(fiveNoteTotal.isDone())
{
System.out.println(“This is where we got up to:”+counter);
try{
ourTotal+=fiveNoteTotal.get();
System.out.println(“Total so far:”+ourTotal);
}catch(Exception e){e.printStackTrace();}
break;//lets take a short break
}

}
executor.shutdown();
}
}

### Compiling the code above

I was too lazy to do this in an IDE, so i just compiled it over the command line using,

javac Async.java

but i cant see a reason why this code wouldn’t work in Eclipse or Netbeans.

## References used

http://www.vogella.com/articles/JavaConcurrency/article.html

http://www.ibm.com/developerworks/java/library/j-jtp04186/index.html

http://docs.oracle.com/javaee/6/tutorial/doc/gkkqg.html

#### Mamta Soni · February 1, 2013 at 11:35 am

Your blog is very informative and gracefully
your guideline is very good.Thank you
Regional pharmacy college
deepshikha group of colleges

#### Bhuman Soni · January 18, 2019 at 11:47 pm

Now you can also subscribe to this blog as we send you a weekly newsletter with new posts, so you don’t miss a post. All you need to do now is enter your email address in the field here http://mydaytodo.com/blog and click subscribe. Cheers

#### Bhuman Soni · February 11, 2013 at 10:37 am

No worries, happy to help!