提升异步其他客户端

Question

I currently working on a async rest client using boost::asio::io_service . I am trying to make the client as a some kind of service for a bigger program. The idea is that the client will execute async http requests to a rest API, independently from the thread running the main program. So inside in the client will be another thread waiting for a request to send. To pass the requests to the client I am using a io_service and io_service::work initialized with the io_service . I almost reused the example given on this tutorial - logger_service.hpp . My problem is that when in the example they post a work to the service, the called handler is a simple function. In my case as I am making async calls like this (I have done the necessary to run all the instancies of the following objects and some more in a way to be able to establish the network connection):

boost::asio::io_service io_service_;
boost::asio::io_service::work work_(io_service_); //to prevent the io_service::run() to return when there is no more work to do
boost::asio::ssl::stream<boost::asio::ip::tcp::socket> socket_(io_service_);

In the main program I am doing the following calls:

client.Connect();
...
client.Send();
client.Send();
...

Some client's pseudo code:

void MyClass::Send()
{
...
io_service_.post(boost::bind(&MyClass::AsyncSend, this);
...
}


void MyClass::AsyncSend()
{
...
boost::io_service::asio::async_write(socket, streamOutBuffer, boost::bind(&MyClass::handle_send, this)); 
...
}

void MyClass::handle_send()
{
boost::io_service::asio::async_read(socket, streamInBuffer, boost::bind(&MyClass::handle_read, this));
}

void MyClass::handle_read()
{
//    ....treatment for the received data...
   if(allDataIsReceived)    
      FireAnEvent(ReceivedData);
   else
    boost::io_service::asio::async_read(socket, streamInBuffer, boost::bind(&MyClass::handle_read, this));
}

As it is described in the documentation the ' post ' method requests the io_service to invoke the given handler and return immediately . My question is, will be the nested handlers, for example the ::handle_send in the AsyncSend , called just after (when the http response is ready) when post() is used? Or the handlers will be called in another order different from the one defined by the order of post() calls ? I am asking this question because when I call only once client->Send() the client seems to "work fine". But when I make 2 consecutive calls, as in the example above, the client cannot finish the first call and than goes to execute the second one and after some chaotic executions at the end the 2 operations fail.

Is there any way to do what I'm describing execute the whole async chain before the execution of another one.

I hope, I am clear enough with my description :)

Answer 1

hello Blacktempel,

Thank you for the given comment and the idea but however I am working on a project which demands using asynchronous calls. In fact, as I am newbie with Boost my question and the example I gave weren't right in the part of the 'handle_read' function. I add now a few lines in the example in a way to be more clear in what situation I am (was). In fact in many examples, may be all of them, who are treating the theme how to create an async client are very basic... All they just show how to chain the different handlers and the data treatment when the 'handle_read' is called is always something like "print some data on the screen" inside of this same read handler. Which, I think, is completely wrong when compared to real world problems! No one will just print data and finish the execution of her program...! Usually once the data is received there is another treatment that has to start, for example FireAnEvent(). Influenced by the bad examples, I have done this 'FireAnEvent' inside the read handler, which, obviously is completely wrong! It is bad to do that because making the things like that, the "handle_read" might never exit or exit too late. If this handler does not finish, the io_service loop will not finish too. And if your further treatment demands once again to your async client to do something, this will start/restart (I am not sure about the details) the io_service loop. In my case I was doing several calls to the async client in this way. At the end I saw how the io_service was always started but never ended. Even after the whole treatment was ended, I never saw the io_service to stop. So finally I let my async client to fill some global variable with the received data inside the handle_read and not to call directly another function like FireAnEvent. And I moved the call of this function (FireAnEvent) just after the io_service.run(). And it worked because after the end of the run() method I know that the loop is completely finished! I hope my answer will help people :)