Question

我想使用pthread实现一个线程类。当然，我希望为我创建的每个线程提供不同的启动例程。 pthread_create只允许静态函数作为启动例程，因此无法实例化。有没有办法允许或者更好地使用结构来处理我的线程？这是我写的代码：

class thread {

    string name;
    pthread_t id;
    pthread_mutex_t mutex;
    pthread_cond_t cond;
    pthread_attr_t attr;

public:
    thread (string t_name);

static void* start(void*);

int id_get();


private:

};

thread::thread (string t_name)
{

  name = t_name;
  pthread_attr_init(&attr);
  int stacksize = sizeof(double) * TH_STACK_SIZE * 30;
  pthread_attr_setstacksize(&attr, stacksize);
  int rc = pthread_create (&id, &attr, &start, NULL);

  cout << "return_code: " << rc << endl;
  cout << id;


}
void* thread::start(void*)
    {
while(1){
cout << "here";
pthread_exit(NULL);
    }
    }

int thread::id_get()
{
    return id;

}

和我的测试主要：

int main(void) {
    cout << "Creating threads" << endl;
    thread test1("first");
    thread test2("second");

    pthread_join(test1.id_get(),NULL);
    pthread_join(test2.id_get(),NULL);

   return 0;

}

Answer 1

如果您有可用的POSIX线程，std::thread将可用于任何支持当前标准的C ++编译器（自c ++ 11起）。

所以基本上你不需要为你的交叉编译目标推出自己的thread类（例如GCC支持自版本4.9以后）。

但总的来说，你的方法是正确的。为了使其适用于各种类，您可以简单地使thread类成为模板：

template<typename T>
class thread {

    string name;
    pthread_t id;
    pthread_mutex_t mutex;
    pthread_cond_t cond;
    pthread_attr_t attr;

public:
    thread (string t_name, T& runnable);

    static void* start(void*);

    int id_get();
    T& runnable_;
};

实现构造函数和start()函数，如下所示：

template<typename T>
thread<T>::thread (string t_name)
: name(t_name)
, runnable_(runnable)
{    
  pthread_attr_init(&attr);
  int stacksize = sizeof(double) * TH_STACK_SIZE * 30;
  pthread_attr_setstacksize(&attr, stacksize);
  int rc = pthread_create (&id, &attr, &start, this);
                                            // ^^^^

  cout << "return_code: " << rc << endl;
  cout << id;
}

template<typename T>
void* thread<T>::start(void* pThis) {
    thread<T>* realThis = reinterpret_cast<thread<T>*>(pThis);
    (realThis->runnable)_.start();
    pthread_exit(NULL);
}

可以使用thread类，如下所示：

struct MyRunnable {
    MyRunnable(/* Whatever parameters needed */) 
    : /* Whatever needs to be initialized */ {
    }
    void start() {
         /* Full access to all class member variables */
    }
}

int main() {
     MyRunnable run(/* Whatever parameters needed */);
     thread<MyRunnable> t("TheTreadName",run); // start() will execute here
     // do concurrent stuff
     t.join();
}

我只想选择一个不同的名称thread，以避免与c ++标准库发生任何冲突。

Answer 2

我希望每个线程都有不同的启动例程创建

当我使用posix线程时（我现在使用std :: thread），我使用了一个＆＃39;两步＆＃39;进入机制。在这两个步骤的（小）成本中，每个类都可以轻松拥有自己的线程。

我总是将这些输入方法保密。

class Foo_t
{

   // ... etc

private:
   static void* threadEntry(void* ptr);

   void* threadEntry2(void); // thread actions in an object method

   // ... etc
}

因为这些是私有的，所以该类有一些公共方法来创建posix线程，通常类似于：

void Foo_t::startApp() 
{
   // ... etc

   int pcStat = m_Thread.create(Foo_t::threadEntry, this);
   //   this 2 parameter method of my thread wrapper class 
   //   invoked the 4 parameter "::pthread_create(...)". 
   //   The 'this' param is passed into the 4th parameter, called arg.
   dtbAssert(0 == pcStat)(m_nodeId)(pcStat)(errno);

   // ...
}

请注意第二个参数＆＃39; this＆＃39;，m_Thread.create（）。

线程将以静态方法开始：

void* Foo_t::threadEntry(void* a_ptr)
{
  dtbAssert(a_ptr != 0);

  Foo_t* a_foo = static_cast<Foo_t*>(a_ptr);

  void* retVal = a_foo->threadEntry2();

  return(retVal);

}

这里，void *参数填入了＆＃39; this＆＃39;类实例的指针，然后static_cast回到我们需要的，一个Foo_t *。请记住，此方法是私有的，因此只有startApp（）才会创建一个线程。

请注意，threadEntry（）调用名为的实际方法：

void* Foo_t::threadEntry2(void)
{
   DBG("Thread %2d (id=%lx): sems %p/%p,  "
       "Entering sem controlled critical region\n", ...);

   // ... start thread work

}

从这里开始，该实例的任何方法都可用。

那么，下一步是什么。有很多方法可以进行不同的线程例程。

考虑向startApp添加参数：

void Foo_t::startApp(int select);

＆＃39; int select＆＃39;并且switch / case语句可以运行唯一的threadEntry（）。

也许＆＃39; int select＆＃39;可以安装（在实例中），以便threadEntry（）中的后续开关/案例可以运行唯一的方法或threadEntry2_x（）。

或许switch / case可能安装在threadEntry2（）中。

考虑startApp参数可能是方法指针。

void Foo_t::startApp(<method pointer>);

可以（稍微更直接地）调用方法指针而不是“固定”＆＃39; name threadEntry2（）。

以上是小问题。

Mutex并且在一个实例中运行了多个线程是更大的问题。

我确实有多个线程＆＃39;乱跑＆＃39;在单个类实例中。为此，我使用了关键部分，在互斥或其他一些保护机制下。 std :: mutex很方便，适用于＆＃39; Posix＆＃39;线程，但是，在Ubuntu上，我经常使用Posix Process Semaphore，设置为Local模式（未命名，非共享）。 PPLSem_t是高效的，适合包含在一个小类中的4个单行方法。

pthread_create tho只允许静态函数作为启动例程，所以它无法实例化。

实例化包含静态方法的类的实例没有困难。我不清楚你在这个陈述/背景中的意思。

回顾一下上面详述的方法，你应该快速在类实例中使用Posix线程。

请记住检查堆栈使用情况以及ARM系统上可用的RAM数量。 Ubuntu默认堆栈大小为8 MB。也许您的ARM提供堆栈大小控制。

Posix线程类和启动例程（pthread）

2 个答案: