Der beste Weg, einen Faden als Mitglied einer C ++ Klasse zu beginnen?

Question

Ich frage mich, die am besten Art und Weise eine Pthread zu starten, der ein Mitglied einer C ++ Klasse ist? Mein eigener Ansatz folgt als Antwort ...

Answer 1

Normalerweise verwende ich eine statische Memberfunktion der Klasse, und einen Zeiger auf die Klasse, die als void * Parameter verwenden. Diese Funktion kann dann durchführen, entweder Thread-Verarbeitung oder eine andere nicht-statische mit dem Klassenreferenzelement Funktion aufrufen. Diese Funktion kann dann alle Klassenmitglieder ohne umständliche Syntax verweisen.

Answer 2

Dies kann einfach mit Hilfe der Boost-Bibliothek, wie dies getan werden:

#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

Weitere Informationen:

• Diese verwendet eine gewöhnliche Klasse Member-Funktion. Es besteht keine Notwendigkeit fügen Sie zusätzliche statische Elemente, die Ihre Klasse Schnittstelle verwechseln
• Just umfassen boost / thread.hpp in der Quelldatei, in der Sie den Thread starten. Wenn Sie nur mit Boost-Start sind, alles andere dieser großen und einschüchternd Paket ignoriert werden kann.

In C ++ 11 Sie können das gleiche tun, aber ohne Auftrieb

// 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 3

Sie haben es Bootstrap die Lücke mit * Parameter:

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 4

Ich habe drei der oben beschriebenen Methoden verwendet. Als ich in c ersten Threading verwendet ++ habe ich statische Elementfunktionen , dann Freund Funktionen und schließlich die BOOST Bibliotheken . Zur Zeit ziehe ich BOOST. In den letzten paar Jahren habe ich ganz im BOOST bigot werden.

BOOST ist in C ++ als CPAN Perl ist. :)

Answer 5

Die Boost-Bibliothek stellt einen Kopiermechanismus, die Objektinformationen übertragen hilft zu dem neuen Thread. Im anderen Anhebungs Beispiel boost :: bind wird mit einem Zeiger kopiert werden, die ebenfalls nur kopiert. Sie müssen also für die Gültigkeit des Objekts kümmern einen baumelnden Zeiger zu verhindern. Wenn Sie den Operator () implementieren und einen Kopierkonstruktor stattdessen liefern und das Objekt direkt übergeben, müssen Sie sich darüber nicht.

Eine viel schönere Lösung, die eine Menge Ärger verhindert:

#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

Das andere Anhebungs Beispiel wird das Thread-Objekt auf dem Heap, obwohl es keinen Sinn, es zu tun ist.