18

在 RPC 通信协议中，在调用方法后，我将“完成”消息发送回调用者。由于这些方法是以并发方式调用的，因此包含响应 (a std::string) 的缓冲区需要由互斥锁保护。我想要达到的目标如下：

void connection::send_response()
{
    // block until previous response is sent
    std::unique_lock<std::mutex> locker(response_mutex_);

    // prepare response
    response_ = "foo";

    // send response back to caller. move the unique_lock into the binder
    // to keep the mutex locked until asio is done sending.
    asio::async_write(stream_,
                      asio::const_buffers_1(response_.data(), response_.size()),
                      std::bind(&connection::response_sent, shared_from_this(),
                                _1, _2, std::move(locker))
                      );
}

void connection::response_sent(const boost::system::error_code& err, std::size_t len)
{
    if (err) handle_error(err);
    // the mutex is unlocked when the binder is destroyed
}

但是，这无法编译，因为boost::asio要求处理程序是 CopyConstructible。

通过使用以下共享储物柜类而不是unique_lock：

template <typename Mutex>
class shared_lock
{
public:
    shared_lock(Mutex& m)
    : p_(&m, std::mem_fn(&Mutex::unlock))
    { m.lock(); }

private:
    std::shared_ptr<Mutex> p_;
};

boost::asio不允许仅移动处理程序背后的原因是什么？

4

2 回答 2

13

在 Chris Kohlhoff 回应我提交的错误之前，这里有一个简单的解决方法：

template <typename F>
struct move_wrapper : F
{
    move_wrapper(F&& f) : F(std::move(f)) {}

    move_wrapper(move_wrapper&&) = default;
    move_wrapper& operator=(move_wrapper&&) = default;

    move_wrapper(const move_wrapper&);
    move_wrapper& operator=(const move_wrapper&);
};

template <typename T>
auto move_handler(T&& t) -> move_wrapper<typename std::decay<T>::type>
{
    return std::move(t);
}

包装器声明了一个复制构造函数，欺骗 asio 的机器提交，但从未定义它，因此复制会导致链接错误。

现在终于可以做到这一点了：

std::packaged_task<int()> pt([] {
    std::this_thread::sleep_for(std::chrono::seconds(1));
    return 42;
});
std::future<int> fu = pt.get_future();

boost::asio::io_service io;
io.post(move_handler(pt));
std::thread(&boost::asio::io_service::run, &io).detach();

int result = fu.get();
assert(result == 42);
于 2014-04-06T08:11:29.537 回答
1

Here's a simpler workaround:

shared_ptr<mutex> lock(mutex & m)
{
    m.lock();
    return shared_ptr<mutex>(&m, mem_fn(&mutex::unlock));
}

No need to write custom wrappers.

Referring to Smart Pointer Programming Techniques you can even use:

class shared_lock    {
private:    
    shared_ptr<void> pv;    
public:    
    template<class Mutex> explicit shared_lock(Mutex & m): pv((m.lock(), &m), mem_fn(&Mutex::unlock)) {}
};

shared_lock can now be used as:

shared_lock lock(m);

Note that shared_lock is not templated on the mutex type, thanks to shared_ptr<void>'s ability to hide type information.

It potentially costs more, but it has some thing going for it too (the receiver can take shared_lock and you could pass it an upgradable, shared, unique lock, scope_guard, of basically any BasicLockable or "better"

于 2015-01-30T14:49:11.240 回答