Thread: Passing class member function to pthread_create

You will not be able to do that directly, since pthread_create() only allows you to specify one argument, but you need two -- the "this" pointer and the arg itself. The general pattern is:

Code:

void *LaunchMemberFunction(void *obj)
{
    MyClass *myObj = reinterpret_cast<MyClass *>(obj);
    return myObj->function();
}

But since you need to pass a parameter, you'll need a second level of indirection:

Code:

class MyLauncher
{
public:
    MyLauncher(MyClass *myObj, void *arg) : mObj(myObj), mArg(arg) {}

    void *launch() { return mObj->function(mArg); }

    MyClass *mObj;
    void *mArg;
};

void *LaunchMemberFunction(void *obj)
{
    MyLauncher *myLauncher = reinterpret_cast<MyLauncher *>(obj);
    return myLauncher->launch();
}

MyClass myObj;
void *myArg;
MyLauncher launcher(&myObj, myArg);
pthread_create(&thr, NULL, LaunchMemberFunction, &launcher);

It kinda makes you want to rethink what you're doing, doesn't it?

Originally Posted by lehe

1. I've tried to make func1 as static member function, but since it uses non-static data member, so error follows.

Right, that won't work.

2. is there some wrapper on pthread library or its equivalence for C++? Is pthread library the best choice for multithreading in C++?

I'd say pthreads is still the right choice. The method I gave above could be made general by some careful templatizing.

You can of course also provide the LaunchMemberFunction() as a static function - but you still need to translate the static call and void * into object and member function call.

--
Mats

IMO the best choice is Boost.Thread, which supports member functions through Boost.Bind without any problems.

I usually create an abstract class of sorts, and each thread that I create inherits from that class. Since a thread is implemented via a subclass, having to pass parameters directly to the thread function isn't necessary. Example:

Code:

// Obviously not complete, but this should demonstrate the basic idea....
class thread
{
      public:
            thread() : code_(0) { }
            void start() { pthread_create(&pth_, NULL, thread::thread_router, reinterpret_cast<void*>(this)); }
            void join() { pthread_join(&pth_, NULL); }
            
            virtual int exec() = 0;
            int exit_code() { return code_; }

      private:
            static void* thread_router(void* arg);
            void exec_thread() { code_ = exec(); }
            pthread_t pth_;
            int code_;
};

void*
thread::thread_router(void* arg)
{
    reinterpret_cast<thread*>(arg)->exec_thread();
    return NULL;
}


class my_thread : public thread
{
    public:
         my_thread(int arg1, int arg2) : arg1_(arg1), arg2_(arg2) { }
         virtual int exec();
    
    private:
         int arg1_, arg2_;
};

int
my_thread::exec()
{
     // use arg1_, arg2_....
     return 0;
}


my_thread thr(1, 2);
thr.start();

// Wait for it to complete...
thr.join();