Со времен простейшей формы подъёма. Токен асинхронного завершения операции Asio является функцией обратного вызова, мы можем применить ту же тактику для Asio, что и для нашего гипотетического.AsyncAPIАсинхронные операции.

К счастью, нам это не нужно. Повышаю. Asio использует механизм, с помощью которого абонент может настроить поведение уведомления любой операции асинхронизации. Поэтому мы можем построитьтокен завершения, который при переходе наувеличивается. Asioасинхронизирует работу, запрашивает блокировку вызывающего волокна.

Типичная асинхронная функция Асио может выглядеть примерно так:

template < ..., class CompletionToken >
deduced_return_type
async_something( ... , CompletionToken&& token)
{
    // construct handler_type instance from CompletionToken
    handler_type<CompletionToken, ...>::type handler(token);
    // construct async_result instance from handler_type
    async_result<decltype(handler)> result(handler);
    // ... arrange to call handler on completion ...
    // ... initiate actual I/O operation ...
    return result.get();
}

Мы будем задействовать этот механизм, который основан на специализации Asio’shandler_type<>шаблон дляТокен завершениятипа и подпись конкретного обратного вызова. Остальная часть этого обсуждения будет ссылаться наasync_something()в качестве рассматриваемой функции Asio async.

В реализации, описанной ниже, используются средства более низкого уровня, чемобещаниеибудущее, потому чтообещаниемеханизм плохо взаимодействует сio_service::стоп. Он даетнарушенное обещаниеисключения.

бустер::волокна::асио::выходвыходявляется завершением токена такого рода.доходностьявляется примеромдоходность:

class yield_t {
public:
    yield_t() = default;
    /**
     * @code
     * static yield_t yield;
     * boost::system::error_code myec;
     * func(yield[myec]);
     * @endcode
     * @c yield[myec] returns an instance of @c yield_t whose @c ec_ points
     * to @c myec. The expression @c yield[myec] "binds" @c myec to that
     * (anonymous) @c yield_t instance, instructing @c func() to store any
     * @c error_code it might produce into @c myec rather than throwing @c
     * boost::system::system_error.
     */
    yield_t operator[]( boost::system::error_code & ec) const {
        yield_t tmp;
        tmp.ec_ = & ec;
        return tmp;
    }
//private:
    // ptr to bound error_code instance if any
    boost::system::error_code   *   ec_{ nullptr };
};

на самом деле только заполнитель, способ вызвать повышение. Азио кастомизация. Он может связыватьбустер::система::error_codeдля использования фактическим обработчиком.

доходностьобъявляется как:

// canonical instance
thread_local yield_t yield{};

Настройка Asio осуществляется посредством специализацииboost::asio::handler_type<>дляyield_t:

// Handler type specialisation for fibers::asio::yield.
// When 'yield' is passed as a completion handler which accepts only
// error_code, use yield_handler<void>. yield_handler will take care of the
// error_code one way or another.
template< typename ReturnType >
struct handler_type< fibers::asio::yield_t, ReturnType( boost::system::error_code) >
{ typedef fibers::asio::detail::yield_handler< void >    type; };

(На самом деле вDetail/yield.hppесть четыре различные специализации, по одной для каждой из четырех подписей Asio async callback, которые мы ожидаем.)

Вышеуказанное предписывает Asio использоватьyield_handlerв качестве фактического обработчика для операции асинхронизации, к которойдоходностьпередается. Там’s дженерикyield_handler<T>реализация иyield_handler<пустота>специализация. Начнем с<void>специализация:

// yield_handler<void> is like yield_handler<T> without value_. In fact it's
// just like yield_handler_base.
template<>
class yield_handler< void >: public yield_handler_base {
public:
    explicit yield_handler( yield_t const& y) :
        yield_handler_base{ y } {
    }
    // nullary completion callback
    void operator()() {
        ( * this)( boost::system::error_code() );
    }
    // inherit operator()(error_code) overload from base class
    using yield_handler_base::operator();
};

async_something, проконсультировавшись сhandler_type<>специализацией признаков, представляет собойyield_handler<void>, который будет передан в качестве фактического обратного вызова для операции асинхронизации.yield_handler& #8217;s конструктор принимаетyield_tэкземплярyieldобъект передан функции асинхронизации] и передает его вyield_handler_base:

// This class encapsulates common elements between yield_handler<T> (capturing
// a value to return from asio async function) and yield_handler<void> (no
// such value). See yield_handler<T> and its <void> specialization below. Both
// yield_handler<T> and yield_handler<void> are passed by value through
// various layers of asio functions. In other words, they're potentially
// copied multiple times. So key data such as the yield_completion instance
// must be stored in our async_result<yield_handler<>> specialization, which
// should be instantiated only once.
class yield_handler_base {
public:
    yield_handler_base( yield_t const& y) :
        // capture the context* associated with the running fiber
        ctx_{ boost::fibers::context::active() },
        // capture the passed yield_t
        yt_( y ) {
    }
    // completion callback passing only (error_code)
    void operator()( boost::system::error_code const& ec) {
        BOOST_ASSERT_MSG( ycomp_,
                          "Must inject yield_completion* "
                          "before calling yield_handler_base::operator()()");
        BOOST_ASSERT_MSG( yt_.ec_,
                          "Must inject boost::system::error_code* "
                          "before calling yield_handler_base::operator()()");
        // If originating fiber is busy testing completed_ flag, wait until it
        // has observed (! completed_).
        yield_completion::lock_t lk{ ycomp_->mtx_ };
        // Notify a subsequent yield_completion::wait() call that it need not
        // suspend.
        ycomp_->completed_ = true;
        // set the error_code bound by yield_t
        * yt_.ec_ = ec;
        // If ctx_ is still active, e.g. because the async operation
        // immediately called its callback (this method!) before the asio
        // async function called async_result_base::get(), we must not set it
        // ready.
        if ( fibers::context::active() != ctx_ ) {
            // wake the fiber
            fibers::context::active()->set_ready( ctx_);
        }
    }
//private:
    boost::fibers::context      *   ctx_;
    yield_t                         yt_;
    // We depend on this pointer to yield_completion, which will be injected
    // by async_result.
    yield_completion            *   ycomp_{ nullptr };
};

yield_handler_baseхранит копиюyield_tэкземпляра — который, как показано выше, содержит толькоerror_code*. Он также захватывает контекст* для текущего волокна, вызывая контекст::active().

Вы заметите, чтоyield_handler_baseимеет еще один элемент данныхycomp_, который инициализируется доnullptrего конструктором и #8212; хотя егооператор[]метод опирается наycomp_, являющийся ненулевым. Подробнее об этом в один момент.

Сконструировавyield_handler<void>,async_something[]async_resulthandler_typeтипа: в этом случаеasync_result<250]void. Он передаетyield_handler<void>экземпляр новомуasync_resultэкземпляру.

// Without the need to handle a passed value, our yield_handler<void>
// specialization is just like async_result_base.
template<>
class async_result< boost::fibers::asio::detail::yield_handler< void > > :
    public boost::fibers::asio::detail::async_result_base {
public:
    typedef void type;
    explicit async_result( boost::fibers::asio::detail::yield_handler< void > & h):
        boost::fibers::asio::detail::async_result_base{ h } {
    }
};

Естественно, это приводит нас прямо кasync_result_base:

// Factor out commonality between async_result<yield_handler<T>> and
// async_result<yield_handler<void>>
class async_result_base {
public:
    explicit async_result_base( yield_handler_base & h) {
        // Inject ptr to our yield_completion instance into this
        // yield_handler<>.
        h.ycomp_ = & this->ycomp_;
        // if yield_t didn't bind an error_code, make yield_handler_base's
        // error_code* point to an error_code local to this object so
        // yield_handler_base::operator() can unconditionally store through
        // its error_code*
        if ( ! h.yt_.ec_) {
            h.yt_.ec_ = & ec_;
        }
    }
    void get() {
        // Unless yield_handler_base::operator() has already been called,
        // suspend the calling fiber until that call.
        ycomp_.wait();
        // The only way our own ec_ member could have a non-default value is
        // if our yield_handler did not have a bound error_code AND the
        // completion callback passed a non-default error_code.
        if ( ec_) {
            throw_exception( boost::system::system_error{ ec_ } );
        }
    }
private:
    // If yield_t does not bind an error_code instance, store into here.
    boost::system::error_code       ec_{};
    // async_result_base owns the yield_completion because, unlike
    // yield_handler<>, async_result<> is only instantiated once.
    yield_completion                ycomp_{};
};

Вот какyield_handler_base::ycomp_становится ненулевым:async_result_base& #8217; конструктор вводит указатель обратно в свойyield_completionчлен.

Напомним, что каноническийвыход_tэкземплярвыходинициализирует свойошибку_код*членec_донульприт. Если этот экземпляр передаетсяasync_Something[]по-прежнемуnullptr, копия, хранящаяся вyield_handler_base, также будет иметь нульec_.async_result_base& #8217;s yield_handler_base& #8217;sec_ошибка_codeчлен.

Сейчас сцена установлена.async_something[]инициирует фактическую операцию асинхронизации, организуя ееyield_handler<void>экземпляр по завершении. Let’s говорят, ради аргумента, что фактическая операция асинхронизации’s callback имеет подписьvoiderror_code.

Но так как это’s асинхронная операция, управление возвращается сразу кasync_Something.async_Somethingвызываетasync_result<yield_handler<void>>::получает(]и вернет свое возвращаемое значение.

async_result<yield_handler<void>>::getнаследуетasync_result_base::get.

async_result_base::получить()немедленно вызываетвыход_завершение::ждать().

// Bundle a completion bool flag with a spinlock to protect it.
struct yield_completion {
    typedef fibers::detail::spinlock    mutex_t;
    typedef std::unique_lock< mutex_t > lock_t;
    mutex_t mtx_{};
    bool    completed_{ false };
    void wait() {
        // yield_handler_base::operator()() will set completed_ true and
        // attempt to wake a suspended fiber. It would be Bad if that call
        // happened between our detecting (! completed_) and suspending.
        lock_t lk{ mtx_ };
        // If completed_ is already set, we're done here: don't suspend.
        if ( ! completed_) {
            // suspend(unique_lock<spinlock>) unlocks the lock in the act of
            // resuming another fiber
            fibers::context::active()->suspend( lk);
        }
    }
};

Предполагая, что ожидающая операция асинхронизации еще не завершена,yield_completion::completed_по-прежнему будетложным, аждать[]вызоветконтекст::suspend()на текущем волокне.

Другие волокна теперь будут иметь возможность работать.

Спустя некоторое время асинхронная операция завершается. Он называетyield_handler<void>::оператор()error_codeconst&]с ошибкой_code, указывающей либо на успех, либо на неудачу. Мы и #8217 рассмотрим оба случая.

yield_handler<void>эксплицитно наследуетоператор()error_codeconst&]отyield_handler_base.

yield_handler_base::оператор()error_codeconst&]первые наборыyield_completion::завершено_истинно. Таким образом, еслиasync_что-то()& #8217; операция асинхронизации завершается немедленно & #8212; еслиyield_handler_base::оператор()называется еще до того, какasync_result_base::[]& #8212; вызывающее волокнонеприостанавливается.

Фактическийerror_code, создаваемый операцией асинхронизации, затем хранится через сохраненныйуказатель yield_t::ec_. Еслиasync_Something[]& #8217;s caller используется (например)выходmy_ecдля связывания локальногоerror_codeэкземпляра, фактическое значениеerror_codeсохраняется в переменной caller’. В противном случае он хранится вasync_result_base::ec_.

Если сохраненный контекст волокнаyield_handler_base::ctx_уже не работает, он помечается как готовый к запуску, передавая его в контекст::set_ready(). Затем управление возвращается отyield_handler_base::оператор[]: Обратный звонок закончен.

Со временем это волокно возобновляется. Контроль возвращается из контекста::suspend()вyield_completion::Wait(), который возвращается вasync_result_base::get().

Случай, в которомasync_something[]& #8217; завершение обратного вызова имеет сигнатуруvoid.yield_handler<void>::оператор()вызывает механизм выше с& #8220;успех& #8221;ошибка_code.

Завершение обратного вызова с подписьюvoiderror_code,T(то есть: помимоerror_code, обратный вызов получает некоторый элемент данных) обрабатывается несколько иначе. Для этого вида подписиhandler_type<>::typeуказываетyield_handler<T>(дляT, кромеvoid.

Ayield_handler<T>резервируетзначение_указатель на значение типаT:

// asio uses handler_type<completion token type, signature>::type to decide
// what to instantiate as the actual handler. Below, we specialize
// handler_type< yield_t, ... > to indicate yield_handler<>. So when you pass
// an instance of yield_t as an asio completion token, asio selects
// yield_handler<> as the actual handler class.
template< typename T >
class yield_handler: public yield_handler_base {
public:
    // asio passes the completion token to the handler constructor
    explicit yield_handler( yield_t const& y) :
        yield_handler_base{ y } {
    }
    // completion callback passing only value (T)
    void operator()( T t) {
        // just like callback passing success error_code
        (*this)( boost::system::error_code(), std::move(t) );
    }
    // completion callback passing (error_code, T)
    void operator()( boost::system::error_code const& ec, T t) {
        BOOST_ASSERT_MSG( value_,
                          "Must inject value ptr "
                          "before caling yield_handler<T>::operator()()");
        // move the value to async_result<> instance BEFORE waking up a
        // suspended fiber
        * value_ = std::move( t);
        // forward the call to base-class completion handler
        yield_handler_base::operator()( ec);
    }
//private:
    // pointer to destination for eventual value
    // this must be injected by async_result before operator()() is called
    T                           *   value_{ nullptr };
};

Этот указатель инициализируется доnullptr.

Когдаasync_somethingмгновенноasync_reult<yield_handler<T>>:

// asio constructs an async_result<> instance from the yield_handler specified
// by handler_type<>::type. A particular asio async method constructs the
// yield_handler, constructs this async_result specialization from it, then
// returns the result of calling its get() method.
template< typename T >
class async_result< boost::fibers::asio::detail::yield_handler< T > > :
    public boost::fibers::asio::detail::async_result_base {
public:
    // type returned by get()
    typedef T type;
    explicit async_result( boost::fibers::asio::detail::yield_handler< T > & h) :
        boost::fibers::asio::detail::async_result_base{ h } {
        // Inject ptr to our value_ member into yield_handler<>: result will
        // be stored here.
        h.value_ = & value_;
    }
    // asio async method returns result of calling get()
    type get() {
        boost::fibers::asio::detail::async_result_base::get();
        return std::move( value_);
    }
private:
    type                            value_{};
};

Этоaync_result<>специализация резервирует член типаTдля получения переданного элемента данных и устанавливаетвыход_handler<T>::значение_для указания на его собственный член данных.

async_result<yield_handler<T>>переопределенияполучают. Оверрайд-звонкиasync_result_base::получают(), поэтому вызывающее волокно приостанавливается, как описано выше.

yield_handler<>::оператор[] []error_code,Tсохраняет свое пройденноеTзначение вasync_result<T>>]::значение_.

Затем он передает управлениеyield_handler_base::оператор()error_codeдля борьбы с пробуждением исходного волокна, как описано выше.

Когдаaync_result<yield_handler<T>>::[]возобновляется, он возвращает сохраненноезначение_async_somethingи, в конечном счете,async_something[8217].

Случай обратного вызова подписиvoidобрабатывается, имеяyield_handler<T>:оператор[]Tзадействуютvoidошибку_codeмашины, пройдя& #8220;успех& #8221;ошибку_code.

Приведенный выше исходный код содержится вyield.hppиdetail/yield.hpp.