¿La mejor manera de iniciar un hilo como miembro de una clase de C++?

Question

Me pregunto mejor forma para iniciar un pthread que es miembro de una clase de C++? Mi propio enfoque sigue como una respuesta ...

Answer 1

Normalmente utilizo una función miembro estática de la clase, y uso un puntero a la clase como el parámetro void *. Esa función puede realizar el procesamiento de subprocesos o llamar a otra función miembro no estática con la referencia de clase. Esa función puede hacer referencia a todos los miembros de la clase sin una sintaxis incómoda.

Answer 2

Tienes que arrancar usando el vacío parámetro *:

class A 
{ 
    static void* StaticThreadProc(void *arg) 
    { 
    return reinterpret_cast<A*>(arg)->ThreadProc(); 
    } 

    void* ThreadProc(void) 
    { 
    // do stuff 
    } 
}; 

... 

pthread_t theThread; 
pthread_create(&theThread, NULL, &A::StaticThreadProc, this);

Answer 3

Esto puede hacerse simplemente mediante el uso de la biblioteca de impulso, así:

#include <boost/thread.hpp> 

// define class to model or control a particular kind of widget 
class cWidget 
{ 
public: 
void Run(); 
} 

// construct an instance of the widget modeller or controller 
cWidget theWidget; 

// start new thread by invoking method run on theWidget instance 

boost::thread* pThread = new boost::thread(
    &cWidget::Run,  // pointer to member function to execute in thread 
    &theWidget);  // pointer to instance of class 

Notas:

• Esto usa una función de miembro de clase ordinaria. No es necesario agregar miembros adicionales, estáticos que confunden su interfaz de clase
• Simplemente incluya boost/thread.hpp en el archivo de origen donde inicia el hilo. Si recién está empezando con el impulso, se puede ignorar todo el resto de ese paquete grande e intimidante.

En C++ 11 se puede hacer lo mismo pero sin impulso

// define class to model or control a particular kind of widget 
class cWidget 
{ 
public: 
void Run(); 
} 

// construct an instance of the widget modeller or controller 
cWidget theWidget; 

// start new thread by invoking method run on theWidget instance 

std::thread * pThread = new std::thread(
    &cWidget::Run,  // pointer to member function to execute in thread 
    &theWidget);  // pointer to instance of class 

Answer 4

he utilizado tres de los métodos descritos anteriormente. Cuando usé por primera vez el enhebrado en C++ utilicé funciones de miembro estáticas, luego funciones de amigo y finalmente las bibliotecas BOOST. Actualmente prefiero BOOST. En los últimos años me he convertido en el intolerante BOOST.

BOOST es a C++ como CPAN a Perl. :)

Answer 5

La biblioteca de impulso proporciona un mecanismo de copia, que ayuda a transferir la información del objeto al nuevo hilo. En el otro ejemplo de boost, boost :: bind se copiará con un puntero, que también se copiará. Por lo tanto, tendrá que cuidar la validez de su objeto para evitar un puntero colgante. Si implementa el operador() y proporciona un constructor de copia en su lugar y pasa el objeto directamente, no tiene que preocuparse por ello.

Una solución mucho mejor, lo que evita un montón de problemas:

#include <boost/thread.hpp> 

class MyClass { 
public: 
     MyClass(int i); 
     MyClass(const MyClass& myClass); // Copy-Constructor 
     void operator()() const;   // entry point for the new thread 

     virtual void doSomething();  // Now you can use virtual functions 

private: 
     int i;       // and also fields very easily 
}; 

---

MyClass clazz(1); 
// Passing the object directly will create a copy internally 
// Now you don't have to worry about the validity of the clazz object above 
// after starting the other thread 
// The operator() will be executed for the new thread. 
boost::thread thread(clazz);    // create the object on the stack 

El otro ejemplo impulso crea el objeto hilo en el montón, aunque no hay un sentido hacerlo.