给定以下测试程序:

#include <asio.hpp>
#include <cassert>

int main()
{
    asio::io_service ios1, ios2;
    asio::io_service::strand s2(ios2);

    auto test_func = wrap(s2, [&] {
        assert(s2.running_in_this_thread());
    });

    auto wrap_test_func = wrap(ios1, test_func);

    wrap_test_func();

    ios1.run_one();
    ios2.run_one();

}

我的理解是这个程序不应该断言。

wrap_test_func 被包装到 io_service ios1 中。它包装的函数被包装到 strand s2(使用 ios2)。

据我所知，调用 wrap_test_func 应该等同于 dispatch(ios1, test_func) 然后应该在 s2 中分派(dispatch) lambda) .

但是，看起来 wrap 已经打开了内 wrapper 。

这是预期的行为吗？

最佳答案

原来是我的误会

这是 Asio 作者的回复拷贝:

Hi Richard,

Yes this behaviour is deliberate. However, in the networking TS and the latest code on the master branch this facility has been renamed from wrap (which implied adding another layer as you expected) to bind_executor. This function simply imbues the object with an associated executor; if it already had one it is overridden.

If you need true wrapping then you should explicitly wrap your inner handler in an outer function object (or lambda), and have the outer handler dispatch() the inner handler on its "associated executor". As you're writing your own asynchronous operation, I suggest adopting the following pattern (documented in the networking TS as part of the "requirements on asynchronous operations"):

• Ask the handler for its associated executor using get_associated_executor.

• post() the handler to that executor if your operation finishes immediately.

• dispatch() the handler to that executor otherwise.

So (untested code, may require tip of master branch):

    template<class Task, class Handler>
    void async_execute(implementation& impl, Task&& task, Handler&& handler)
    {
        ...

        auto ex = asio::get_associated_executor(handler get_io_context());

        // this is immediate completion, so we use post()

        if (not impl)
        {
            post(ex, [handler = std::forward<Handler>(handler)]() mutable
                 {
                     promise_type promise;
                     promise.set_exception(std::make_exception_ptr(system_error(errors::null_handle)));
                     handler(promise.get_future());
                 });
            return;
        }

        // this is not immediate completion, so we use dispatch()
        // (NOTE: assumes this->post_execute() does not run the task)

        // Optional. Really only needed if your io_context participates in the
        // async operation in some way not shown in this snippet, and not
        // simply as a channel for delivering the handler.
        auto io_work = make_work_guard(get_io_contet());

        auto handler_work = make_work_guard(ex);
        auto impl_ptr = impl.get();
        auto async_handler = [this,
                              ex,
                              impl_ptr,
                              io_work, handler_work,
                              handler = std::forward<Handler>(handler)]
        (detail::long_running_task_op::identifier ident,
         auto future) mutable
        {
            assert(impl_ptr);
            io_work.reset();
            dispatch(ex, [handler = std::move(handler), future = std::move(future)]() mutable
                 {
                     handler(std::move(future));
                 });
            assert(impl_ptr);
            impl_ptr->remove_op(ident);
        };

        ...

        this->post_execute();
    }

Hope this helps.

Cheers, Chris

关于c++ - asio 1.11.0 独立包装不正确......还是我？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/38880676/