Hey, On 21 January 2017 at 13:09, Adam Zegelin wrote:

Hi,

Another alternative I can think of is that the function that schedules all the async_writes knows ahead-of-time the number of reads that need to be completed. Each async_read() handler would put its results into a shared list and then, if the list's size is equal to the expected number of results, fires the "completion" handler. While easy enough to implement, this seems fraught with issues. If there is more than one thread calling io_service.run(), then access to the shared list has to be synchronised. Also, it doesn't seem very generic — I have a number of places where this write n, read n, execute (or is it map, reduce?) pattern needs to happen, and I'd prefer a solution that was write one, worked everywhere.

​I would definitely go with this approach​. It's by far the simplest and to me it seems to match an asynchronous philosophy pretty well. You can use an io_service::strand [1] to synchronize access to the shared list easily without explicit locking. For best performance you should probably keep the handler running in the strand as short as possible and keep the parts of the read handler that don't access shared state outside of the strand. [1] http://www.boost.org/doc/libs/1_63_0/doc/html/boost_asio/reference.html#boos... ​Hope ​this helps, -- Maarten

2017-01-21 20:09 GMT+08:00 Adam Zegelin :

Hi,

I'm writing a boost::asio application that communicates with multiple streams. I'd like to write data to these streams then wait for everyone to reply before performing computation on the resulting data.

What is the best way to implement this?

The route I've ventured down involves me calling async_write() on each stream, with the callback hander executing async_read(). But this where I'm stuck. What is the best way to execute one final hander once all read operations have completed?

Coroutine may help. Take a simple echo-server for example: https://github.com/jamboree/co2#asio-echo-server In your case, you just need to keep the tasks in a list and 'await' for them to complete.

On 22/01/2017 01:09, Adam Zegelin wrote:

One solution I've found, though it feels "un-asio" is to pass the use_future option as the hander for the reads. The result is futures for each read, which I can then place into a list<future>, and have an additional io_service.post()'ed handler call get() on these futures. The only issue with this is that I must call io_service.run() from more than one thread, since the handler calling get() blocks — otherwise I can potentially deadlock the whole application.

You can pass a collection of futures to when_all(), which returns a future that will be completed when all the parameters are completed. You can then use future.then() to attach a continuation to this future which will execute when that occurs.