35、协议缓冲区设计：环形缓冲区实现、动态缓冲区扩展、内存管理

协议缓冲区，说白了就是网络通信中临时存放数据的“中转站”。

你想想看，网络数据包到达的时间是不确定的。有时候一口气来一堆，有时候半天没动静。如果不用缓冲区，你的程序要么丢数据，要么被阻塞死。我在早期做嵌入式网络项目时，就吃过这个亏——一次突发流量直接把程序搞崩了。

嗯，今天我们就来聊聊怎么设计一个靠谱的协议缓冲区。重点讲三个东西：环形缓冲区、动态扩展、内存管理。

35.1 环形缓冲区：为什么是“环”？

先说说最基础的环形缓冲区。

普通线性缓冲区有个毛病：数据读走了，前面的空间就浪费了。你得时不时把后面的数据往前挪，或者干脆重新分配内存。这操作在高速网络场景下，简直就是性能杀手。

环形缓冲区不一样。它逻辑上是个环，头尾相连。写数据时往“尾”写，读数据时从“头”读。头尾指针追着跑，空间循环利用。

我个人习惯用两个指针来管理：read_pos 和 write_pos。当 write_pos 追上 read_pos 时，说明缓冲区满了；反过来，read_pos 追上 write_pos 时，说明缓冲区空了。

来看一个简单的实现框架：

// 环形缓冲区结构体
typedef struct {
    uint8_t *buffer;      // 数据存储区
    size_t   size;        // 缓冲区总大小
    size_t   read_pos;    // 读指针位置
    size_t   write_pos;   // 写指针位置
} ring_buffer_t;

// 初始化
int ring_buffer_init(ring_buffer_t *rb, size_t size) {
    rb->buffer = (uint8_t *)malloc(size);
    if (!rb->buffer) return -1;
    rb->size = size;
    rb->read_pos = 0;
    rb->write_pos = 0;
    return 0;
}

// 写入数据
size_t ring_buffer_write(ring_buffer_t *rb, 
                         const uint8_t *data, 
                         size_t len) {
    size_t available = ring_buffer_available(rb);
    if (len > available) len = available;
    
    // 分两段写入（绕过环的终点）
    size_t first_part = rb->size - rb->write_pos;
    if (len <= first_part) {
        memcpy(rb->buffer + rb->write_pos, data, len);
    } else {
        memcpy(rb->buffer + rb->write_pos, data, first_part);
        memcpy(rb->buffer, data + first_part, len - first_part);
    }
    
    rb->write_pos = (rb->write_pos + len) % rb->size;
    return len;
}

注意看那个“分两段写入”的逻辑。因为环是连续的，但内存是线性的。写到环的尾部时，得绕回头部继续写。这个细节，我当年第一次写的时候漏掉了，结果数据错位，排查了半天。

35.2 动态缓冲区扩展：不够用怎么办？

环形缓冲区大小是固定的。但网络数据量有时候会超出预期。比如你设了4KB缓冲区，结果对方发了个8KB的包。怎么办？

硬扛？数据丢了。等着？程序卡死。

我建议的做法是：动态扩展。当缓冲区不够时，自动翻倍扩容。

// 动态扩展环形缓冲区
int ring_buffer_expand(ring_buffer_t *rb, size_t new_size) {
    if (new_size <= rb->size) return 0;
    
    uint8_t *new_buffer = (uint8_t *)malloc(new_size);
    if (!new_buffer) return -1;
    
    // 把旧数据按顺序拷贝到新缓冲区
    size_t data_len = ring_buffer_data_len(rb);
    size_t first_part = rb->size - rb->read_pos;
    
    if (data_len <= first_part) {
        memcpy(new_buffer, rb->buffer + rb->read_pos, data_len);
    } else {
        memcpy(new_buffer, rb->buffer + rb->read_pos, first_part);
        memcpy(new_buffer + first_part, rb->buffer, 
               data_len - first_part);
    }
    
    free(rb->buffer);
    rb->buffer = new_buffer;
    rb->size = new_size;
    rb->read_pos = 0;
    rb->write_pos = data_len;
    
    return 0;
}

这里有个关键点：扩展后要重新整理数据顺序。因为旧缓冲区里数据可能是分两段存的（环的尾部+头部），但新缓冲区是线性的，得把它们拼成连续的一段。

35.3 内存管理：别让内存泄漏找上你

说到内存管理，这是C语言网络编程里最容易翻车的地方。

我曾经在一个项目中，缓冲区频繁创建和销毁，结果忘了释放旧内存。程序跑了三天，内存占用从几十MB涨到了几个GB。最后服务器直接OOM被kill了。嗯，从那以后，我对内存管理就格外小心。

关于协议缓冲区的内存管理，我总结了几条原则：

• 谁分配，谁释放。 创建缓冲区的地方，必须负责销毁它。
• 避免野指针。 释放后将指针置为NULL，防止二次释放。
• 使用引用计数。 如果缓冲区被多个模块共享，用引用计数管理生命周期。

来看一个带引用计数的缓冲区设计：

typedef struct {
    uint8_t *data;
    size_t   size;
    int      ref_count;  // 引用计数
} shared_buffer_t;

shared_buffer_t* shared_buffer_create(size_t size) {
    shared_buffer_t *sb = malloc(sizeof(shared_buffer_t));
    if (!sb) return NULL;
    
    sb->data = malloc(size);
    if (!sb->data) {
        free(sb);
        return NULL;
    }
    
    sb->size = size;
    sb->ref_count = 1;  // 初始引用为1
    return sb;
}

void shared_buffer_retain(shared_buffer_t *sb) {
    if (sb) {
        sb->ref_count++;
    }
}

void shared_buffer_release(shared_buffer_t *sb) {
    if (!sb) return;
    
    sb->ref_count--;
    if (sb->ref_count <= 0) {
        free(sb->data);
        free(sb);
    }
}

这个模式在协议栈里很实用。比如一个数据包从网卡驱动传到协议层，再到应用层，每一层都“持有”这个缓冲区。处理完了就释放引用。最后一个释放的人负责清理内存。

35.4 三种方案的对比

我把这三种缓冲区方案放在一起对比一下，方便你根据场景选择：

方案	优点	缺点	适用场景
固定环形缓冲区	无动态分配，性能稳定	大小固定，可能溢出	数据量可预测，实时性要求高
动态扩展缓冲区	灵活应对突发流量	扩展时有性能开销	数据量波动大，不能丢数据
引用计数缓冲区	安全共享，避免拷贝	实现稍复杂，有计数开销	多模块共享数据，零拷贝需求

35.5 核心逻辑图

下面这张图展示了环形缓冲区、动态扩展和内存管理三者之间的关系：

35.6 避坑指南

最后，分享几个我踩过的坑：

• 忘记处理“环回”情况。 读写指针在环上移动时，一定要用取模运算。直接用 pos++ 会越界。
• 动态扩展时没考虑原子性。 如果在多线程环境下扩展缓冲区，要加锁。否则另一个线程可能正在读写旧缓冲区。
• 引用计数溢出。 理论上 ref_count 不会无限增长，但万一代码有bug导致 retain 和 release 不匹配，计数会乱。建议在调试版本中加入断言检查。

嗯，协议缓冲区设计就聊到这里。说白了，环形缓冲区解决效率问题，动态扩展解决容量问题，内存管理解决安全问题。三者配合好了，你的网络程序才能跑得稳、跑得快。

---

公众号:蓝海资料掘金营，微信deep3321