如何在 C++ 中围绕异步回调创建同步包装器？

Question

我正在使用 C++ 中的 libportal 库来改进对现有应用程序的 Flatpak 支持，我遇到了一个问题，即 libportal 公开的许多 API 都是异步的，但代码库我正在使用的编写方式是假设相关操作是同步的。当然，我可以重构代码以支持异步操作，但这需要对应用程序的代码库进行重大更改，并且对于我需要 libportal 的目的而言，它不会带来明显的好处，主线程被阻塞并不重要.我与一位 libportal 维护者交谈过，他说他对添加我想使用的 API 的同步变体不感兴趣 (xdp_portal_open_file)，而是建议我自己制作一个同步包装器，这最终让我我的问题：

如何在 C++ 中为基于回调的异步函数制作同步包装器？在这种情况下，回调是来自Gio 2.0 的GAsyncReadyCallback。

Answer 1

我使用条件变量为您创建了一个示例。 我没有你的框架，所以我使用 std::async 来模拟异步调用。

这个例子基本上是启动异步调用，让回调在异步函数完成时设置一个信号。然后调用线程将阻塞，直到设置标志（同时不花费任何 CPU 时间）。

#include <chrono>
#include <future>
#include <iostream>
#include <mutex>
#include <condition_variable>
#include <thread>

// use a condition variable, a mutex and a flag to build a synchronization point.
// condition variables are more like a signal between threads then a real variable!
// and are used a lot to do inter-thread signaling, because the avoid busy loops
class synchronization_point_t
{
public:
    void set()
    {
        std::unique_lock<std::mutex> lock{ m_mtx };
        m_flag = true;
        m_cv.notify_all();
    }

    void wait()
    {
        std::unique_lock<std::mutex> lock{ m_mtx };
        m_cv.wait(lock, [&] {return m_flag; });
    }

private:
    std::mutex m_mtx;
    std::condition_variable m_cv;
    bool m_flag{ false };
};

//-----------------------------------------------------------------------------

void callback(void* userdata)
{
    std::cout << "callback setting synchronization point signal\n";
    auto synchronization_point = reinterpret_cast<synchronization_point_t*>(userdata);
    synchronization_point->set();
}

void async_fn(void* userdata)
{
    std::cout << "async_fn starting\n";

    // simulate some work here
    for (std::size_t n = 0; n < 10; ++n)
    {
        std::cout << ".";
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
    std::cout << "\n";

    std::cout << "async_fn calling callback\n";
    callback(userdata);
    std::cout << "async_fn done\n";
}


void fn()
{
    std::cout << "fn() creating a synchronization point\n";
    synchronization_point_t synchronization_point;

    std::cout << "fn() calling the asynchronous variant\n";
    auto future = std::async(std::launch::async, [&]
    {
        async_fn(reinterpret_cast<void*>(&synchronization_point));
    });

    // this will wait until the function has called the callbacks
    std::cout << "fn() waiting for the asynchronous call to complete\n";
    synchronization_point.wait();
    std::cout << "fn() done\n";
}

int main()
{
    std::cout << "main calling synchronous version of fn()\n";
    fn();
    std::cout << "main done\n";
    return 0;
}