Asynchronous programming is a wonderfull thing is it not? However that only applies if it is used in a controlled manner. Given the advantages that it offers it can potentially be very easy to get into the swing of it all and make an entire application async and ending up in debugging hell in the event of unexpected application behaviour.

So why am i talking about aync? ok so let me get one thing clear, when i say async i strictly mean non-blocking, because you can make an async call and have your program wait on the function to finish doing its task, however in that case you are no longer doing what you set out to do. Ok i guess  am just dragging this out, well i get the point , enough foreplay, now on to business!

Since my research work is mostly all C++, i reached a stage in my research where i had to adopt an asynchronous (non-blocking) approach at solving one of my research problems. Which had me to go on the hunt for the best possible means to accomplish this in C++. So given my self-made rules to minimize dependencies, i started looking into the Async model which is part of the new C++ standard.

Believe me i was very very tempted to go down the third-party library pathway i.e. Asio which provides you with both boost and non-boost options.

However in the interest of confirming to my self-made rules i decided to give the new C++ libraries a spin and surprisingly it is very very simple. I cant believe i am saying this but it is almost as simple (if not simpler) to do async with C++ as it is with Java.


So this is what i wanted to accomplish,

  1. write 2 functions A and B
  2. Function A goes on for a long long time
  3. Function B performs a short simple task
  4. Start executing function A
  5. Invoke B from A
  6. A keeps on running while B doing its job 
  7. at some point when B finishes A acknowledges it and continues doing its processing

Sounds complicated? bear with me a little longer and i will make things clearer

Equipment used

  1. Ubuntu 10.04 to 12.04: i have tried it on most of the Ubuntu versions
  2. g++ 4.6: this is the only compiler that i have tried this on, 10.04 comes with g++4.4 by default in which case you need to install the new version using apt-get install g++-4.6.
  3. A text editor 

While this implementation was done under Linux i am sure it can be ported accross to any OS with a compiler that supports c++0x


#include <future>
#include <iostream>

using namespace std;

bool finito = false;//this is the shared variable which will pass messages between the 2 functions
int value;
mutex m; // mutex is simply a way to enforce locking on a shared piece of data

bool countToTen()//think of this as the function B
/*lets do something so we can demonstrate that the function takes
time to finish*/
for(int counter=0;counter<10;counter++)
/ /cout<<"counter from(async):"<<(i+1)<<endl;
/*lets acquire a lock on the finito variable
we do not need to worry about unlocking it
as the lock_guard already takes care of that for us
lock_guard<std::mutex> lk(m);
finito = true;
return finito;
int main()//think of this as the function A
/*the launch policies are launch::async and launch::sync
which are both self-explanatory.
future<bool> done = async(std::launch::async,countToTen);
cout<<"Now we are going to start counting...."<<endl;
for(int counter=0;counter<100000;counter++)
/*do something meaningfull....
In my case i was looping through frames of a video

/* Instead of accessing finito directly we can also access it via the future
done.get(), the future is a neat little thing that holds the return value of your
function, so when the function is done you can access it via the get method

cout<<"ok so we have finished the function"<<endl;
cout<<"this is where we got upto:"<<value<<" before countToTen finished";
break;//ok we are done so lets get out of here

Compiling the code above

So you need to keep a few steps in mind since the new threading functionality is still experimental and you need to specify that use of these new functions when compiling the code. It can be compiled using the following commands

g++ -std=c++0x pthread -o yourasyncdemo yourasyncdemo.cpp

-std: c++0x, so you are using the extensions to the standard library which are part of c++0x
-pthread: so we are including the thread library

References used

In addition to a good tutorial on Aync, the link below also contains a range of other useful tutorials on threading in c++0x.

Leave a Reply

Your email address will not be published. Required fields are marked *