我对 boost asio 如何处理这个有一个理解问题:

当我在客户端查看我的请求响应时，我可以使用以下 boost 示例 Example

但我不明白如果服务器每隔 X 毫秒向客户端发送一些状态信息会发生什么。我是否为此打开了一个 serperate 套接字，或者我的客户端是否可以区分请求、响应和 cycleMessage？

客户端发送请求并读取为 cycleMessage 会发生吗？因为他也在因为这个Message等待async_read？

class TcpConnectionServer : public boost::enable_shared_from_this<TcpConnectionServer>
{
public:
    typedef  boost::shared_ptr<TcpConnectionServer> pointer;
    static pointer create(boost::asio::io_service& io_service)
    {
        return pointer(new TcpConnectionServer(io_service));
    }
    boost::asio::ip::tcp::socket& socket()
    {
        return m_socket;
    }
    void Start()
    {
        SendCycleMessage();
        boost::asio::async_read(
                m_socket, boost::asio::buffer(m_data, m_dataSize),
                boost::bind(&TcpConnectionServer::handle_read_data, shared_from_this(), boost::asio::placeholders::error));
    }

private:
    TcpConnectionServer(boost::asio::io_service& io_service)
        : m_socket(io_service),m_cycleUpdateRate(io_service,boost::posix_time::seconds(1))
      {

      }
    void handle_read_data(const boost::system::error_code& error_code)
    {
        if (!error_code)
        {
        std::string answer=doSomeThingWithData(m_data);
        writeImpl(answer);

        boost::asio::async_read(
                m_socket, boost::asio::buffer(m_data, m_dataSize),
                boost::bind(&TcpConnectionServer::handle_read_data, shared_from_this(), boost::asio::placeholders::error));
        }
        else
        {

            std::cout << error_code.message() << "ERROR DELETE READ \n";
            // delete this;
        }
    }


    void SendCycleMessage()
    {
        std::string data = "some usefull data";
        writeImpl(data);
        m_cycleUpdateRate.expires_from_now(boost::posix_time::seconds(1));
        m_cycleUpdateRate.async_wait(boost::bind(&TcpConnectionServer::SendTracedParameter,this));
    }

    void writeImpl(const std::string& message)
    {
        m_messageOutputQueue.push_back(message);
        if (m_messageOutputQueue.size() > 1)
        {
            // outstanding async_write
            return;
        }

        this->write();
    }

    void write()
    {
        m_message = m_messageOutputQueue[0];
        boost::asio::async_write(
                m_socket,
                boost::asio::buffer(m_message),
                boost::bind(&TcpConnectionServer::writeHandler, this, boost::asio::placeholders::error,
                            boost::asio::placeholders::bytes_transferred));
    }

    void writeHandler(const boost::system::error_code& error, const size_t bytesTransferred)
    {
        m_messageOutputQueue.pop_front();
        if (error)
        {
            std::cerr << "could not write: " << boost::system::system_error(error).what() << std::endl;
            return;
        }

        if (!m_messageOutputQueue.empty())
        {
            // more messages to send
            this->write();
        }
    }

    boost::asio::ip::tcp::socket m_socket;
    boost::asio::deadline_timer m_cycleUpdateRate;
    std::string m_message;

    const size_t m_sizeOfHeader = 5;
    boost::array<char, 5> m_headerData;
    std::vector<char> m_bodyData;

    std::deque<std::string> m_messageOutputQueue;
};

有了这个实现，我将不需要 boost::asio::strand 或者？因为我不会从其他线程修改 m_messageOutputQueue。

但是当我在我的客户端有一个 m_messageOutputQueue 时，我可以从其他线程访问这一点，我需要 strand 吗？因为那时我需要同步？我是不是理解错了什么？

最佳答案

消息的区分是您的应用程序协议(protocol)的一部分。

ASIO 仅提供交通工具。

现在，实际上，如果您想要一个“keepalive”消息，您必须设计您的协议(protocol)，以便客户端可以区分这些消息。

诀窍是在更高的层次上考虑它。不要直接在客户端处理async_read。相反，让 async_read 将消息放入队列(或多个队列；状态消息甚至不能进入队列，但会取代之前未处理的状态更新)。

然后根据这些队列对您的客户端进行编码。

通常做的一件简单的事情是引入消息框架和消息类型 id:

FRAME offset 0: message length(N)
FRAME offset 4: message data
FRAME offset 4+N: message checksum
FRAME offset 4+N+sizeof checksum: sentinel (e.g. 0x00, or a larger unique signature)

那里的结构使协议(protocol)更具可扩展性。无需触及所有其他代码即可轻松添加加密/压缩。有内置的错误检测等。

关于c++ - boost asio tcp 异步读/写，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/31133639/