c++ 中类的成员函数的 pthread - 为什么不是模板？

Question

在 C++ 中将 pthread 与类的成员函数一起使用的“典型”方法是使用继承（如此处建议的 https://stackoverflow.com/a/1151615/157344 ）。但为什么不这样呢：

#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;
};

可以这样使用：

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

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

它的优点是不使用虚拟功能，因此不使用 vtable 并且使用的 RAM 更少（我正在为 MCU 开发它，而不是为 PC 开发，因此 RAM 的使用很重要）。它也不需要虚拟析构函数。

此外，我认为它更有意义，因为典型的对象而不是 HAS-A 线程（组合），而不是 IS-A 线程（继承），对吧？ (;

与继承方法相比，这种设计是否有任何缺陷，因为我在任何地方都没有看到它提出的建议？您肯定会为每个实例化获取 _trampoline() 的副本，但这与继承版本中的虚函数调用没有太大区别......我希望 create() 和 getHandle() 将被内联，因为没有理由不...

Answer 1

这解决了“this”地址的问题

#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;
};

更新用法：

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

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

Answer 2

您的Thread::_trampoline 方法没有extern "C" 链接，因此，虽然这在实践中可能有效，但它是不正确的。由于您无法为模板函数提供正确的链接，因此除非您允许宏，否则没有简单的方法可以自动执行此操作。

此外，我认为它更有意义，因为典型的对象而不是 HAS-A 线程（组合），而不是 IS-A 线程（继承），对吧？ (;

不，这取决于您的型号。

• 活动对象经常紧密绑定到单个线程（因此您可以考虑比一个实例 IS-A 并发执行进程）
• 对于任务队列（或线程池），task 通常是对象，而线程与一些调度逻辑相关联（队列/池本身当然也可能是对象，但这似乎不是您的建议）

老实说，如果您要创建这么多不同的顶级线程函数，以至于担心 vtable 占用的内存，我怀疑您的设计首先是错误的。

Answer 3

作为Useless mentioned in his answer，严格来说pthread库调用的线程函数需要是extern "C"。虽然静态成员函数几乎适用于所有情况，但从语言律师的角度和至少一种现实生活的情况来看，它是不正确的。详情请见https://stackoverflow.com/a/2068048/12711。

但是，您可以让extern "C" 函数提供pthread 库和您的类模板之间的接口，但这似乎需要一点点开销：

#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;
};

我同意在大多数情况下，组合而不是继承可能是更好的线程模型。

当然，请记住，C++11 提供了std::thread，这是一个模板化的非继承设计。如果不能选择 C++11，请参阅 boost::thread。