EmptyCrate Software. Travel. Stuff.

We've covered the "Assembly Language", "C" and "C++" of the C++ threading world, and now we are going to try and move beyond that.

In the "C++" example we showed a object that automatically managed a thread's life time and used the thread to calculate the Fibonacci sequence in the background. Using templates we should be able to make a generic version of the Fibonacci calculator thread.

If boost::threads represent the C of multithreaded programming, then RAII and automatically managed threads represent the C++ of multithreaded programming.

In the last article we promised that using more RAII would allow us to get this code even smaller and better to manage. Here is the result of that:


class threaded_class
{
public:
threaded_class()
: m_stoprequested(false),
m_thread(boost::bind(&threaded_class::do_work, this)) //Note 2
{
}

~threaded_class()
{

Understanding RAII is critical to understanding good C++ design.

RAII stands for "Resource Acquisition Is Initialization." The basic idea is that an object fully manages all of its own resources.

Understanding object lifetime is critical to understanding RAII. For the purposes of this article we will only be discussing objects created on the stack, not on the heap. That is, objects not created with "new."

There are just a couple of simple rules to understanding lifetime: