提升异步TCP服务器写入错误

Question

我有一个问题，我有一个客户端和服务器之间的TCP连接，当客户端初始化时，他发送一条消息到服务器和服务器回答一个欢迎消息。

所有这一切都在本地网络上正常工作。

所以我的问题是，我使用async_write和async_read（因为我需要我的服务器是异步的） 我的客户端发送消息到服务器，服务器看到它并回答，但我的客户端从来没有得到欢迎消息。

否则，当我关闭我的服务器时，客户端收到欢迎消息。

这里是我的服务器代码：

的main.cpp

int main() 
{ 
    try 
    { 
    boost::asio::io_service io_service; 

    tcp_server server(io_service, 7171); 
    io_service.run(); 
} 
catch (std::exception& e) 
{ 
    std::cerr << e.what() << std::endl; 
} 

return 0; 
} 

tcp_server

class tcp_server 
{ 
    public: 
tcp_server(boost::asio::io_service& io_service, int port) // (1)                                            
    : m_acceptor(io_service, tcp::endpoint(tcp::v4(), port)) 
    { 
     std::cout << "Port : " << port << std::endl; 
     start_accept(); 
    } 

private: 

    void start_accept() 
    { 
    tcp_connection::pointer new_connection = tcp_connection::create(m_acceptor.io_service()); 

    m_acceptor.async_accept(new_connection->socket(), 
          boost::bind(&tcp_server::handle_accept, this, new_connection, 
        boost::asio::placeholders::error)); 
    } 

    void handle_accept(tcp_connection::pointer new_connection, const boost::system::error_code& error) // (4)                                 
    { 
    if (!error) 
     { 
     std::cout << "Get one client!" << std::endl; 
     new_connection->start(); 
     start_accept(); // (5)                                                    
     } 
    } 


    tcp::acceptor m_acceptor; 
}; 

tcp_connection

class tcp_connection : public boost::enable_shared_from_this<tcp_connection> 
{ 
public: 
    typedef boost::shared_ptr<tcp_connection> pointer; 

    static pointer create(boost::asio::io_service& ios) 
    { 
    pointer new_connection(new tcp_connection(ios)); 
    return new_connection; 
    } 

    tcp::socket& socket() 
    { 
     return m_socket; 
    } 

    void do_read() // (1)                                                      
    { 
    boost::asio::async_read(m_socket, boost::asio::buffer(m_buffer), // (3)                                         
          boost::bind(&tcp_connection::handle_read, shared_from_this(), 
             boost::asio::placeholders::error) 
          ); 
    } 


    void start() 
    { 
    m_message = "Welcome on the server \n"; 

    boost::asio::async_write(m_socket, boost::asio::buffer(m_message), 
          boost::bind(&tcp_connection::handle_write, shared_from_this(), 
             boost::asio::placeholders::error) 
          ); 
    } 
private: 
tcp_connection(boost::asio::io_service& io_service) 
    : m_socket(io_service) 
     { } 

    void handle_write(const boost::system::error_code& error) 
    { 
    std::cout << "handle_write : "<< m_message << std::endl; 
    if (!error) 
     do_read(); // (2)                                                      
    else 
     std::cout << error.message() << std::endl; 
    } 

    void handle_read(const boost::system::error_code& error) // (6)                                            
    { 
    std::cout << "handle read" << m_buffer.data() <<std::endl; 
    if (!error) 
     do_read(); 
    else 
     close(); 
    } 

void close() // (7)                                                       
    { 
    m_socket.close(); 
    } 

    tcp::socket m_socket; 
    std::string m_message; 
    boost::array<char, 128> m_buffer; 
}; 

我不明白为什么？ 我该如何避免这种情况？

Answer 1

请的async_read该手册：

此功能用于从流读异步一定数量的数据的字节 的。函数调用总是立即返回。 异步操作将继续，直到出现以下 条件之一为真：

• 所提供的缓冲器满了。也就是说，传输的字节数等于缓冲区大小的总和。
• An error occurred。

在你的情况下，两个条件都不满足，直到对方关闭套接字为止。

您应该使用async_read_some代替（或async_read_until，但它可能会更复杂一点）。