Std :: Mutex mit RAII, aber fertig und im Hintergrund Thread

Question

Ich habe eine Funktion für gelegentlich ein Frame von GigE-Kamera, und will es schnell zurück. Das Standardverfahren ist wie folgt:

// ... 
camera.StartCapture(); 
Image img=camera.GetNextFrame(); 
camera.StopCapture(); // <-- takes a few secs 
return img; 

Return Daten bereit sind nach GetNextFrame() und StopCapture() ist ziemlich langsam; Daher möchte ich so schnell wie möglich img zurückgeben und einen Hintergrund-Thread spawnen, um StopCapture() zu tun. In dem (unwahrscheinlichen) Fall, dass die Akquisition erneut gestartet wird, möchte ich den Zugriff durch einen Mutex schützen. Es gibt Orte, an denen Ausnahmen ausgelöst werden können. Daher entscheide ich mich für eine RAII-Stil-Sperre, die beim Verlassen des Bereichs freigegeben wird. Gleichzeitig muss ich die Sperre in den Hintergrund Thread übertragen. So etwas wie dieser (Pseudo-Code):

class CamIface{ 
    std::mutex mutex; 
    CameraHw camera; 
public: 
    Image acquire(){ 
     std::unique_lock<std::mutex> lock(mutex); // waits for cleanup after the previous call to finish 
     camera.StartCapture(); 
     Image img=camera.GetNextFrame(); 
     std::thread bg([&]{ 
     camera.StopCapture(); // takes a long time 
     lock.release(); // release the lock here, somehow 
     }); 
     bg.detach(); 
     return img; 
     // do not destroy&release lock here, do it in the bg thread 
    }; 

}; 

Wie kann ich das Schloss vom Anrufer mit dem Hintergrund-Thread hervorgebracht? Oder gibt es einen besseren Weg, damit umzugehen?

EDIT: Ausreichende Lebensdauer von CamIface Instanz ist sichergestellt, bitte nehmen Sie an, es existiert für immer.

Answer 1

Die Tatsache, dass dies schwer zu tun ist, sollte darauf hindeuten, dass Ihr Design seltsam asymmetrisch ist. Setzen Sie stattdessen die gesamte Interaktion der Kamera in den Hintergrund-Thread mit allen Mutex-Operationen aus diesem Thread. Stellen Sie sich den Kamera-Thread als Besitzer der Kamera-Ressource und des entsprechenden Mutex vor.

Dann übergeben Sie die erfaßten Rahmen über die Threadgrenze mit einer std :: future oder anderen Synchronisation wie eine gleichzeitige Warteschlange. Sie könnten von hier aus den Hintergrundfaden persistent machen. Beachten Sie, dass dies nicht bedeutet, dass das Capture die ganze Zeit laufen muss, es könnte nur die Thread-Verwaltung erleichtern: Wenn das Kamera-Objekt den Thread besitzt, kann der Destruktor es zum Beenden veranlassen, dann join().

Answer 2

Verschieben Sie den std :: unique_lock in den Hintergrundthread.

Answer 3

Aktualisierte Antwort: @Revolver_Ocelot ist richtig, dass meine Antwort unbestimmte Verhalten fördert, die ich vermeiden möchte.

Also lass mich die einfache Implementierung Semaphore verwenden, um von this SO Answer

#include <mutex> 
#include <thread> 
#include <condition_variable> 

class Semaphore { 
public: 
    Semaphore (int count_ = 0) 
     : count(count_) {} 

    inline void notify() 
    { 
     std::unique_lock<std::mutex> lock(mtx); 
     count++; 
     cv.notify_one(); 
    } 

    inline void wait() 
    { 
     std::unique_lock<std::mutex> lock(mtx); 

     while(count == 0){ 
      cv.wait(lock); 
     } 
     count--; 
    } 

private: 
    std::mutex mtx; 
    std::condition_variable cv; 
    int count; 
}; 


class SemGuard 
{ 
    Semaphore* sem; 
public: 
    SemGuard(Semaphore& semaphore) : sem(&semaphore) 
    { 
     sem->wait(); 
    } 
    ~SemGuard() 
    { 
     if (sem)sem->notify(); 
    } 
    SemGuard(const SemGuard& other) = delete; 
    SemGuard& operator=(const SemGuard& other) = delete; 
    SemGuard(SemGuard&& other) : sem(other.sem) 
    { 
     other.sem = nullptr; 
    } 
    SemGuard& operator=(SemGuard&& other) 
    { 
     if (sem)sem->notify(); 
     sem = other.sem; 
     other.sem = nullptr; 
     return *this; 
    } 
}; 

class CamIface{ 
    Semaphore sem; 
    CameraHw camera; 
public: 
    CamIface() : sem(1){} 
    Image acquire(){ 
     SemGuard guard(sem); 
     camera.StartCapture(); 
     Image img=camera.GetNextFrame(); 
     std::thread bg([&](SemGuard guard){ 
     camera.StopCapture(); // takes a long time 
     }, std::move(guard)); 
     bg.detach(); 
     return img; 
    }; 

}; 

Alter Antwort: Genau wie PanicSheep sagte, den Mutex in das Gewinde bewegen. Zum Beispiel wie folgt aus:

std::mutex mut; 

void func() 
{ 
    std::unique_lock<std::mutex> lock(mut); 
    std::thread bg([&](std::unique_lock<std::mutex> lock) 
    { 
     camera.StopCapture(); // takes a long time 
    },std::move(lock)); 
    bg.detach(); 
} 

auch nur zu bemerken, tun dies nicht:

std::thread bg([&]() 
{ 
    std::unique_lock<std::mutex> local_lock = std::move(lock); 
    camera.StopCapture(); // takes a long time 
    local_lock.release(); // release the lock here, somehow 
}); 

Weil Sie den Faden Inbetriebnahme und den Funktionsumfang Endung sind Rennen.

Answer 4

Sie können sowohl mutex als auch condition_variable verwenden, um die Synchronisation durchzuführen. Außerdem ist es gefährlich, den Hintergrund-Thread zu trennen, da der Thread möglicherweise noch läuft, während das CamIface-Objekt zerstört wurde.