std ::互斥与RAII但在后台线程完成和释放

Question

我有一个偶尔从GigE相机获取帧，并希望它快速返回的功能。标准程序是这样的：GetNextFrame()后

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

返回数据已准备就绪，StopCapture()是相当缓慢;因此，我想尽快返回img，并产生一个后台线程来执行StopCapture()。但是，在收购再次开始的情况下（不太可能），我希望通过互斥体保护访问。有些地方可能会抛出异常，所以我决定使用RAII风格的锁，它将在范围退出时释放。同时，我需要将锁转移到后台线程。像这样的东西（伪码）：

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 
    }; 

}; 

我怎样才能将锁从调用者转移到后台线程产生？或者有更好的方法来处理这个问题吗？

编辑：CamIface的实例有足够的使用寿命，请假设它永远存在。

Answer 1

这很难做到的事实表明您的设计奇怪地不对称。相反，将所有相机交互放置在后台线程中，并使用该线程中的所有互斥操作。将相机线程想象成拥有相机资源和相应的互斥体。

然后通过std :: future或其他同步（如并发队列）在线程边界上传递捕获的帧。你可以从这里考虑使后台线程持久。请注意，这并不意味着捕获必须一直运行，它可能只是简化线程管理：如果相机对象拥有该线程，析构函数可以发信号通知它退出，然后join()它。

Answer 2

将std :: unique_lock移动到后台线程。

Answer 3

已更新回答： @Revolver_Ocelot是正确的，我的答案鼓励未定义的行为，我想避免。

所以让我用简单的信号实现从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; 
    }; 

}; 

老答案： 就像PanicSheep说，移动互斥进入线程。例如像这样：

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(); 
} 

而且，只是一句话，不这样做：

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 
}); 

因为你赛车线程启动和结束的功能范围。

Answer 4

您可以同时使用mutex和condition_variable进行同步。另外分离后台线程也很危险，因为在CamIface对象被破坏的时候线程仍然可以运行。

class CamIface { 
public: 
    CamIface() { 
     background_thread = std::thread(&CamIface::stop, this); 
    } 
    ~CamIface() { 
     if (background_thread.joinable()) { 
      exit = true; 
      cv.notify_all(); 
      background_thread.join(); 
     } 
    } 
    Image acquire() { 
     std::unique_lock<std::mutex> lock(mtx); 
     cv.wait(lock, [this]() { return !this->stopping; }); 
     // acquire your image here... 
     stopping = true; 
     cv.notify_all(); 
     return img; 
    } 
private: 
    void stop() { 
     while (true) { 
      std::unique_lock<std::mutex> lock(mtx); 
      cv.wait(lock, [this]() { return this->stopping || this->exit; }); 

      if (exit) return; // exit if needed. 

      camera.StopCapture(); 
      stopping = false; 
      cv.notify_one(); 
     } 
    } 

    std::mutex mtx; 
    std::condition_variable cv; 
    atomic<bool> stopping = {false}; 
    atomic<bool> exit = {false}; 
    CameraHw camera; 
    std::thread background_thread; 
};