C / C++ / 系统课时
用读缓冲处理字节流边界
用读缓冲处理字节流边界
非阻塞 Socket 一次 read 得到多少字节并不由应用协议决定:一条消息可能被拆成多次到达,多条消息也可能一次读回来。本节实现可扩展输入缓冲,让网络层只负责持续收集字节,并为协议层处理半包、粘包留下稳定边界。
学习目标
- 理解 TCP 字节流与应用层消息边界之间的差异
- 设计具有读写索引、可扩容和空间复用能力的输入缓冲区
- 正确处理非阻塞读取中的数据、EOF、
EINTR与EAGAIN
Socket 给的是字节流而不是消息
假设发送方连续发送两条长度分别为 5 和 7 字节的应用消息,接收方可能一次读到 12 字节,也可能先读到 3 字节、之后再读到 9 字节。TCP 只保证有序字节流,不承诺一次 send 对应一次 read。
因此网络层不应该把“本次 read 返回的数据”直接当成一条消息,而应该先追加到长期存在的输入 Buffer。协议解析器再根据长度字段、分隔符或固定长度从 Buffer 中提取完整帧,剩余的不完整字节继续保留。

Buffer 用两个索引描述有效数据
一个实用 Buffer 可以用连续数组加两个索引实现:readerIndex 指向第一字节可读数据,writerIndex 指向下一处可写位置。两者之间是当前有效数据,writer 后方是可直接写空间,reader 前方则是已经消费、可以回收的空间。

片段示例:下面给出 Buffer 的核心索引与空间整理逻辑,省略与协议解析无关的便利接口。
class Buffer {
public:
explicit Buffer(std::size_t initial = 1024)
: data_(initial), readerIndex_(0), writerIndex_(0) {}
std::size_t readableBytes() const { return writerIndex_ - readerIndex_; }
std::size_t writableBytes() const { return data_.size() - writerIndex_; }
const char* peek() const { return data_.data() + readerIndex_; }
char* beginWrite() { return data_.data() + writerIndex_; }
void hasWritten(std::size_t n) { writerIndex_ += n; }
void retrieve(std::size_t n) {
if (n < readableBytes()) {
readerIndex_ += n;
} else {
// 数据全部消费后复位索引,避免索引持续向后增长。
readerIndex_ = 0;
writerIndex_ = 0;
}
}
void ensureWritableBytes(std::size_t n) {
if (writableBytes() >= n) return;
if (readerIndex_ + writableBytes() >= n) {
const std::size_t readable = readableBytes();
std::memmove(data_.data(), peek(), readable);
readerIndex_ = 0;
writerIndex_ = readable;
} else {
data_.resize(writerIndex_ + n);
}
}
private:
std::vector<char> data_;
std::size_t readerIndex_;
std::size_t writerIndex_;
};这里优先复用已经消费的前部空间,只有总容量仍然不足时才扩容。这样既避免每次消费都移动内存,也避免只会向后追加导致缓冲区无意义增长。
一次事件要尽量读到 EAGAIN
非阻塞 fd 可读时,推荐持续读取直到内核返回 EAGAIN 或 EWOULDBLOCK。如果 Buffer 当前尾部空间较少,可以先直接写入剩余空间;高性能实现还常用 readv 再配一个栈上临时区,既避免提前扩容,又能在一次系统调用中尽可能排空 Socket 接收缓冲。
下面是可直接独立运行的最小示例:使用 socketpair 构造本机连接,把超过初始 Buffer 容量的数据读入动态缓冲,并打印最终内容。
#include <cerrno>
#include <cstring>
#include <iostream>
#include <stdexcept>
#include <string>
#include <sys/socket.h>
#include <unistd.h>
#include <vector>
class Buffer {
public:
explicit Buffer(std::size_t size = 8)
: data_(size), reader_(0), writer_(0) {}
ssize_t readFd(int fd) {
char extra[64];
iovec vec[2];
vec[0] = {data_.data() + writer_, data_.size() - writer_};
vec[1] = {extra, sizeof(extra)};
const ssize_t n = ::readv(fd, vec, 2);
if (n <= 0) return n;
const std::size_t writable = data_.size() - writer_;
if (static_cast<std::size_t>(n) <= writable) {
writer_ += static_cast<std::size_t>(n);
} else {
writer_ = data_.size();
append(extra, static_cast<std::size_t>(n) - writable);
}
return n;
}
void append(const char* src, std::size_t n) {
if (data_.size() - writer_ < n) {
data_.resize(writer_ + n);
}
std::memcpy(data_.data() + writer_, src, n);
writer_ += n;
}
std::string readable() const {
return std::string(data_.data() + reader_, writer_ - reader_);
}
private:
std::vector<char> data_;
std::size_t reader_;
std::size_t writer_;
};
int main() {
int fds[2];
if (::socketpair(AF_UNIX, SOCK_STREAM, 0, fds) != 0) {
throw std::runtime_error("socketpair failed");
}
const std::string message = "hello-reactor-buffer";
::write(fds[0], message.data(), message.size());
Buffer input(8);
const ssize_t n = input.readFd(fds[1]);
std::cout << "bytes=" << n << " data=" << input.readable() << '\n';
::close(fds[0]);
::close(fds[1]);
}预期输出:
bytes=20 data=hello-reactor-buffer示例中初始可写空间只有 8 字节,其余数据进入 extra,随后再追加到动态数组。这正是 readv 方案的价值:常见小包直接写 Buffer,大包也不必在系统调用前猜测应该扩容多少。
把读取结果转换成明确事件
真正接入 Reactor 后,读取函数不能只返回“成功或失败”。n > 0 表示 Buffer 新增数据,可以通知消息回调;n == 0 表示对端完成了有序关闭,应进入连接关闭流程;n < 0 则必须结合 errno 判断是否重试、等待下次事件或按致命错误关闭。
EINTR 表示系统调用被信号中断,可以立即重试;EAGAIN 和 EWOULDBLOCK 表示当前数据已经读完,并不是连接故障。只有其他不可恢复错误才应该交给 Connection 的错误处理路径。
片段示例:依赖已有的 inputBuffer_、handleClose() 和消息回调。
void Connection::handleRead() {
for (;;) {
const ssize_t n = inputBuffer_.readFd(socketFd_);
if (n > 0) {
continue;
}
if (n == 0) {
handleClose();
return;
}
if (errno == EINTR) {
continue;
}
if (errno == EAGAIN || errno == EWOULDBLOCK) {
break;
}
handleError(errno);
return;
}
if (inputBuffer_.readableBytes() > 0 && messageCallback_) {
messageCallback_(shared_from_this(), inputBuffer_);
}
}这里仍然没有尝试识别“一条消息”。Connection 只负责把 Socket 字节稳定搬进 Buffer,再把当前可读数据交给协议层。协议层消费多少字节,就推进多少 readerIndex;不足一帧时什么都不丢,继续等待下次可读事件。这样长度前缀、分隔符协议以及 RPC 帧格式都可以建立在同一个输入缓冲机制之上。