короче говоря, вам нужно создать экземпляр обработчика, например, разместив его в io_service, прежде чем пытаться получить async_result для того, чтобы сохранить корутину в живых.

импульс.Asio предотвращает невозобновляемую корутину от бесконечного приостановления, уничтожая корутин, в результате чего стек корутина разматывается. Объект coroutine будет бросать boost::coroutines::detail::forced_unwind во время его разрушение, вызывающие приостановлено стека. Asio выполняет это by:

• на yield_context CompletionToken поддерживает weak_ptr в сопрограммы.
• когда специализированной handler_type::type обработчик построен, он получает shared_ptr для coroutine через CompletionToken в weak_ptr. Когда обработчик передается как обработчик завершения асинхронных операций, обработчик и его shared_ptr копируются. Когда вызывается обработчик, он возобновляет работу сопрограммы.
• при вызове async_result::get(), специализация сбросит coroutine shared_ptr принадлежит обработчику, который был передан async_result во время конструкции, и после этого дайте корутину.

вот попытка проиллюстрировать выполнение кода. Пути в | укажите активный стек,: указывает на подвешенный стек, а стрелки используются для указания передачи управления:

boost::asio::io_service io_service;
boost::asio::spawn(io_service, &my_timer);
`-- dispatch a coroutine creator
    into the io_service.
io_service.run();
|-- invoke the coroutine entry
|   handler.
|   |-- create coroutine
|   |   (count: 1)
|   |-- start coroutine        ----> my_timer()
:   :                                |-- create handler1 (count: 2)
:   :                                |-- create asnyc_result1(handler1)
:   :                                |-- timer.async_wait(handler)
:   :                                |   |-- create handler2 (count: 3)
:   :                                |   |-- create async_result2(handler2)
:   :                                |   |-- create operation and copy
:   :                                |   |   handler3 (count: 4)
:   :                                |   `-- async_result2.get()
:   :                                |       |-- handler2.reset() (count: 3)
|   `-- return                 <---- |       `-- yield
|       `-- ~entry handler           :
|           (count: 2)               :
|-- io_service has work (the         :
|   async_wait operation)            :
|   ...async wait completes...       :
|-- invoke handler3                  :
|   |-- resume                 ----> |-- async_result1.get()
:   :                                |   |--  handler1.reset() (count: 1)
|   `-- return                 <---- |   `-- yield
|       `-- ~handler3                :       :
|           |  (count: 0)            :       :
|           `-- ~coroutine()   ----> |       `-- throw forced_unwind

исправить эту проблему, handler необходимо скопировать и вызывается через asio_handler_invoke() когда пришло время возобновить работу корутины. Например, следующее сообщение будет содержать обработчик завершения¹ на io_service это вызывает копию handler:

timer.async_wait (handler);

timer.get_io_service().post(
  std::bind([](decltype(handler) handler)
  {
    boost::system::error_code error;
    // Handler must be invoked through asio_handler_invoke hooks
    // to properly synchronize with the coroutine's execution
    // context.
    using boost::asio::asio_handler_invoke;
    asio_handler_invoke(std::bind(handler, error), &handler);
  }, handler)
);
return result.get ();

как показала здесь, С этим дополнительным кодом, выход становится:

my_timer enter
my_timer returns

_{1. Код обработчика завершения, вероятно, может быть немного очищен, но как я отвечал как возобновить импульс.Асио stackful coroutine из другой нити, я заметил, что некоторые компиляторы выбирают неправильный asio_handler_invoke крюк.}