2

我有以下多态接口：

struct service
{
    virtual void connect(std::function<void>(bool) cb);
      // Invoke 'cb' with 'true' on connection success, 'false' otherwise.

    virtual ~service() { }
};

的一些实现service是同步的：

struct synchronous_service : service
{
    void connect(std::function<void>(bool) cb) override
    {
        cb(true);
    }
};

其他是异步的：

struct asynchronous_service : service
{
    void connect(std::function<void>(bool) cb) override
    {
        _thread_pool.post([this, cb]{ cb(true); });
    }
};

我需要创建一个service包装器，它service本身就是一个。这需要是线程安全的并在 a 下保持一些状态mutex：

struct wrapped_service : service 
{
    state                    _state;
    std::mutex               _mutex;
    std::unique_ptr<service> _underlying;

    void connect(std::function<void>(bool) cb) override
    {
        std::lock_guard<decltype(_mutex)> guard{_mutex};
        // update `_state`

        _underlying->connect([this, cb]
        {
            std::lock_guard<decltype(_mutex)> guard{_mutex};
            // update `_state`
            cb(true);
        });

        // update `_state`
    }
}

如果_underlying->connect调用始终是异步的，则std::mutex可以正常工作。但是，在_underlying->connect同步的情况下，程序将冻结。

这可以通过使用std::recursive_mutexinstead of来解决std::mutex，但众所周知这是代码异味。

这是一个有效的用例std::recursive_mutex吗？

还是设计有缺陷？请注意，我无法控制service界面。

4

1 回答 1

0

回调有两种模式：立即和延迟。这要求客户端准备好立即回调并重新进入。这使客户端实现复杂化。如果您使回调始终被延迟，则无需客户端重新进入。

于 2019-02-01T14:29:36.837 回答