如何等待所有提升的完成:asio的堆栈协同程序？

Question

我正在使用asio :: spawn开始一些协同程序,我想等到所有这些都完成后再做其他工作.怎么做？

控制流程如下:

asio::spawn (io, [] (asio::yield_context yield) {
  ...
  // starting few coroutines
  asio::spawn (yield, [] (asio::yield_context yield2) { ... });
  asio::spawn (yield, [] (asio::yield_context yield2) { ... });
  asio::spawn (yield, [] (asio::yield_context yield2) { ... });
  asio::spawn (yield, [] (asio::yield_context yield2) { ... });

  // now I want to wait for all of them to finish before I do 
  // some other work?
  ...
});

io.run ();

UPDATE

下面是示例代码

#include <boost/asio.hpp>
#include <boost/asio/spawn.hpp>
#include <boost/asio/steady_timer.hpp>
#include <chrono>

#include <iostream>
using namespace std;

int main ()
{
  using namespace boost::asio;

  io_service io;

  spawn (io, [&] (yield_context yield) {
    cout << "main coro starts\n";

    auto lambda = [&] (yield_context yield)
      {
        cout << "in lambda inside subcoroutine - starts\n";
        steady_timer t (io, std::chrono::seconds (1));
        t.async_wait (yield);
        cout << "in lambda inside subcoroutine - finishes\n";
      };

    // starting few coroutines
    spawn (yield, lambda);
    spawn (yield, lambda);

    // now I want to wait for all of them to finish before I do
    // some other work?
    // ???

    cout << "main coro finishes\n";
  });

  io.run ();
}

输出是:

// main coro starts
// in lambda inside subcoroutine - starts
// in lambda inside subcoroutine - starts
// main coro finishes <----
// in lambda inside subcoroutine - finishes
// in lambda inside subcoroutine - finishes

虽然我期待:

// main coro starts
// in lambda inside subcoroutine - starts
// in lambda inside subcoroutine - starts
// in lambda inside subcoroutine - finishes
// in lambda inside subcoroutine - finishes
// main coro finishes

(参见"主要coro饰面"线的地方)

Answer 1

我找到了一种......某种解决方法。

我可以使用无限持续时间的计时器，并从最后一个子协程中取消它。这将唤醒主协程。

科利鲁示例

#include <boost/asio.hpp>
#include <boost/asio/spawn.hpp>
#include <boost/asio/steady_timer.hpp>

#include <iostream>
using namespace std;

int main ()
{
  using namespace boost::asio;

  io_service io;

  spawn (io, [&] (yield_context yield) {
    cout << "main coro starts\n";


    steady_timer rendez_vous (io, steady_timer::clock_type::duration::max ());
    /* volatile */ int counter = 2;


    auto lambda = [&] (yield_context yield)
      {
        cout << "in lambda inside subcoroutine - starts\n";
        steady_timer t (io, boost::chrono::seconds (1));
        t.async_wait (yield);
        cout << "in lambda inside subcoroutine - finishes\n";

        if (--counter == 0)
            rendez_vous.cancel ();
      };

    // starting few coroutines
    spawn (yield, lambda);
    spawn (yield, lambda);

    // now I want to wait for all of them to finish before I do
    // some other work?
    // ???
    boost::system::error_code ignored_ec;
    rendez_vous.async_wait (yield [ignored_ec]);
    // ignore errors here by reason.

    cout << "main coro finishes\n";
  });

  io.run ();
}

坦率地说，我不喜欢这个解决方案，因为它滥用了“计时器”概念和对象，并且可能浪费系统资源。