pthread for a member function of class in C++ - why not template?

Question

A "typical" approach to using pthread with a member function of a class in C++ would be to use inheritance (like suggested here https://stackoverflow.com/a/1151615/157344 ). But why not something like this:

#include <pthread.h>

template <class T, void * (T::*thread)()>
class Thread
{
public:
    int create(T *that) { return pthread_create(&_handle, nullptr, _trampoline, that); };
    pthread_t getHandle() const { return _handle; };

private:
    static void * _trampoline(void *that) { return (static_cast<T *>(that)->*thread)(); };

    pthread_t _handle;
};

It can be used like that:

class SomeClassWithThread
{
public:
    int initialize() { return _thread.create(this); };

private:
    void * _threadFunction();
    Thread<SomeClassWithThread, &SomeClassWithThread::_threadFunction> _thread;
};

It has an advantage of NOT using virtual functions, so no vtable and less RAM used (I'm developing that for an MCU, not for a PC, so RAM usage matters). It also doesn't need virtual destructor.

Moreover I think it makes more sense, because a typical object rather HAS-A thread (composition), than IS-A thread (inheritance), right? (;

Is there any flaw with such design, as I haven't seen it suggested anywhere, as opposed to inheritance method? You'd definetely get a copy of _trampoline() for each instantiation but that's not much different from a virtual function call in inheritance version... I hope that create() and getHandle() would be inlined, as there's no reason not to...

Answer 1

This resolves the problem with the "this" address

#include <pthread.h>

template <class T, void * (T::*thread)()>
class Thread
{
public:
    int create(T* passedThis) { return pthread_create(&_handle, nullptr, _trampoline, passedThis); };
    pthread_t getHandle() const { return _handle; };

private:
    static void * _trampoline(void *that) { return (static_cast<T*>(that)->*thread)(); };

    pthread_t _handle;
};

Updated usage:

class SomeClassWithThread
{
public:
    int initialize() { return _thread.create(this); };

private:
    void * _threadFunction();
    Thread<SomeClassWithThread, &SomeClassWithThread::_threadFunction> _thread;
};

Answer 2

Your Thread::_trampoline method doesn't have extern "C" linkage so, although this may work in practise, it isn't correct. Since you can't give the correct linkage to template functions, there isn't an easy way to automate this unless you allow macros.

Moreover I think it makes more sense, because a typical object rather HAS-A thread (composition), than IS-A thread (inheritance), right? (;

Nope, that depends on your model.

• active objects are frequently bound tightly to a single thread (so you can consider than an instance IS-A concurrently-executing process)
• with task queues (or thread pools) it's frequently the task that is the object, whereas the thread is associated with some scheduling logic (the queue/pool itself may be an object too of course, but that doesn't seem to be what you're suggesting)

Honestly, if you're creating so many different top-level thread functions that you're worried about the memory taken up by vtables, I suspect your design is wrong in the first place.

Answer 3

As Useless mentioned in his answer, strictly speaking the thread function called by the pthread library needs to be extern "C". While a static member function works in nearly all cases, from a language lawyer point of view and at least one real life situation, it's not correct. See https://stackoverflow.com/a/2068048/12711 for details.

However, you can have an extern "C" function provide the interface between the pthread library and your class template, but it does seem to require a tiny bit of overhead:

#include <pthread.h>

struct trampoline_ctx
{
    void* (*trampoline)(void*);
    void* obj;
};

extern "C"
void* trampoline_c(void* ctx)
{
    struct trampoline_ctx* t = static_cast<struct trampoline_ctx*>(ctx);

    return (t->trampoline)(t->obj);
}


template <class T, void * (T::*thread)()>
class Thread
{
public:
    int create(T *that) { 
        ctx.trampoline = _trampoline;
        ctx.obj = that;
        return pthread_create(&_handle, nullptr, trampoline_c, &ctx); 
    };
    pthread_t getHandle() const { return _handle; };

private:
    static void * _trampoline(void *that) { return (static_cast<T *>(that)->*thread)(); };

    pthread_t _handle;
    struct trampoline_ctx ctx;
};

I agree that composition rather than inheritance is probably a better model for threading most of the time.

Of course, remember that C++11 provides std::thread which is a templated, non-inheritance design. And see boost::thread if C++11 isn't an option.