基于多反应堆的高并发服务器【C/C++/Reactor】(中)Buffer的创建和销毁、扩容、写入数据

TcpConnection:封装的就是建立连接之后得到的用于通信的文件描述符,然后基于这个文件描述符,在发送数据的时候,需要把数据先写入到一块内存里边,然后再把这块内存里边的数据发送给客户端,除了发送数据,剩下的就是接收数据。接收数据,把收到的数据先存储到一块内存里边。也就意味着,无论是发送数据还是接收数据,都需要一块内存。并且这块内存是需要使用者自己去创建的。所以就可以把这块内存做封装成Buffer。

基于多反应堆的高并发服务器【C/C++/Reactor】(中)Buffer的创建和销毁、扩容、写入数据_第1张图片

>>>>>>>>>>>>>>>>>>>>>>>>>>>>学习笔记>>>>>>>>>>>>>>>>>>>>>>>>>>>>

1.文件描述符与数据发送:

  • 在发送数据时,需要先将数据写入内存缓冲区(buffer)。
  • 内存缓冲区可以通过封装成一个Buffer结构体来实现
  • Buffer结构体中包含一个指向内存的指针(data)、内存总大小(capacity)、读数据位置(readPos)和写数据位置(writePos)等成员

2.Buffer结构体及其成员说明:

  • 指针:指向内存地址(data)
  • 总大小:内存块的字节数(capacity)
  • 读位置:当前读取数据的位置(readPos)
  • 写位置:当前写入数据的位置(writePos)

3.Buffer API函数:

  • 提供一系列API函数,以便对buffer中的内存进行操作
  • 主要操作包括初始化buffer和进行读写操作

4.初始化Buffer:

  • 需要为buffer申请指定大小的堆内存
  • 使用malloc函数申请堆内存,并将内存地址返回给调用者
  • 初始化buffer结构体中的成员,包括data指针、容量、读位置和写位置
  • data指针需要指向一个有效的内存块,因此需要再次申请内存
  • 使用memset函数将data指针指向的内存块初始化为零
  • 返回buffer指针给调用者

>>>>>>>>>>>>>>>>>>>>>>>>>>>>Buffer的创建和销毁>>>>>>>>>>>>>>>>>>>>>>>>>>>>

  • Buffer.h 
struct Buffer {
    // 指向内存的指针
    char* data;
    int capacity;
    int readPos;
    int writePos;
}

 (一)Buffer的初始化

// 初始化
struct Buffer* bufferInit(int size);
// 初始化
struct Buffer* bufferInit(int size) {
    struct Buffer* buffer = (struct Buffer*)malloc(sizeof(struct Buffer));
    if(buffer!=NULL) {
        buffer->data = (char*)malloc(sizeof(char) * size);
        buffer->capacity = size;
        buffer->readPos = buffer->writePos = 0;
        memset(buffer->data, 0, size);
    }
    return buffer;
}

 (二)Buffer的销毁

// 销毁
void bufferDestroy(struct Buffer* buf);
// 销毁
void bufferDestroy(struct Buffer* buf) {
    if(buf!=NULL) {
        if(buf->data!=NULL) { // buf->data指向有效的堆内存
            free(buf->data); // 释放
        }
    }
    free(buf);
}


>>>>>>>>>>>>>>>>>>>>>>>>>>>>Buffer的扩容>>>>>>>>>>>>>>>>>>>>>>>>>>> 

(一)readPoswritePos 相对位置发生变化的三种情况:

(1)Buffer初始时 - 未写入任何数据

基于多反应堆的高并发服务器【C/C++/Reactor】(中)Buffer的创建和销毁、扩容、写入数据_第2张图片

(2)Buffer - 写入了部分数据

基于多反应堆的高并发服务器【C/C++/Reactor】(中)Buffer的创建和销毁、扩容、写入数据_第3张图片

  • 剩余的可写的内存容量 = 可写数据内存大小
// 得到剩余的可写的内存容量
int bufferWriteableSize(struct Buffer* buf);
// 得到剩余的可写的内存容量
int bufferWriteableSize(struct Buffer* buf) {
    return buf->capacity - buf->writePos;
}

 (3)Buffer - 写入了部分数据并读出了部分数据

基于多反应堆的高并发服务器【C/C++/Reactor】(中)Buffer的创建和销毁、扩容、写入数据_第4张图片

  • 计算已写数据内存(未读)的大小 
// 已写数据内存(未读)的大小 --- 得到剩余的可读的内存容量
int bufferReadableSize(struct Buffer* buf);
// 已写数据内存(未读)的大小 --- 得到剩余的可读的内存容量
int bufferReadableSize(struct Buffer* buf) {
    return buf->writePos - buf->readPos;
}

对于内存数据已读的区域的数据为无效数据,此处的无效指的是内存数据,由于数据已经被读了出来,故这里边的数据已经无效了。对于这个图来说,剩余的可用内存块一共有多大呢? 

  • 剩余的可写的内存容量 = 内存数据已读大小 + 可写数据内存大小

但这个是理论值,因为这两块内存不是连续的,故即使空间够存储,但是不连续的存放会导致读写麻烦。此时的解决方案是:移动内存实现合并内存

基于多反应堆的高并发服务器【C/C++/Reactor】(中)Buffer的创建和销毁、扩容、写入数据_第5张图片

(1)先获取已写数据内存(未读)这块内存的大小,将值赋给readableSize

// 得到已写但未读的内存大小
int readableSize = bufferReadableSize(buf);

(2)然后把这块内存的数据拷贝到前面去,这就实现了合并

// 移动内存实现合并
memcpy(buf->data, buf->data + buf->readPos, readableSize);

 (3)更新位置

// 更新位置
buf->readPos = 0;
buf->writePos = readableSize;

(二)Buffer扩容

当往buffer中写入数据时,如果剩余的内存不足以容纳新的数据,需要进行扩容。有三种情况需要考虑:     

  1. 剩余的可写的内存容量够用- 不需要扩容
  2. 内存需要合并才够用 - 不需要扩容
  3. 内存不够用 - 需要扩容
// 扩容
void bufferExtendRoom(struct Buffer* buf, int size);
// 扩容
void bufferExtendRoom(struct Buffer* buf, int size) {
    // 1.内存够用 - 不需要扩容
    if(bufferWriteableSize(buf)>= size) {
        return;
    }
    // 2.内存需要合并才够用 - 不需要扩容
    // 剩余的可写的内存 +  已读的内存 >= size
    else if(bufferWriteableSize(buf) + bufferReadableSize(buf) >= size) {
        // 得到已写但未读的内存大小
        int readableSize = bufferReadableSize(buf);
        // 移动内存实现合并
        memcpy(buf->data, buf->data + buf->readPos, readableSize);
        // 更新位置
        buf->readPos = 0;
        buf->writePos = readableSize;
    }
    // 3.内存不够用 - 需要扩容
    else{
        void* temp = realloc(buf->data, buf->capacity + size);
        if(temp ==NULL) {
            return;// 失败了
        }  
        memset(temp + buf->capacity, 0, size);// 只需要对拓展出来的大小为size的内存块进行初始化就可以了
        // 更新数据
        buf->data = temp;
        buf->capacity += size;
    }
}

>>>>>>>>>>>>>>>>>>>>>>>>>>>>往Buffer里写入数据>>>>>>>>>>>>>>>>>>>>>>>>>>> 

(1)直接写  

// 写内存 1.直接写 
int bufferAppendData(struct Buffer* buf, const char* data, int size); 

int bufferAppendString(struct Buffer* buf, const char* data); 
// 写内存 1.直接写 
int bufferAppendData(struct Buffer* buf, const char* data, int size) {
    // 判断传入的buf是否为空,data指针指向的是否为有效内存,以及数据大小是否大于零
    if(buf == NULL || data == NULL || size <= 0) {
        return -1;
    }
    // 扩容(试探性的)
    bufferExtendRoom(buf,size);
    // 数据拷贝
    memcpy(buf->data + buf->writePos, data, size);
    // 更新写位置
    buf->writePos += size;
    return 0;
}

int bufferAppendString(struct Buffer* buf, const char* data) {
    int size = strlen(data);
    int ret = bufferAppendData(buf, data, size);
    return ret;
}

实现bufferAppendData函数重点:

1. 实现写内存函数时,需要判断传入的buf是否为空,data指针指向的是否为有效内存,以及数据大小是否大于零

2. 在写数据之前,需要进行内存扩容(试探性的,可能剩余的可写容量就够写入那就不必扩容)

3. 写数据时,需要从上次写入的writePos位置开始

4. 数据写入完成后,需要更新writePos的位置

总结:在实现bufferAppendData函数时,需要考虑如何处理内存的写入和接收数据的情况。在写数据之前,可能需要进行内存扩容以确保有足够的空间。写数据时,需要从上次写入的writePos位置开始。完成写入后,需要再次更新writePos的位置。

(2)接收套接字数据

#include 
ssize_t readv(int fd, const struct iovec *iov, int iovcnt);
struct iovec {
    void  *iov_base;    /* Starting address */
    size_t iov_len;     /* Number of bytes to transfer */
};

功能:readv函数从文件描述符(包括TCP Socket)中读取数据,并将读取的数据存储到指定的多个缓冲区中。
-> 成功时返回接收的字节数,失败时返回-1

filedes 传递接收数据的文件(套接字)描述符
iov 包含数据保存位置和大小的iovec结构体数组的地址值
iovcnt 第二个参数中数组的长度

fd:要读取数据的文件描述符,可以是TCP Socket。
iov:存储读取数据的多个缓冲区的数组。
iovcnt:缓冲区数组的长度。
返回值:成功时返回实际读取的字节数,失败时返回-1,并设置errno变量来指示错误的原因。

read/recv/readv  在接收数据的时候,

  • read/recv 只能指定一个数组
  • readv 能指定多个数组(也就是说第一个用完,用第二个...)

readv函数可以一次接收多个缓冲区中的数据,并在内核中减少了多次系统调用的开销。

// 写内存 2.接收套接字数据
int bufferSocketRead(struct Buffer* buf,int fd);
  • bufferSocketRead函数实现功能:当调用这个bufferSocketRead函数之后,一共接收到了多少个字节
  • bufferSocketRead函数具体细节:在这个函数里边,通过malloc申请了一块临时的堆内存(tmpbuf),这个堆内存是用来接收套接字数据的。当buf里边的数组容量不够了,那么就使用这块临时内存来存储数据,还需要把tmpbuf这块堆内存里边的数据再次写入到buf中。当用完了之后,需要释放内存。
// 写内存 2.接收套接字数据
int bufferSocketRead(struct Buffer* buf,int fd) {
    struct iovec vec[2]; // 根据自己的实际需求来
    // 初始化数组元素
    int writeableSize = bufferWriteableSize(buf); // 得到剩余的可写的内存容量
    // 0号数组里的指针指向buf里边的数组,记得 要加writePos,防止覆盖数据
    vec[0].iov_base = buf->data + buf->writePos;
    vec[0].iov_len = writeableSize;

    char* tmpbuf = (char*)malloc(40960); // 申请40k堆内存
    vec[1].iov_base = buf->data + buf->writePos;
    vec[1].iov_len = 40960;
    // 至此,结构体vec的两个元素分别初始化完之后就可以调用接收数据的函数了
    int result = readv(fd, vec, 2);// 表示通过调用readv函数一共接收了多少个字节
    if(result == -1) {
        return -1;// 失败了
    }
    else if (result <= writeableSize) { 
        // 说明在接收数据的时候,全部的数据都被写入到vec[0]对应的数组里边去了,全部写入到
        // buf对应的数组里边去了,直接移动writePos就好
        buf->writePos += result;
    }
    else {
        // 进入这里,说明buf里边的那块内存是不够用的,
        // 所以数据就被写入到我们申请的40k堆内存里边,还需要把tmpbuf这块
        // 堆内存里边的数据再次写入到buf中。
        // 先进行内存的扩展,再进行内存的拷贝,可调用bufferAppendData函数
        // 注意一个细节:在调用bufferAppendData函数之前,通过调用readv函数
        // 把数据写进了buf,但是buf->writePos没有被更新,故在调用bufferAppendData函数
        // 之前,需要先更新buf->writePos
        buf->writePos = buf->capacity; // 需要先更新buf->writePos
        bufferAppendData(buf, tmpbuf, result - writeableSize);
    }
    free(tmpbuf);
    return result;
}

你可能感兴趣的:(基于多反应堆的,C/C++/Reactor,高并发服务器,Buffer的创建和销毁)