無限執行boost asio async_read_until

Question

我在boost :: asio :: async_read_until之后面對周期性的無限等待處理程序調用。 這在兩種情況下出現：

• 在服務器上，盡管調用了客戶端boost :: asio :: async_write處理程序沒有任何錯誤。 僅當客戶端在服務器上連接后發送其第一個命令時，此行為才會出現。
• 在客戶端上，經過幾分鍾的命令交換，在這種情況下，服務器端boost :: asio :: async_write處理函數被調用，但是客戶端繼續等待boost :: asio :: async_read_until處理函數。

鑒於並非每次都有，所以在我看來我使用async_read_until，async_write和boost :: asio :: strand的方式不正確。

這是簡化服務器的架構：

• 在鋼絞線下的插座上讀取
• 收到新命令后，另一個異步讀取開始，接收到的命令在另一個線程中異步處理（並且沒有子程序）
• 處理命令后，使用strand下的async_write將結果發送回同一套接字

（對服務器的某些命令不需要響應，有時需要在服務器上發生某些事件之后將命令發送給客戶端，即沒有從客戶端獲取數據。有必要說明的是，在同一套接字上永遠不能同時運行一個以上的async_read_until操作和一個以上的async_write操作。）

和客戶的：

• 連接后發送命令到服務器
• 從服務器收到命令后，發送回一個答案

服務器代碼：

#include <iostream>
#include <istream>
#include <ostream>
#include <string>

#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/thread.hpp>

class server_session
    : public boost::enable_shared_from_this<server_session>
{
public:
    server_session(boost::asio::io_service& io_service)
        : _io_service(io_service)
        , _socket(io_service)
        , _strand(io_service)
        , _delimiter('\b')
    {}

    boost::asio::ip::tcp::socket& socket()
    {
        return _socket;
    }

    void read()
    {
        boost::asio::async_read_until(
            _socket,
            _streambuf,
            _delimiter,
            _strand.wrap(
                boost::bind(
                    &server_session::handle_read,
                    shared_from_this(),
                    boost::asio::placeholders::error,
                    boost::asio::placeholders::bytes_transferred
                    )
                )
            );
    }

    void handle_read(const boost::system::error_code& ec, std::size_t bytes_transferred)
    {
        if (ec)
        {
            std::cerr << "async_read_until error: " << ec.message() << std::endl;
            return;
        }

        std::istream is(&_streambuf);
        std::string msg;
        std::getline(is, msg, _delimiter);

        read();

        _io_service.post(
            boost::bind(
                &server_session::proc_msg,
                shared_from_this(),
                msg
                )
            );
    }

    void proc_msg(const std::string msg)
    {
        // command proc here
        std::cout << "received: " << msg << std::endl;

        static std::uint64_t i = 0;
        write("resp_" + std::to_string(i++));
    }

    void write(const std::string& msg)
    {
        _strand.post(
            boost::bind(
                &server_session::write_impl,
                shared_from_this(),
                boost::shared_ptr<std::string>(new std::string(msg + _delimiter))
                )
            );
    }

private:
    void write_impl(const boost::shared_ptr<std::string>& text_ptr)
    {
        boost::asio::async_write(
            _socket,
            boost::asio::buffer(text_ptr->data(), text_ptr->size()),
            _strand.wrap(
                    boost::bind(
                        &server_session::handle_write,
                        shared_from_this(),
                        text_ptr,
                        boost::asio::placeholders::error
                        )
                    )
            );
    }

    void handle_write(const boost::shared_ptr<std::string>, const boost::system::error_code& ec)
    {
        if (ec)
        {            
            std::cerr << "async_write error: " << ec.message() << std::endl;
        }
    }

    boost::asio::io_service& _io_service;
    boost::asio::ip::tcp::socket _socket;
    boost::asio::strand _strand;
    boost::asio::streambuf _streambuf;
    char _delimiter;
};

class server
{
public:
    server(int port)
        : _acceptor(
            _io_service,
            boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(),port)
            )
    {
        start_accept();

        boost::thread_group thd_grp;

        for (int i = 0; i < 2; ++i)
        {
            thd_grp.create_thread(
                boost::bind(&boost::asio::io_service::run, &_io_service)
                );
        }

        thd_grp.join_all();
    }

private:
    void start_accept()
    {
        _session_ptr.reset(new server_session(_io_service));

        _acceptor.async_accept(
            _session_ptr->socket(),
            boost::bind(
                &server::handle_accept,
                this,
                boost::asio::placeholders::error
                )
            );
    }

    void server::handle_accept(const boost::system::error_code& ec)
    {
        if (ec)
        {
            std::cerr << "handle_accept error: " << ec.message() << std::endl;
            return;
        }

        _session_ptr->read();
        start_accept();
    }

    boost::asio::io_service _io_service;
    boost::asio::ip::tcp::acceptor _acceptor;
    boost::shared_ptr<server_session> _session_ptr;
};

int main(int argc, char** argv)
{
    if (argc != 2)
    {
        std::cerr << "usage: " << argv[0] << " <port>";
        return EXIT_FAILURE;
    }

    server s(std::stoi(argv[1]));
    return EXIT_SUCCESS;
}

客戶代碼：

#include <iostream>
#include <istream>
#include <ostream>
#include <string>

#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/shared_ptr.hpp>

class client
{
public:
    client(const std::string& host, const std::string& port)
        : _socket(_io_service)
        , _resolver(_io_service)
        , _query(host, port)
        , _delimiter('\b')
    {
        _iterator = _resolver.resolve(_query);

        boost::asio::async_connect(
            _socket, 
            _iterator,
            boost::bind(
                &client::handle_connect,
                this,
                boost::asio::placeholders::error
                )
            );

        _io_service.run();
    }

    void handle_connect(const boost::system::error_code& ec)
    {
        if (ec)
        {
            std::cerr << "async_connect error: " << ec.message() << std::endl;
            return;
        }

        write();
    }

    void write()
    {
        static std::uint64_t i = 0;
        boost::shared_ptr<std::string> msg_ptr(new std::string("req_" + std::to_string(i++) + _delimiter));

        boost::asio::async_write(
            _socket,
            boost::asio::buffer(msg_ptr->data(), msg_ptr->size()),
            boost::bind(
                &client::handle_write,
                this,
                msg_ptr,
                boost::asio::placeholders::error
                )
            );
    }

    void handle_write(const boost::shared_ptr<std::string>, const boost::system::error_code& ec)
    {
        if (ec)
        {
            std::cerr << "async_write error: " << ec.message() << std::endl;
            return;
        }

        read();
    }

    void read()
    {
        boost::asio::async_read_until(
            _socket,
            _streambuf,
            _delimiter,
            boost::bind(
                &client::handle_read,
                this,
                boost::asio::placeholders::error,
                boost::asio::placeholders::bytes_transferred
                )
            );
    }

    void handle_read(const boost::system::error_code& ec, std::size_t bytes_transferred)
    {
        if (ec)
        {            
            std::cerr << "async_read_until error: " << ec.message() << std::endl;
            return;
        }

        std::istream is(&_streambuf);
        std::string msg;
        std::getline(is, msg, _delimiter);

        std::cout << "received: " << msg << std::endl;

        write();
    }

    boost::asio::io_service _io_service;     
    boost::asio::ip::tcp::socket _socket;
    boost::asio::ip::tcp::resolver _resolver;
    boost::asio::ip::tcp::resolver::query _query;
    boost::asio::ip::tcp::resolver::iterator _iterator;
    boost::asio::streambuf _streambuf;
    char _delimiter;
};

int main(int argc, char** argv)
{
    if (argc != 3)
    {
        std::cerr << "usage: " << argv[0] << " <host> <port>";
        return EXIT_FAILURE;
    }

    client c(argv[1], argv[2]);
    return EXIT_SUCCESS;
}

在套接字上已經運行async_read_until時使用astr進行async_write正確嗎？

async_read_until是否可能以某種方式在內部阻塞套接字，並且實際上數據沒有發送到客戶端？

對於代碼為何無法正常工作的任何建議，我將不勝感激。

我正在使用Boost 1.58，平台-Win7和Win8。 在localhost和LAN上測試了以上結果。

Answer 1

我至少可以告訴您，每次啟動新的異步操作時，您都應使用asio :: deadline_timer並重置計時器。 您尤其應該使用async_read_until之類的操作來執行此操作，因為您要指定完成調用的條件，而這些條件可能永遠不會滿足。 查找the ceiling_timer示例，並在每個異步操作上實現async_wait，並指定該操作的截止日期。 在超時操作中，可以酌情取消掛起的異步操作，出錯或重新啟動。