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,
- write 2 functions A and B
- Function A goes on for a long long time
- Function B performs a short simple task
- Start executing function A
- Invoke B from A
- A keeps on running while B doing its job
- 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
- Ubuntu 10.04 to 12.04: i have tried it on most of the Ubuntu versions
- 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.
- 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
using namespace std;
bool finito = false;//this is the shared variable which will pass messages between the 2 functions
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*/
/ /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
finito = true;
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;
/*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