Question

Is I am looking at writing a multithreaded tcp server using boost ASIO. I have read through the tutorials and had a look at some of the examples and just want to check that my understanding is correct.

The server will accept connections then service requests from multiple clients.

My understanding is as follows:

1. The server uses “a single io_service and a thread pool calling io_service::run()“
2. All threads call io_service::run().
3. The calls to io_service::run() are not within a strand, ergo completion handlers can run simultaneously.
4. When a request arrives one of the threads is chosen, its read handler will be called
5. Another request may arrive,starting the read handler on a second thread
6. When one of the threads has finished handling the request it calls async_write, from within a strand
7. Another thread also finishes processing its request, it also calls async_write, from within a strand
8. The writes to the io_service are serialised via the strand, ergo they are thread safe.
9. When the write operation completes the thread calls async_read()
10. This call is not protected by a strand and the thread will be used for handling requests

Is my understanding correct? Is this solution vulnerable to race conditions?

Answer 1

As Sam miller said, your assumptions are quite correct.

However I would like to point out an issue that you may have not spotted.

It is right that strands will serialize async_write(s) and therefore there will be thread safe.
But the issue is not here, async_write is by itself thread safe if not used on the same socket. And strands will not help here since you should not interleave async_write on the same socket.

Strands will not wait the previous async_write to finish before calling the next one. you will have to create a structure that async_write only if none is already in action on the socket.