multithreading and classes?

Question

Here is the issue that I'm having with multithreading. The proc needs to be static which means the only way I see that 2 threads can communicate and share data is through the global scope. This does not seem very clean nor does it feel very OO. I know I can create a static proc function in a class but that's still static.

What I'd like to for example do is have thread procs in the class somehow so that ex: I could create an MD5 checksum class and have an array of these objects, each on their own thread checking its hash, while the UI thread is not impaired by this and another class could simply keep track of the handles and wait for multiple objects before saying "Complete" or something. How is this limitation usually overcome?

Answer 1

I'm not sure I understood well... I give it a try. Are you looking for thread local storage ?

Answer 2

You cannot avoid using a static function if you want to start a thread there. You can however (using Windows) pass the this pointer as a parameter and use it on the other side to enter the class instance.

#include <windows.h>

class Threaded {
    static DWORD WINAPI StaticThreadEntry(LPVOID me) {
        reinterpret_cast<Threaded*>(me)->ThreadEntry();
        return 0;
    }

    void ThreadEntry() {
        // Stuff here.
    }

public:
    void DoSomething() {
        ::CreateThread(0, 0, StaticThreadEntry, this, 0, 0);
    }
};

Answer 3

In C++, Boost.Thread solves the problem nicely. A thread is represented by a functor, meaning that the (non-static) operator() is the thread's entry point.

For example, a thread can be created like this:

// define the thread functor
struct MyThread {
  MyThread(int& i) : i(i) {}
  void operator()(){...}
private:
  int& i;
};

// create the thread
int j;
boost::thread thr(MyThread(j));

by passing data to the thread functor's constructor, we can pass parameters to the thread without having to rely on globals. (In this case, the thread is given a reference to the integer j declared outside the thread.)

With other libraries or APIs, it's up to you to make the jump from a (typically static) entry point to sharing non-static data.

The thread function typically takes a (sometimes optional) parameter (often of type void*), which you can use to pass instance data to the thread.

If you use this to pass a pointer to some object to the thread, then the thread can simply cast the pointer back to the object type, and access the data, without having to rely on globals.

For example, (in pseudocode), this would have roughly the same effect as the Boost example above:

void MyThreadFunc(void* params) {
  int& i = *(int*)params;
  ... 
}

int j;
CreateThread(MyThreadFunc, &j);

Or the parameter can be a pointer to an object whose (non-static) member function you wish to call, allowing you to execute a class member function instead of a nonmember.

Answer 4

What's wrong with the function being static? So long as the function you've written is re-entrant, you're not violating any OO principles even if you need to pass in a pointer to the class object you're trying to read/modify.

Answer 5

Thread creation routines usually allow you to pass a parameter to the function which will run in a new thread. This is true for both Posix pthread_create(...) and Win32 CreateThread(...). Here is a an example using Pthreads:

void* func (void* arg) {
    queue_t* pqueue = (queue_t*)arg;

    // pull messages off the queue
    val = queue_pull(pqueue);

    return 0;
}

int main (int argc, char* argv[]) {
    pthread_t thread;
    queue_t queue = queue_init();

    pthread_create(&thread, 0, func, &queue);

    // push messages on the queue for the thread to process
    queue_push(&queue, 123);

    void* ignored;
    pthread_join(&thread, &ignored);

    return 0;
}

No statics anywhere. In a C++ program you could pass a pointer to an instance of a class.