C++ std :: thread di una funzione membro

Question

Sto provando a programmare un server della riga di comando che riceverebbe informazioni da una porta seriale, analizzarlo e registrarlo in un oggetto interno.

Quindi, su richiesta di un cliente, il server restituisce le informazioni richieste.

Quello che voglio fare è mettere le parti del parser del ricevitore & in un thread separato per far funzionare il server lungo il lato, senza interferire con la raccolta dei dati.

#include <iostream> 
#include <thread> 

class exampleClass{ 
    std::thread *processThread; 

    public void completeProcess(){ 
     while(1){ 
      processStep1(); 
      if (verification()){processStep2()} 
     } 
    }; 

    void processStep1(){...}; 
    void processStep2(){...}; 
    bool verification(){...}; 
    void runThreaded(); 
} // End example class definition 

// The idea being that this thread runs independently 
// until I call the object's destructor 

exampleClass::runThreaded(){ 
    std::thread processThread(&exampleClass::completeProcess, this); 
} // Unfortunately The program ends up crashing here with CIGARET 

Answer 1

Si esegue un locale filo all'interno di una funzione membro. È necessario unire o staccarlo e, dal momento che è locale, è necessario fare questo in funzione stessa:

exampleClass::runThreaded() 
{ 
    std::thread processThread(&exampleClass::completeProcess, this); 
    // more stuff 
    processThread.join(); 
} // 

sto indovinando cosa si vuole veramente è quello di lanciare una discussione membro di dati invece di lanciare un uno locale. Se lo fai, devi ancora unirlo da qualche parte, per esempio nel distruttore. In questo caso, il metodo dovrebbe essere

exampleClass::runThreaded() 
{ 
    processThread = std::thread(&exampleClass::completeProcess, this); 
} 

e il distruttore

exampleClass::~exampleClass() 
{ 
    processThread.join(); 
} 

e processThread dovrebbe essere un std::thread, non un puntatore a uno.

Solo una nota sul design: se si deve avere un metodo runThreaded che agisce su un membro di dati del thread, si deve fare molta attenzione a non chiamarlo più di una volta prima che il thread venga unito. Potrebbe essere più sensato avviare il thread nel costruttore e aggiungerlo al distruttore.

Answer 2

L'oggetto filo è in pila e verrà distrutto alla fine della funzione. Thread object destroyer chiama std::terminate se il thread è ancora in esecuzione, come nel tuo caso. Vedi here.