Simple C++ Threading

Question

I am trying to create a thread in C++ (Win32) to run a simple method. I'm new to C++ threading, but very familiar with threading in C#. Here is some pseudo-code of what I am trying to do:

static void MyMethod(int data)
{
    RunStuff(data);
}

void RunStuff(int data)
{
    //long running operation here
}

I want to to call RunStuff from MyMethod without it blocking. What would be the simplest way of running RunStuff on a separate thread?

Edit: I should also mention that I want to keep dependencies to a minimum. (No MFC... etc)

Answer 1

Simple threading in C++ is a contradiction in terms!

Check out boost threads for the closest thing to a simple approach available today.

For a minimal answer (which will not actually provide you with all the things you need for synchronization, but answers your question literally) see:

http://msdn.microsoft.com/en-us/library/kdzttdcb(VS.80).aspx

Also static means something different in C++.

Answer 2

static boost::thread runStuffThread();

static void MyMethod(int data)
{
    runStuffThread = boost::thread(boost::bind(RunStuff, data));
}

// elsewhere...
runStuffThread.join(); //blocks

Answer 3

CreateThread (Win32) and AfxBeginThread (MFC) are two ways to do it.

Be careful to use _beginthread if you need to use the C run-time library (CRT) though.

Answer 4

For win32 only and without additional libraries you can use CreateThread function http://msdn.microsoft.com/en-us/library/ms682453(VS.85).aspx

Answer 5

If you really don't want to use third party libs (I would recommend boost::thread as explained in the other anwsers), you need to use the Win32API:

static void MyMethod(int data)
{

    int data = 3;

    HANDLE hThread = ::CreateThread(NULL,
     0,
     &RunStuff,
     reinterpret_cast<LPVOID>(data),
     0,
     NULL);


    // you can do whatever you want here

    ::WaitForSingleObject(hThread, INFINITE);
    ::CloseHandle(hThread);
}

static DWORD WINAPI RunStuff(LPVOID param)
{  

     int data = reinterpret_cast<int>(param);

     //long running operation here

     return 0;
}

Answer 6

Is this safe:

unsigned __stdcall myThread(void *ArgList) {
//Do stuff here
}

_beginthread(myThread, 0, &data);

Do I need to do anything to release the memory (like CloseHandle) after this call?

Answer 7

Consider using the Win32 thread pool instead of spinning up new threads for work items. Spinning up new threads is wasteful - each thread gets 1 MB of reserved address space for its stack by default, runs the system's thread startup code, causes notifications to be delivered to nearly every DLL in your process, and creates another kernel object. Thread pools enable you to reuse threads for background tasks quickly and efficiently, and will grow or shrink based on how many tasks you submit. In general, consider spinning up dedicated threads for never-ending background tasks and use the threadpool for everything else.

Before Vista, you can use QueueUserWorkItem. On Vista, the new thread pool API's are more reliable and offer a few more advanced options. Each will cause your background code to start running on some thread pool thread.

// Vista
VOID CALLBACK MyWorkerFunction(PTP_CALLBACK_INSTANCE instance, PVOID context);

// Returns true on success.
TrySubmitThreadpoolCallback(MyWorkerFunction, context, NULL);

// Pre-Vista
DWORD WINAPI MyWorkerFunction(PVOID context);

// Returns true on success
QueueUserWorkItem(MyWorkerFunction, context, WT_EXECUTEDEFAULT);

Answer 8

More info about Treading

Answer 9

Another alternative is pthreads - they work on both windows and linux!