Vermeiden confilicts in aufeinanderfolgenden Fäden

Question

Ich brauche eine Schleife der folgenden Art und Weise zu erstellen:

while (!end) { 

    // some modifications to myPar 

    boost::thread t(&myClass::myFun, this, myPar); 

    // other operations 
} 

Bei jeder Iteration möchte ich den Thread nur starten, wenn der eine in der vorherigen Iteration genannt beendet hat. Aber ich möchte nicht, dass die "anderen Operationen" darauf warten. Gibt es eine Möglichkeit, dies zu tun?

Answer 1

ich mit boost :: thread nicht gespielt, aber so etwas wie dies sollte

boost::thread t; 
while (!end) { 

    // some modifications to myPar 
    if(t.joinable()) 
      t.join(); 

    t = {&myClass::myFun, this, myPar}; 

    // other operations 
} 

EDIT in Bezug auf Kommentare arbeiten Sie so etwas wie dieses

class Worker 
{ 

public: 
    void addParams(const SomeParams &params) 
    { 
     paramsQueue.push(params); 
    } 

    void start() 
    { 
     auto loop = [this]() 
     { 
      while(!interrupted) 
      { 
       //BLOCK HERE if queue is empty 

       auto params = paramsQueue.pop(); 

       //do something with params 
      } 
     }; 

     thread = {loop}; 
    } 

    void interrupt() 
    { 
     interrupted = true; 
    } 

private: 
    boost::thread thead; 
    std::queue<SomeParams> paramsQueue; 
    bool interrupted = false; 
}; 


... 

Worker worker; 

worker.start(); 

while (!end) { 

    // some modifications to myPar 

    worker.addParams(params); 

    // other operations 
} 

Aber denken Sie daran tun können, implementieren blockieren, weil Sie UB haben, wenn Sie versuchen werden, in der leeren Warteschlange zu lesen. Auch Push und Pop aus der Warteschlange müssen threadsicher sein.