Boost.Asio 异步读写操作

最新推荐文章于 2026-05-01 12:15:07 发布
原创 最新推荐文章于 2026-05-01 12:15:07 发布 · 1.1k 阅读 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
cknow-ai FHKHH

cknow-ai 关注

标签
#网络 #服务器 #运维
分类 计算机网络

Boost.Asio 异步读写操作

参考资料：
asio异步读写操作及注意事项

目录
  1. 异步写操作
    • async_write_some
    • async_send
    • 基于 async_write_some 的封装
    • 基于 async_send 的封装
  2. 异步读操作
    • async_read_some
    • async_receive
    • 基于 async_read_some 的封装
    • 基于 async_receive 的封装
  3. 实际应用场景：实现一个简单的网络通信服务
    • 服务端示例
    • 客户端示例

1. 异步写操作

1.1 async_write_some
  • 特点：
    • 每次只尽可能多地发送数据，实际发送的字节数可能小于请求发送的总字节数。
    • 应用层需通过回调函数检查已发送字节数，并循环调用直到数据完全发送。
  • 适用场景：
    • 更精细的控制发送过程，例如流式传输或对发送进度有特殊要求。
1.2 async_send
  • 特点：
    • 内部会循环调用 async_write_some，直到数据完全发送。
    • 回调函数只在发送完成或发生错误时触发。
  • 适用场景：
    • 需要简化发送逻辑时使用。
1.3 基于 async_write_some 的封装

实现逻辑：

  • 使用队列管理待发送数据，保证发送顺序。
  • 在回调函数中检查发送进度，如果未发送完成则继续发送。

代码：

void Session::WriteToSocket(const std::string& buf) {
    _send_queue.emplace(std::make_shared<MsgNode>(buf.c_str(), buf.length()));
    if (_send_pending) return;

    _send_pending = true;
    auto front = _send_queue.front();
    _socket->async_write_some(
        asio::buffer(front->_msg, front->_total_len),
        [this, front](const boost::system::error_code& ec, std::size_t bytes_transferred) {
            this->HandleWrite(ec, bytes_transferred);
        });
}

void Session::HandleWrite(const boost::system::error_code& ec, std::size_t bytes_transferred) {
    if (ec) {
        std::cerr << "Error during async write: " << ec.message() << std::endl;
        return;
    }

    auto front = _send_queue.front();
    front->_cur_len += bytes_transferred;

    if (front->_cur_len < front->_total_len) {
        _socket->async_write_some(
            asio::buffer(front->_msg + front->_cur_len, front->_total_len - front->_cur_len),
            [this, front](const boost::system::error_code& ec, std::size_t bytes_transferred) {
                this->HandleWrite(ec, bytes_transferred);
            });
    } else {
        _send_queue.pop();
        if (_send_queue.empty()) {
            _send_pending = false;
        } else {
            WriteToSocket("");  // 继续发送队列中的下一个消息
        }
    }
}
1.4 基于 async_send 的封装

实现逻辑：

  • 使用队列管理数据，依次调用 async_send，简化发送逻辑。

代码：

void Session::WriteAllToSocket(const std::string& buf) {
    _send_queue.emplace(std::make_shared<MsgNode>(buf.c_str(), buf.length()));
    if (_send_pending) return;

    _send_pending = true;
    auto front = _send_queue.front();
    _socket->async_send(
        asio::buffer(front->_msg, front->_total_len),
        [this, front](const boost::system::error_code& ec, std::size_t bytes_transferred) {
            this->WriteAllCallBack(ec, bytes_transferred);
        });
}

void Session::WriteAllCallBack(const boost::system::error_code& ec, std::size_t bytes_transferred) {
    if (ec) {
        std::cerr << "Error during async send: " << ec.message() << std::endl;
        return;
    }

    _send_queue.pop();
    if (_send_queue.empty()) {
        _send_pending = false;
    } else {
        WriteAllToSocket("");  // 继续发送队列中的下一个消息
    }
}

2. 异步读操作

2.1 async_read_some
  • 特点：
    • 每次只尽可能多地读取数据，实际读取的字节数可能小于请求的总字节数。
    • 需要在回调函数中检查已读取字节数，并循环调用直到数据完全读取。
  • 适用场景：
    • 需要精细控制读取过程的场景。
2.2 async_receive
  • 特点：
    • 内部会循环调用 async_read_some，直到数据完全读取。
    • 回调函数只在读取完成或发生错误时触发。
  • 适用场景：
    • 需要简化读取逻辑时使用。
2.3 基于 async_read_some 的封装

实现逻辑：

  • 初始化接收缓冲区，调用 async_read_some 开始接收数据。
  • 在回调函数中检查读取进度，循环调用直到读取完成。

代码：

void Session::ReadFromSocket() {
    if (_recv_pending) return;

    _recv_node = std::make_shared<MsgNode>(RECVSIZE);
    _socket->async_read_some(
        asio::buffer(_recv_node->_msg, _recv_node->_total_len),
        [this](const boost::system::error_code& ec, std::size_t bytes_transferred) {
            this->ReadCallBack(ec, bytes_transferred);
        });
    _recv_pending = true;
}

void Session::ReadCallBack(const boost::system::error_code& ec, std::size_t bytes_transferred) {
    if (ec) {
        std::cerr << "Error during async read: " << ec.message() << std::endl;
        return;
    }

    _recv_node->_cur_len += bytes_transferred;

    if (_recv_node->_cur_len < _recv_node->_total_len) {
        _socket->async_read_some(
            asio::buffer(_recv_node->_msg + _recv_node->_cur_len, _recv_node->_total_len - _recv_node->_cur_len),
            [this](const boost::system::error_code& ec, std::size_t bytes_transferred) {
                this->ReadCallBack(ec, bytes_transferred);
            });
    } else {
        // 数据读取完成
        _recv_pending = false;
        _recv_node = nullptr;
    }
}
2.4 基于 async_receive 的封装

实现逻辑：

  • 初始化接收缓冲区，调用 async_receive 一次性读取数据。

代码：

void Session::ReadAllFromSocket() {
    if (_recv_pending) return;

    _recv_node = std::make_shared<MsgNode>(RECVSIZE);
    _socket->async_receive(
        asio::buffer(_recv_node->_msg, _recv_node->_total_len),
        [this](const boost::system::error_code& ec, std::size_t bytes_transferred) {
            this->ReadAllCallBack(ec, bytes_transferred);
        });
    _recv_pending = true;
}

void Session::ReadAllCallBack(const boost::system::error_code& ec, std::size_t bytes_transferred) {
    if (ec) {
        std::cerr << "Error during async receive: " << ec.message() << std::endl;
        return;
    }

    _recv_node->_cur_len += bytes_transferred;

    // 数据读取完成
    _recv_pending = false;
    _recv_node = nullptr;
}

3. 实际应用场景：网络通信服务

3.1 服务端示例

逻辑：

  • 接收客户端连接。
  • 使用封装的异步读写函数进行数据收发。

代码：

void StartServer(asio::io_context& io_context, short port) {
    auto acceptor = std::make_shared<asio::ip::tcp::acceptor>(io_context, asio::ip::tcp::endpoint(asio::ip::tcp::v4(), port));

    auto socket = std::make_shared<asio::ip::tcp::socket>(io_context);
    acceptor->async_accept(*socket, [socket](const boost::system::error_code& ec) {
        if (!ec) {
            auto session = std::make_shared<Session>(socket);
            session->ReadFromSocket();  // 开始接收数据
        }
    });

    io_context.run();
}
3.2 客户端示例

逻辑：

  • 连接服务端。
  • 使用封装的异步读写函数与服务端通信。

代码：

void StartClient(asio::io_context& io_context, const std::string& host, short port) {
    auto socket = std::make_shared<asio::ip::tcp::socket>(io_context);
    asio::ip::tcp::resolver resolver(io_context);
    asio::connect(*socket, resolver.resolve(host, std::to_string(port)));

    auto session = std::make_shared<Session>(socket);
    session->WriteToSocket("Hello, Server!");
    session->ReadFromSocket();  // 等待服务端响应

    io_context.run();
}
点赞 点赞 19
评论 0
书签 书签 8
26、boost asio 教程---正确的读写数据 第二部分
Knowledgebase的博客
09-21 449
记住 `tcp::socket::async_connect` 成员函数，它接受一个端点作为参数，以及自由函数 `boost::asio::async_connect`，它可以处理一系列端点。这在 Boost.Asio 中是一种常见的做法，其中自由函数是某些现有功能的更高级通用化，而这些功能可以通过成员函数提供。我们将要讨论的函数有：`boost::asio::async_read`、`boost::asio::async_read_until` 和 `boost::asio::async_write`。
asio异步读写操作
2201_75528880的博客
11-25 989
这一篇记录的是boost::asio的异步读写操作，还是先记录api使用的代码片段，然后连起来写一个以应答为主的异步echo服务器。这里实现的这个异步服务器存在隐患，就是当服务器即将发送数据前(调用async_write前)，此刻客户端中断，服务器此时调用async_write会触发发送回调函数，判断ec为非0进而执行delete this逻辑回收session。但要注意的是客户端关闭后，在tcp层面会触发读就绪事件，服务器会触发读事件回调函数。
boost.asio的async_write_some存在的坑
iLuoPu的博客
02-19 5184
boost.asio的async_write_some看起来很方便，但使用起来很复杂，主要有两个方面: async_write_some经常与io_context不在同一线程，async_write_some同一时刻只能由一个线程调用，需要加锁，同时需要与io_context所在线程的其他异步方法同步，如关闭sock的时机。 当对方一直不读取缓冲区，就会造成本方的socket发送缓冲区爆满，此种情况需要怎样处理? 第一种情况就需要根据业务情况加各种锁了。现在只讨论当对方一直不读缓冲区的情况。测试如下 s
关于boost::asio::async_write的实现机制
zhb_yz的专栏
08-18 8144
 关于boost::asio::async_write机制 在用boost的asio开发网络应用时可能会用到2个异步发送函数 （1）basic_stream_socket类的async_write_some函数  这个函数以异步的方式将缓冲区中的数据写入到stream socket中，但是写入  操作不能保证将所有的字节全部写入。 （1）async_write函数  async_
Human3R：动态人体与场景4D重建技术解析
最新发布
weixin_30542079的博客
05-01 425
计算机视觉中的三维重建技术正从静态场景向动态交互演进。通过时空体素表示和跨模态特征融合，现代算法能实现毫米级精度的人体动作捕捉与场景建模。这种技术突破关键在于将传统分离的人体重建（如SMPL模型）与神经辐射场（NeRF）等场景重建技术统一到4D坐标系，通过动态occupancy field等创新方法解决交互区域的穿透问题。在智能健身、虚拟拍摄等应用场景中，此类技术可大幅降低动作捕捉成本，其中Human3R框架实测将部署时间从4小时缩短至30分钟。随着Octree稀疏优化等工程改进，这类系统已能在消费级GPU
boost::asio::async_read、boost::asio::async_write 模板函数的简化版实现逻辑。
liulilittle的博客
08-03 1733
write_yield 等价 boost::asio::async_write 模板函数（stackful 协同程式）read_yield 等价 boost::asio::async_read 模板函数（stackful 协同程式）write_async 等价 boost::asio::async_write 模板函数。read_async 等价 boost::asio::async_read 模板函数。...............
boost.asio async_read_some 和 async_read
weixin_42427338的博客
04-24 1万+
这次做的这个项目就遇到一些问题 想要达到的效果是每次先读取１００字节的内容，之后根据这里面的数据长度的提示去找到接下来需要继续读出来的数据长度是多少，但是还是遇到了一些问题没有解决。所以又回头去看了一下ＡＰＩ到底都是怎么回事。 首先我之前使用的是ip::tcp::socket::async_read_some() basic_stream_socket::async_read_some T...
4. boost::asio之asio异步读写操作及注意事项
yang_pi_pi的博客
02-11 494
本文介绍boost asio的异步读写操作及注意事项，为保证知识便于读者吸收，仅介绍api使用的代码片段，下一节再编写完整的客户端和服务器程序。所以我们定义一个session类，这个session类表示服务器处理客户端连接的管理类session类定义了一个socket成员变量，负责处理对端的连接读写，封装了Connect函数在写操作前，我们先封装一个Node结构，用来管理要发送和接收的数据，该结构包含数据域首地址，数据的总长度，以及已经处理的长度(已读的长度或者已写的长度)
【boost网络库从青铜到王者】第六篇:asio网络编程中的socket异步读(接收)写(发送)
森明帮大于黑虎帮的博客
08-24 2171
【boost网络库从青铜到王者】第六篇:asio网络编程中的socket异步读(接收)写(发送)
boost::ASIO 读写
qq1987924的专栏
08-25 1万+
NO.1 ASIO 读操作大总结： A. Boos：：asio：：read 同步读方式 void client::read_data(char   * sourse  , int num )         {                 boost::asio::read( socket_own , boost::asio::buffer( sourse , num ) );
boost：asio的同步方式和异步方式
qq1987924的专栏
08-23 1040
http://blog.csdn.net/byrsongqq/article/details/6253435   Boost.Asio是一个跨平台的网络及底层IO的C++编程库，它使用现代C++手法实现了统一的异步调用模型。 头文件 #include 名空间 using namespace boost::asio; ASIO库能够使用TCP、UDP、ICMP、串口来发送/接收数据，
Boost asio的async_write函数
热门推荐
某花
10-28 2万+
Boost asio是一个异步网络通信的库，其中async_write是一个比较常用的函数，但是，如果没有正确的使用，就可能会出现一些意想不到的潜在Bug。例如下面的代码： for (int i=0; i < n; i++) { boost::asio::async_write( socket_, boost::asio::buffer( buffer[i
boost::async_read_some连续接收数据
波波诸葛伟
11-30 3873
"font-size:18px">我在最近工作的时候用到了boost的http_server程序，这个http_server是一个框架用于接收并解析http协议。这个框架在接收get请求时没有任何问题，当接收post数据时，当数据大于>2k时，无法正确接收，后来发现sync_read_some函数一次只能接收大约1k数据，如果要接收大数据，需要反复接收，自己修改了几天，将经验分享一下。   //
boost async_read_some 用法
weixin_34252090的博客
08-08 2228
async_read_some读到数据就会直接回调设置的函数，不管数据是否已经读完。所以在这里会遇到一个非常棘手的问题，如何确定数据已经读取完毕？常见的方式是在数据的后面添加标志位，例如添加/r/n/r/n作为结束符，然后停止读取async_read_some的基本原理是往IOCP的队列里面添加一个异步任务，没有事情的时候，CSession::ContinueRead不应该被...
serial_port::async_read_some函数调用过程
u011743621的博客
07-21 580
Boost Asio异步发送数据（async_write）崩溃问题记录
guotianqing的博客
03-03 4373
背景 服务端与客户端之间的网络通信（使用Boost Asio库异步编程模式实现），客户端会向服务端请求数据。 在刚开始的测试中，是没有出现问题的。后来有一次测试时，服务端查询完数据后，向客户端发送时总是崩溃。 通过gdb调试，可以发现是在调用到异步发送函数（boost::asio::async_write）后崩溃的。 打印的栈信息如下： Program terminated with signa...
（四）基于BOOST ASIO实现的异步TCP客户端与服务端
小飞侠的博客
06-01 1296
基于BOOST ASIO实现的异步TCP服务端
Boost.Asio学习笔记3——IO操作
qq_41007891的博客
06-29 1169
像任何其它类型的I/O一样，网络I/O也涉及使用内存缓冲区，这些缓冲区是在进程地址空间中分配的连续内存块，用于存储数据。这意味着，在⼀般情况下，为了将缓冲区中的所有数据写⼊套接字，我们可能需要多次调⽤该⽅法。⽅法写⼊数据，即使想发送⼀个由⼏个字节组成的⼩消息，也必须使⽤循环、⼀个变量来跟踪已经写⼊的字节数，并且在每次循环迭代时正确构造缓冲区。，接受⼀个表⽰可写缓冲区（单个或复合）的对象作为参数，顾名思义，它会从套接字读取⼀定量的数据到缓冲区中。它启动⼀个操作，旨在从套接字读取⼀定量的数据到缓冲区。
boost asio简易tcp服务器
wanghualin033的博客
10-18 1066
可用于一些需要tcp连接的场景，代码简洁，不易出错，经测试可用 #include <iostream> #include <memory> #include <array> #include <boost/asio.hpp> class session : public std::enable_shared_from_this<sess...
Boost之async_read_some() callback(一百零四)
Android系统攻城狮
11-12 1372
#define BOOST_ALL_NO_LIB 1 #include <iostream> #include <boost/asio/read.hpp> #include <cstring> #include <vector> #include <boost/asio/io_context.hpp> #include <boost/asio/post.hpp> #include <boost/asio/streambuf.hp.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值