C / C++ / 系统课时

用读缓冲处理字节流边界

用读缓冲处理字节流边界

非阻塞 Socket 一次 read 得到多少字节并不由应用协议决定:一条消息可能被拆成多次到达,多条消息也可能一次读回来。本节实现可扩展输入缓冲,让网络层只负责持续收集字节,并为协议层处理半包、粘包留下稳定边界。

学习目标

  • 理解 TCP 字节流与应用层消息边界之间的差异
  • 设计具有读写索引、可扩容和空间复用能力的输入缓冲区
  • 正确处理非阻塞读取中的数据、EOF、EINTR 与 EAGAIN

Socket 给的是字节流而不是消息

假设发送方连续发送两条长度分别为 5 和 7 字节的应用消息,接收方可能一次读到 12 字节,也可能先读到 3 字节、之后再读到 9 字节。TCP 只保证有序字节流,不承诺一次 send 对应一次 read。

因此网络层不应该把“本次 read 返回的数据”直接当成一条消息,而应该先追加到长期存在的输入 Buffer。协议解析器再根据长度字段、分隔符或固定长度从 Buffer 中提取完整帧,剩余的不完整字节继续保留。

TCP 字节流进入输入缓冲并由协议层拆帧

Buffer 用两个索引描述有效数据

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

读缓冲区的 readerIndex 与 writerIndex 布局

片段示例:下面给出 Buffer 的核心索引与空间整理逻辑,省略与协议解析无关的便利接口。

cpp
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 容量的数据读入动态缓冲,并打印最终内容。

cpp
#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]);
}

预期输出:

text
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() 和消息回调。

cpp
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 帧格式都可以建立在同一个输入缓冲机制之上。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

用读缓冲处理字节流边界

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通