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

Question

我想使用pthread实现线程类。 当然，我要为正在创建的每个线程使用不同的启动例程。 pthread_create tho只允许将静态函数作为启动例程，因此无法实例化。 有没有办法允许使用它，还是使用结构来处理我的线程更好？ 这是我写的sofer的代码：

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），我使用了“两步”输入机制。 以这两个步骤的代价（小），每个类都可以轻松拥有自己的线程。

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

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);

   // ...
}

注意m_Thread.create（）的第二个参数“ this”。

线程将从静态方法开始：

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 *参数用类实例的'this'指针填充，然后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);

'int select'和switch / case语句可以运行唯一的threadEntry（）。

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

也许开关/外壳可能安装在threadEntry2（）中。

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

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

可以（更直接地）调用方法指针，而不是调用“固定”名称threadEntry2（）。

以上是小问题。

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

我确实在单个类实例中有多个线程“运行”。 为此，我在互斥或其他保护机制下使用了关键部分。 std :: mutex很方便，并且可以与“ Posix”线程一起使用，但是，在Ubuntu上，我经常使用Posix Process Semaphore，并将其设置为“本地”模式（未命名，未共享）。 PPLSem_t是高效的，适合于封装在小类中的4个单行方法。

---

pthread_create tho只允许将静态函数作为启动例程，因此无法实例化。

实例化包含静态方法的类的实例没有困难。 我不确定您在此声明/上下文中的含义。

回顾一下我上面详细介绍的方法，您应该很快就可以在您的类实例中使用Posix线程。

---

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