Simple example of threading in C++

Question

Can someone post a simple example of starting two (Object Oriented) threads in C++.

I'm looking for actual C++ thread objects that I can extend run methods on (or something similar) as opposed to calling a C-style thread library.

Thanks.

Update - I left out any OS specific requests in the hopes that whoever replied would reply with cross platform libraries to use. I'm just making that explicit now.

Answer 1

Hi Zak, I found a useful-looking tutorial here:

http://www.linuxdocs.org/HOWTOs/C++Programming-HOWTO-24.html

Hope this helps!

Adam

Answer 2

It largely depends on the library you decide to use. For instance, if you use the wxWidgets library, the creation of a thread would look like this:

class RThread : public wxThread {

public:
 RThread()
  : wxThread(wxTHREAD_JOINABLE){
 }
private:
 RThread(const RThread &copy);

public:
 void *Entry(void){
  //Do...

  return 0;
 }

};

wxThread *CreateThread() {
 //Create thread
 wxThread *_hThread = new RThread();

 //Start thread
 _hThread->Create();
 _hThread->Run();

 return _hThread;
}

If your main thread calls the CreateThread method, you'll create a new thread that will start executing the code in your "Entry" method. You'll have to keep a reference to the thread in most cases to join or stop it. More info here: wxThread documentation

Answer 3

You didn't specify your platform, but in most cases, I'd recommend that you take a look at Boost.Thread, a hello-world example of which is available here.

Answer 4

This DDJ article has some examples of using Boost.Thread.

Answer 5

I'd recommend using the Boost::Thread library. It offers easy portable threading. If you want OS-specific threading calls, you'll need to specify the OS, as DavidK mentioned.

Answer 6

Well, technically any such object will wind up being built over a C-style thread library because C++ only just specified a stock 'std::thread' model in c++0x, which was just nailed down and hasn't yet been implemented. The problem is somewhat systemic, technically the existing c++ memory model isn't strict enough to allow for well defined semantics for all of the 'happens before' cases. Hans Boehm wrote an paper on the topic a while back and was instrumental in hammering out the c++0x standard on the topic.

http://www.hpl.hp.com/techreports/2004/HPL-2004-209.html

That said there are several cross-platform thread C++ libraries that work just fine in practice. Intel thread building blocks contains a tbb::thread object that closely approximates the c++0x standard and Boost has a boost::thread library that does the same.

http://www.threadingbuildingblocks.org/

http://www.boost.org/doc/libs/1_37_0/doc/html/thread.html

Using boost::thread you'd get something like:

#include <boost/thread.hpp>

void task1() { 
    // do stuff
}

void task2() { 
    // do stuff
}

int main (int argc, char ** argv) {
    using namespace boost; 
    thread thread_1 = thread(task1);
    thread thread_2 = thread(task2);

    // do other stuff
    thread_2.join();
    thread_1.join();
    return 0;
}