wer kennt sich mit boost threads aus?

Ich würde gerne boost threads in meiner Applikation verwenden. Nur habe ich ein kleines Problem. Ich möchte in einer Klasse den Thread als membervariable (evtl. als shared_ptr) erzeugen. Dieser soll von außerhalb (aus einer anderen klasse) beendet (also angehalten) und neu gestartet werden.

Angenommen ich habe einen boost::thread als shared pointer m_pthread:
Könnte es hier ein Problem geben?

void thread_function()
{
    while(!m_bStop)
    {
    }
}

void startThread()
{
    if(!m_pthread)
    {
        m_bStop = false;
        m_pthread(new boost::thread(thread_function)
    }
}

void stopThread()
{
    m_bStop = true;
    m_pthread->join()
}

Ich bin mir in einigen Dingen unsicher:
1. Ist das Starten des threads und das Stoppen richtig umgesetzt?
2. Wie stellt man fest, ob ein thread bereits erstellt ist?
3. Kann ich davon ausgehen, dass der heap nach dem join() und dem return aus der while schleife aufgeräumt ist?
3. Gibt es sonst noch Probleme, die euch einfallen?
4. Machen Shared Pointer hier überhaupt Sinn???

Vielen Dank Euch und noch einen schönen Abend!

Ansonsten:
Ich würde nicht while(!stop) , sondern while(running) benutzen.

1. startThread() wird so nicht kompilieren, stopThread() ist so okay.
2. Am Besten gar nicht. Du kannst boost::thread direkt als Member Deiner Klasse benutzen. Wenn Du wissen willst, ob eine Funktion im Threadobjekt aktiv ist, kannst Du z.B. thread::joinable() befragen.
3. Wovon soll der Heap geräumt werden? Vom Threadobjekt? Siehe Punk 2.
4. Nicht für diesen Codeschnippsel.
5. Nein.

class MyClass
{
   HANDLE StopEvent_;

public:
   MyClass()
   {
      StopEvent_ = CreateEvent( 0,      // Security Attributes: use default
                                TRUE,   // manual reset
                                FALSE,  // initial state
                                0 );    // Name
   }

   ~MyClass()
   {
      if( StopEvent_ )
      {
         CloseHandle( StopEvent_ );
      }
   }

   void thread_function()
   {
      // Schleife durchlaufen, solange das Stopp Event nicht gesetzt ist
      while( WaitObject( StopEvent_, 0 ) != WAIT_OBJECT_0)
      {
      }
   }

   void start_thread()
   {
      if( StopEvent_ )
      {
         // Stopp Event zurücksetzen
         ResetEvent( StopEvent_ );
         ...
      }
   }

   void stop_thread()
   {
      if( StopEvent_ )
      {
         // Stopp Event setzen
         SetEvent( StopEvent_ );
         ...
      }
   }

private:
  // Kopien verbieten
  MyClass( const MyClass& );
  MyClass& operator=( const MyClass& );
};

Da das Setzen/Lesen einer Variablen nicht unbedingt atomar sein muss...

Und das ist für die Run-Condition genau weshalb ein Problem? Vor allem, weil join() als Barriere fungiert.

DocShoe schrieb:

Da das Setzen/Lesen einer Variablen nicht unbedingt atomar sein muss...

Und das ist für die Run-Condition genau weshalb ein Problem? Vor allem, weil join() als Barriere fungiert.

Kenn´ ich den ganzen Code der Thread Klasse? Vielleicht gibt es ja diese Methode:

bool is_running() const
{
   return !m_bStop;
}

Damit lässt sich ein Fall konstruieren, in dem der Thread noch läuft, sich selbst aber als angehalten meldet.

eine Zwischenfrage sei mir gestattet...

was bedeutet denn "atomare Änderung"? Kann mir grad nichts darunter vorstellen...

Danke euch

Gruß
Jodi

was bedeutet denn "atomare Änderung"? Kann mir grad nichts darunter vorstellen...

Das ist eine Änderung, welche komplett geschieht, ohne dass sie unterbrochen wird. Oftmals bestehen Betriebssystemspezifische Funktionen, um solche atomischen Veränderungen zu machen.
z.B findest du unter Windows sehr viele hier (die Interlocked Sachen):
http://msdn.microsoft.com/en-us/library/ms686360(v=VS.85).aspx

Wenn es kompliziertere Sachen sein sollen, dann kommst du um eigene Synchronisation nicht herum (Semaphore, Monitore usw.)