C++ event processing

Question

Hello. I am using the excellent asio for an asynchronous network client. When handling read (async_read) I am concerned that the method/function handling the data might hang or take too long (the function is supplied by the user of the class).

What is the best way of calling the supplied function and ensuring it won't take too long ?

Thank you for your time.

Answer 1

You could write a wrapper function which launches the given handler in a separate thread and does a timed_join on it. If the timeout reaches, you could throw an exception or do whatever else you want.

Answer 2

There are several examples provided by the boost documentation that describe what you are wanting to accomplish.

http://www.boost.org/doc/libs/1_44_0/doc/html/boost_asio/examples.html

look under the section titled timeouts for the examples.

Answer 3

Unless the work your handler does is very short-lived (unlikely in a real world application), you are going to want a producer/consumer queue to hand off the received data from your I/O thread(s) to your worker thraed(s) for further processing, so you can return from your handler asap.

There is a primer on producer/consumer using Boost.Thread here - written by the current author of the Boost Threads library, as a bonus.

Answer 4

An extra thread(s) to handle the callback processing is a good idea. As mentioned above, having your callback push a message onto a thread safe queue and another thread consuming/processing the message works great.

Another threading scenario that may work for you is to just start additional threads on the io_service. These additional threads will make it possible to process several handlers at the same time.

const int max_threads = 5;
boost::asio::io_service ios;
boost::thread_group thread_group;

for (int i = 0 ; i < max_threads; ++i)
  thread_group.create_thread( boost::bind(&boost::asio::io_service::run, boost::ref(ios)) );

The correct solution really depends on what the application is doing. If this is a TCP connection and the messages need to be processed in sequential order consider using the producer/consumer queue. If the messages are independent of each other and do not require that they are processed in order then this approach is suitable as well.

If its a UDP connection then all bets are off anyway because the ordering of the received messages is not guaranteed.