15.9Concurrent Use of Coroutines

Here, we first create a thread pool of the type CoroPool for all coroutines using the interface CoroPoolTask:

CoroPool pool{4};

Then, we call the coroutine, which starts the coroutine lazily and returns the interface, and hand the interface over to the pool to take control of the coroutine:

CoroPoolTask t1 = runAsync("1"); pool.runTask(std::move(t1));

We use (and have to use) move semantics for the coroutine interface, because runTask() requires to pass an rvalue to be able to take over the ownership of the coroutine (after the call t1 no longer has it).

We could also do that in one statement:

pool.runTask(runAsync("1"));

Before we end the program. the pool blocks until all scheduled coroutines have been processed:

pool.waitUntilNoCoros();

When we run this program, we get something like the following output (the thread IDs vary):

****main() on thread 0x80000008 runTask(runAsync(1))

****waitUntilNoCoros()

**** main() done

As you can see, different threads are used:

•The coroutine runAsync() is started on a different thread to main()

•The coroutine print() called from there is started on a third thread

•The second call of coroutine print() called from there is started on a fourth thread

However, runAsync() changes threads with each call of print(). By using co_await, these calls suspend runAsync() and call print() on a different thread (as we will see, the suspension schedules the called coroutine in the pool). At the end of print(), the calling coroutine runAsync() resumes on the same thread in which print() was running.

As a variation, we could also start and schedule coroutine runAsync() four times: coro/coroasync2.cpp

#include "coroasync.hpp" #include <iostream>

int main()

{

****main() on thread 17308 runTask(runAsync(1)) runTask(runAsync(2)) runTask(runAsync(3)) runTask(runAsync(4))

****waitUntilNoCoros()