C++：如何定义类方法作为线程的启动例程（使用 pthread 库）

Question

我有一个基类和派生类。 他们有一个虚拟函数 - virtual void action() 我如何将它传递给 *pthread_create()* 函数？

示例（有错误）：

class Base{
  protected:
     pthread_t tid;
  public:
  virtual void* action() = 0;
};

class Derived : public Base{
  void* action();
  Derived(){
    pthread_create(&tid, NULL, &action, NULL);
  } 
};

也许它应该是静态的？ 我尝试了很多组合但找不到解决方案..

Answer 1

几个月前，我在从事高级设计项目时遇到了这个问题。它需要一些底层 C++ 机制的知识。

根本问题是指向函数的指针与指向成员函数的指针不同。这是因为成员函数有一个隐式的第一个参数 this。

从 man 页面来看：

int pthread_create(pthread_t *thread,
                   const pthread_attr_t *attr,
                   void *(*start_routine) (void *),
                   void *arg);

线程入口点是 void* (*)(void*)。您的函数 Base::action 的类型为 void* (Base::*)()。这个丑陋的类型声明的 Base:: 部分表示 this 的类型。类型差异是编译器不接受您的代码的原因。

为了使这项工作正常进行，我们需要解决两件事。我们不能使用成员函数，因为指向成员函数的指针不会将 this 绑定到实例。我们还需要一个 void* 类型的参数。值得庆幸的是，这两个修复是齐头并进的，因为解决方案是我们自己显式传递 this 。

class Base {
public:
    virtual void* action() = 0;

protected:
    pthread_t tid;

    friend void* do_action(void* arg) {
        return static_cast<Base*>(arg)->action();
    }
};

class Derived : public Base {
public:
    Derived() {
        // This should be moved out of the constructor because this
        // may (will?) be accessed before the constructor has finished.
        // Because action is virtual, you can move this to a new member
        // function of Base. This also means tid can be private.
        pthread_create(&tid, NULL, &do_action, this);
    }

    virtual void* action();
};

编辑：糟糕，如果 tid 是 protected 或 private，那么 do_action 需要成为朋友。

Answer 2

您必须有一个函数将一个 void 指针传递给 pthread_create。我自己编写该函数，作为一个带有指向 Base 指针的函数（Derived 也可以工作），然后调用 action参数的函数。然后，您可以创建一个运行该函数并接收 this 作为参数的线程：

void *f(void *param)
{
    Base* b = (Base *)param;
    return b->action();
}

class Derived : public Base{
  void* action();
  Derived() {
    pthread_create(&tid, NULL, f, this);
  }
};

Answer 3

事实上它必须是静态的。您还需要将对象作为参数传递给 pthread_create：

void *Base::static_action(void *v)
{
    ((Base*)v)->action();
    return NULL;
}

pthread_create(&tid, NULL, &Base::static_action, myObject);

Answer 4

我通常会做类似的事情，我会让你填写其他细节（错误处理、锁定等）：

启动方法：

bool pthreadBase::start()
{
   return pthread_create(&threadID, NULL, &execute,this);
}

静态 void* 执行方法：

void *pthreadBase::execute(void *t)
{
   reinterpret_cast<pthreadBase *> (t)->processLoop();
   return NULL;
}

之后，你可以创建一个名为 processLoop 的虚拟方法来执行作为线程的入口点。

这是一个简单的实现（未经测试）：

class theThread: public pthreadBase
{
   public:
      theThread(SharedMemoryStructure *SharedMemory)
      {
         _Running = start();
         _Shared = SharedMemory;
      }

      ~theThread()
      {
         stop(); //Just do a join or something
         _Running = false;
      }

   private:
      void processLoop()
      {
         while(_Shared->someQuitFlag() == false)
         {
            /*Do Work*/
         }
      }

   private:
      bool _Running;
      SharedmemoryStructure *_Shared;
};

Answer 5

使其静态并不能真正保证工作，但实际上至少对于大多数实现来说确实有效（并且有足够多的人依赖它，我会有点惊讶地看到这种变化很快）。