等待異步操作

Question

我想實現一種機制，允許我阻止程序流程，直到異步操作完成。 （主要是在單元測試中不存在消息循環中使用。）

我的代碼創建一個線程和等待線程內部的狀況通知：

#include <chrono> 
#include <condition_variable> 
#include <iostream> 
#include <memory> 
#include <mutex> 
#include <stdexcept> 
#include <thread> 

struct Blocker { 
    Blocker() : 
     wait_thread([this]() { 
      std::mutex mtx; 
      std::unique_lock<std::mutex> lck(mtx);    
      cond.wait(lck); 
     }) 
    { 
    } 

    void wait() { wait_thread.join(); } 

    void notify() { cond.notify_one(); } 

    std::condition_variable cond;  
    std::thread wait_thread; 
}; 

template<typename Callback> 
void async_operation(const Callback & cb) { cb(); } 

int main() { 
    Blocker b; 
    async_operation([&](){ b.notify(); }); 
    b.wait(); 
} 

的問題是，它通常死鎖，因爲在線程開始之前調用notify。我應該如何解決這個問題？

Answer 1

#include <mutex> 
#include <condition_variable> 

struct blocker 
{ 
    blocker() : done (false) {} 

    void 
    notify() 
    { 
    std::unique_lock<std::mutex> lock (m); 
    done = true; 
    c.notify_all(); 
    } 

    void 
    wait() 
    { 
    std::unique_lock<std::mutex> lock (m); 
    while (!done) 
     c.wait (lock); 
    } 

    bool done; 
    std::mutex m; 
    std::condition_variable c; 
};