Click here to Skip to main content
Click here to Skip to main content

Effective Threads in C++ - Part 1: The Basic Thread Class

, 22 Nov 2006
Rate this:
Please Sign up or sign in to vote.
Wrapping the Win32 Thread API into a C++-friendly class.

Introduction

Over the past few years, multithreaded apps have become the mainstay of my development repertoire. I've even found myself writing multithreaded apps where it wasn't needed. Worker threads allow Win32 applications to improve the user experience and increase performance.

For C++ programs and programmers, the Windows API's C interface doesn't necessarily fit well into new or existing class hierarchies. However, the thread concept has become the mainstay of parallel programming practice, and has become more appropriate in a wider and wider variety of circumstances.

In part 1 of this three article series, I will present my general thread class, explaining the design decisions behind it and how to use it to get the greatest effect.

The Thread Class

Before we get ahead of ourselves, let's take a look at the public interface of the Thread class:

class Thread
{
public:
    Thread();
    virtual ~Thread();

    // Suspend - Suspends the thread (if one is active)
    void Suspend();

    // Resume - Resumes a previously suspended thread
    void Resume();

    // Terminate - Terminates the thread (if one is active).
    // Prefer another means of exiting the thread, as
    // calling Terminate() does not allow the thread to free
    // any resources it may hold
    void Terminate();

    // IsThreadActive - Called in the context of another
    // (external) thread to test whether the thread is
    // currently running
    bool IsThreadActive() const;
};

This rather basic interface is also rather clean. It exposes a fair amount of the operations the Win32 API allows on threads themselves, in a clean, C++-friendly class.

Now, you may be saying to yourself, "Hey? You said it was a complete interface. There isn't even a way to create a thread in there!". Ahh, we're getting there. But before we do, we have to go through template land.

That’s right, my implementation of the Thread class uses a little template-magic. This magic is needed to allow us to use the same code among different client classes. After all, you wouldn't want to re-write the class for each client, would you?

So, let's look a little closer at a few particular lines of the source code.

template<class T, class P>
class Thread
{
public:
    typedef void (T::*ThreadFunc)( P );
    
    // ...
    // Same as above
    // ...
};

There are actually two different template parameters: T and P; or, put another way: Class and Parameter.

To invoke a method on an object, the compiler needs two things: the object's type (the T in the template argument list), and the method's signature (which is composed of the return type, class, method name, and parameter list). For this implementation, the method is assumed to return nothing (void) and takes one parameter (see article #3 in this series for a more general solution which doesn't make these assumptions).

The typedef makes things very easy. It is a method typedef, specifying that ThreadFunc is a function pointer to a function of T which takes a P as a parameter and returns nothing. See why the typedef makes it easier?

Now that we've pushed and shoved our way through template land, let's look at the meat of the Thread class: the Run() method.

// Run - Start the Thread and run the method
// pClass->(*pfFunc), passing p as an argument.
// Returns true if the thread was created 
// successfully, false otherwise
bool Run( T* pClass, ThreadFunc pfFunc, P p );

That's it! That's the public interface for the Thread class. Nothing too intense. And the implementation is not much more complex. So, with that, how do we use this new class?

Using the Thread Class

Let's look at an example on how to use the Thread class:

class TestClass
{
    ...

private:
    Lib::Thread<TestClass, int> m_thread;
};

In this example, the Thread class should be used as a data member of another class (with a little modification, the class can be used as a stand-alone object; I will leave that as the dreaded and hated exercise to the reader............ for now). The enclosing class is the first template parameter to the Thread class. This is needed for the compiler to invoke the correct method of the correct class. The second template parameter is the type of argument that will be passed to the thread method.

To start the thread, call the Thread::Run() method:

m_thread.Run( this, &TestClass::DoWork, i );

This will create a new thread using the standard Win32 ::CreateThread(...) method. This new thread will immediately turn around and call the method specified to the Thread::Run() method (I know it may not look like it, but we're specifying a function in all those arguments).

The three arguments to the Thread::Run() method are:

  • The object we will be invoking the method upon
  • The method we will be invoking
  • The parameter we will pass to the method

What do we need to specify a function call? From the compiler's perspective, they are return type, class, method name, and parameter list. From the runtime's perspective, we also need an object. Since the return type is hard coded, and the class and parameter list is specified in the template argument, all the compiler needs is a method name, and the runtime needs an object. Guess what? Those are the first two parameters of the Thread::Run() method (parameter 2 and 1, respectively).

After the thread is called, it (essentially) turns around and calls:

this->DoWork( i );

As soon as this method exits, the thread is finished with its work, and it exits as well.

Conclusion

The Thread class is rather basic, but very useful. It provides a C++ wrapper for the powerful Win32 C Threading API. This particular implementation makes a few assumptions: the Thread class must be a member of an enclosing class, the return type must be void, and the method takes a single parameter.

These assumptions may be less than ideal for the time, so article #3 will show you how to get around these assumptions using more template magic. (Trust me, it won't be that painful.)

But first, article #2 will show you how to extend the Thread class into the most useful threading paradigm I have ever come across.

History

  • 2006.11.21 - First revision.

License

This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.

A list of licenses authors might use can be found here

About the Author

FlamTaps
Web Developer
United States United States
No Biography provided

Comments and Discussions

 
GeneralLink to part 3 please need it badly.... Pinmemberjdgosalia16-Jun-09 17:36 
GeneralNice! Pinmembercpallini22-Nov-06 10:37 
GeneralRe: Nice! PinmemberNeville Franks23-Nov-06 18:45 
GeneralRe: Nice! Pinmembercpallini23-Nov-06 22:06 
GeneralBoost.Threads PinmemberVolker von Einem21-Nov-06 21:21 
GeneralRe: Boost.Threads PinmemberTodd Smith21-Nov-06 22:50 
GeneralRe: Boost.Threads PinmemberVolker von Einem21-Nov-06 23:19 
GeneralRe: Boost.Threads PinmemberFlamTaps22-Nov-06 4:40 
GeneralRe: Boost.Threads PinmemberFlamTaps22-Nov-06 4:41 
GeneralRe: Boost.Threads PinmemberFlamTaps22-Nov-06 6:01 
GeneralRe: Boost.Threads PinmemberSceptic Mole22-Nov-06 3:06 
GeneralWaiting............. PinmemberRobert.ZDO21-Nov-06 14:14 
GeneralRe: Waiting............. PinmemberFlamTaps22-Nov-06 6:10 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

| Advertise | Privacy | Mobile
Web01 | 2.8.140721.1 | Last Updated 22 Nov 2006
Article Copyright 2006 by FlamTaps
Everything else Copyright © CodeProject, 1999-2014
Terms of Service
Layout: fixed | fluid