1.4.C++项目:仿muduo库实现并发服务器之buffer模块的设计

项目完整版在:

一、buffer模块: 缓冲区模块

在这里插入图片描述
Buffer模块是一个缓冲区模块,用于实现通信中用户态的接收缓冲区和发送缓冲区功能。

二、提供的功能

存储数据,取出数据

三、实现思想

1.实现换出去得有一块内存空间,采用vector ,vector底层是一个线性的内存空间!

(一)要素

1.默认空间大小
2.当前的读取数据位置!
3.当前的写入数据位置!

(二)操作

  1. 写入位置
    当前写入位置指向哪里,从哪里开始写入
    如果后续剩余空间不够了!
  2. 考虑整体缓冲区空闲空间是否足够!(因为读位置也会向后偏移,前后有可能有空闲空间)
    足够:将数据移动到起始位置
    不够:扩容,从当前写位置开始扩容足够大小!
    数据一旦写入成功,当前写位置,向后偏移!
  3. 读取数据
    当前的读取位置指向哪里,就从哪里开始读取,前提是有数据可读
    可读数据大小:当前写入位置,减去当前读取位置!

(三)框架设计

class buffer {
    private:
        std::vector<char> _buffer;
        // 位置是一个相对偏移量,而不是绝对地址!
        uint64_t _read_idx; // 读位置
        uint64_t _write_idx; // 写位置
    public:
        1. 获取当前写的位置
        2. 确保可写空间足够
        3. 获取前沿空间大小
        4. 获取后沿空间大小
        5. 将写入据位置向后移动指定长度
        6. 获取当前读取位置的地址!
        7. 获取可读空间大小
        8. 将读位置向后移动指定长度!
        9. clear

四、实现代码

#include <ctime>
#include <cstring>
#include <iostream>
#include <vector>
#include <cassert>
#include <string>
using namespace std;
#define BUFFER_SIZE 1024
class Buffer {
    private:
        std::vector<char> _buffer; // 使用vector进行内存空间管理
        uint64_t _read_idx; // 读偏移
        uint64_t _write_idx; // 写偏移
    public:
        Buffer():_read_idx(0),_write_idx(0),_buffer(BUFFER_SIZE) {}
        char* begin() {return &*_buffer.begin();}
        // 获取当前写入起始地址
        char *writePosition() { return begin() + _write_idx;}
        // 获取当前读取起始地址
        char *readPosition() { return begin() + _read_idx; }
        // 获取缓冲区末尾空间大小 —— 写偏移之后的空闲空间,总体大小减去写偏移
        uint64_t tailIdleSize() {return _buffer.size() - _write_idx; }
        // 获取缓冲区起始空间大小 —— 读偏移之前的空闲空间
        uint64_t handIdleSize() {return _read_idx ;}
        // 获取可读空间大小 = 写偏移 - 读偏移 
        uint64_t readAbleSize() {return _write_idx - _read_idx ;} 
        // 将读偏移向后移动
        void moveReadOffset(uint64_t len) { 
          // 向后移动大小必须小于可读数据大小
              assert(len <= readAbleSize());
              _read_idx += len; 
          }
        // 将写偏移向后移动
        void moveWriteOffset(uint64_t len) { 
              assert(len <= tailIdleSize());
              _write_idx += len;
        }
        void ensureWriteSpace(uint64_t len)  {
          // 确保可写空间足够 (整体空间够了就移动数据,否则就扩容!)  
            if (tailIdleSize() >= len) return;
            // 不够的话 ,判断加上起始位置够不够,够了将数据移动到起始位置
            if (len <= tailIdleSize() + handIdleSize()) {
                uint64_t rsz = readAbleSize(); //帮当前数据大小先保存起来
                std::copy(readPosition(),readPosition() + rsz,begin()); // 把可读数据拷贝到起始位置
                _read_idx = 0; // 读归为0
                _write_idx = rsz; // 可读数据大小是写的偏移量!
            }
            else { // 总体空间不够!需要扩容,不移动数据,直接给写偏移之后扩容足够空间即可!
                _buffer.resize(_write_idx + len);

            }
        }
        // 写入数据
        void Write(const void *data,uint64_t len) {
        
                ensureWriteSpace(len);
                const char *d = (const char*) data;
                std::copy(d,d + len,writePosition());
        }
        void WriteAndPush(void* data,uint64_t len) {
                Write(data,len);
                moveWriteOffset(len);
        }
         void WriteStringAndPush(const std::string &data) {
            writeString(data);
           
            moveWriteOffset(data.size());
           
        }
        void writeString(const std::string &data) {
                return Write(data.c_str(),data.size());
        }
        void writeBuffer(Buffer &data) {
                return Write(data.readPosition(),data.readAbleSize());
        }
        void writeBufferAndPush(Buffer &data) {
                writeBuffer(data);
                moveWriteOffset(data.readAbleSize());
                
        }
        std::string readAsString (uint64_t len) {
                assert(len <= readAbleSize());
                std::string str;
                str.resize(len);
                Read(&str[0],len);
                return str;
        }
        void Read(void *buf,uint64_t len) {
                // 读取数据 1. 保证足够的空间 2.拷贝数据进去
                // 要求获取的大小必须小于可读数据大小!
                assert(len <= readAbleSize());
                std::copy(readPosition(),readPosition() + len,(char*)buf);
        }
        void readAndPop(void *buf,uint64_t len) {
                Read(buf,len);
                moveReadOffset(len);
        }
        // 逐步调试!!!!!
        std::string ReadAsStringAndPop(uint64_t len) {
            assert(len <= readAbleSize());
            std::string str = readAsString(len);
            moveReadOffset(len);
            return str;
        }
        char* FindCRLF() {
                char *res = (char*)memchr(readPosition(),'\n',readAbleSize());
                return res;
        }
        // 通常获取一行数据,这种情况针对是:
        std::string getLine() {
                char* pos = FindCRLF();
                if (pos == NULL) {
                    return "";
                }
                // +1 为了把换行数据取出来!
                return readAsString(pos - readPosition() + 1);
        }
        std::string getLineAndPop() {
                std::string str = getLine();
                moveReadOffset(str.size());
                return str;
        }
        void Clear() { // 清空缓冲区!clear
                // 只需要将偏移量归0即可!
                _read_idx = 0;
                _write_idx = 0;
        }
};

五、进行测试

#include "server.hpp"
using namespace std;
// 控制打印信息!!!
#define INF 0
#define DBG 1
#define ERR 2
#define LOG_LEVEL INF
    #define LOG(level,format,...) do{\
    if (level < LOG_LEVEL) break;\
    time_t t = time(NULL);\
    struct tm *ltm = localtime(&t);\
    char tmp[23] = {0};\
    strftime(tmp,31,"%H:%M:%S",ltm);\
    fprintf(stdout,"[%s,%s:%d] " format "\n",tmp,__FILE__,__LINE__,##__VA_ARGS__);\
}while(0)

#define INF_LOG(format, ...) LOG(INF, format, ##__VA_ARGS__)
#define DBG_LOG(format, ...) LOG(DBG, format, ##__VA_ARGS__)
#define ERR_LOG(format, ...) LOG(ERR, format, ##__VA_ARGS__)

int main() {
    Buffer buf;
    std::string str = "hello!";
    // buf.WriteStringAndPush(str);
    // Buffer buf1;
    // buf1.writeBufferAndPush(buf);
    // std::string tmp;
    // tmp = buf1.ReadAsStringAndPop(buf.readAbleSize());
    // cout << tmp << endl;
    // cout << buf.readAbleSize() << endl;
    // cout << buf1.readAbleSize() << endl;
    for (int i = 0; i < 300; i ++) {
        std::string str = "hello" + std::to_string(i) + '\n';
        buf.WriteStringAndPush(str);
    }
    while(buf.readAbleSize() > 0) {
        string line = buf.getLineAndPop();
        LOG("hello");  
    }
    // string tmp;
    // tmp = buf.ReadAsStringAndPop(buf.readAbleSize());
    // cout << tmp << endl;
    
    return 0;
}

中秋快乐!

  • 2
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
### 回答1: Linux多线程服务端编程是指使用Muduo C网络在Linux操作系统中进行多线程的服务端编程。Muduo C网络是一个基于事件驱动的网络,采用了Reactor模式,并且在底层使用了epoll来实现高效的I/O复用。 使用Muduo C网络进行多线程服务端编程有以下几个步骤: 1. 引入Muduo C网络:首先需要下载并引入Muduo C网络的源代码,然后在编写代码时包含相应的头文件。 2. 创建并初始化EventLoop:首先需要创建一个EventLoop对象,它用于接收和分发事件。通过初始化函数进行初始化,并在主线程中调用它的loop()函数来运行事件循环。 3. 创建TcpServer:然后创建一个TcpServer对象,它负责监听客户端的连接,并管理多个TcpConnection对象。通过设置回调函数,可以在特定事件发生时处理相应的逻辑。 4. 创建多个EventLoopThread:为了提高并发性能,可以创建多个EventLoopThread对象,每个对象负责一个EventLoop,从而实现多线程处理客户端的连接和请求。 5. 处理事件:在回调函数中处理特定事件,例如有新的连接到来时会调用onConnection()函数,可以在该函数中进行一些初始化操作。当有数据到来时会调用onMessage()函数,可以在该函数中处理接收和发送数据的逻辑。 6. 运行服务端:在主线程中调用TcpServer的start()函数来运行服务端,等待客户端的连接和请求。 总的来说,使用Muduo C网络进行Linux多线程服务端编程可以更好地利用多核处理器的性能优势。每个线程负责处理特定事件,通过事件驱动模式实现高效的网络编程。这样可以提高服务器并发能力,提高系统的整体性能。 ### 回答2: Linux多线程服务端编程是指在Linux平台上使用多线程的方式来编写网络服务器程序。而使用muduo C网络是一种常见的方法,它提供了高效的网络编程接口,可以简化多线程服务器开发过程。 muduo C网络基于Reactor模式,利用多线程实现了高并发的网络通信。在使用muduo C进行多线程服务端编程时,我们可以按照以下步骤进行: 1. 引入muduo:首先需要导入muduo C网络的头文件,并链接对应的文件,以供程序调用。 2. 创建线程池:利用muduo C中的ThreadPool类创建一个线程池,用于管理和调度处理网络请求的多个线程。 3. 创建TcpServer对象:使用muduo C中的TcpServer类创建一个服务器对象,监听指定的端口,并设置好Acceptor、TcpConnectionCallback等相关回调函数。 4. 定义业务逻辑:根据具体的业务需求,编写处理网络请求的业务逻辑代码,如接收客户端的请求、处理请求、发送响应等。 5. 注册业务逻辑函数:将定义好的业务逻辑函数注册到TcpServer对象中,以便在处理网络请求时调用。 6. 启动服务器:调用TcpServer对象的start函数,启动服务器,开始监听端口并接收客户端请求。 7. 处理网络请求:当有客户端连接到服务器时,muduo C会自动分配一个线程去处理该连接,执行注册的业务逻辑函数来处理网络请求。 8. 释放资源:在程序结束时,需要调用相应的函数来释放使用的资源,如关闭服务器、销毁线程池等。 通过使用muduo C网络,我们可以简化多线程服务端编程的过程,提高服务器并发处理能力。因为muduo C网络已经实现了底层的网络通信细节,我们只需要专注于编写业务逻辑代码,从而减少开发的工作量。同时,muduo C的多线程模型可以有效地提高服务器并发性能,满足高并发网络服务的需求。 ### 回答3: Linux多线程服务端编程是指在Linux操作系统上开发多线程的服务器应用程序。使用muduo C网络有助于简化开发过程,提供高效的网络通信能力。 muduo C网络是一个基于Reactor模式的网络,适用于C++语言,由Douglas Schmidt的ACE网络演化而来。它提供了高度并发的网络编程能力,封装了许多底层细节,使得开发者能够更加专注于业务逻辑的实现。 在开发过程中,首先需要创建一个muduo C的EventLoop对象来管理事件循环。然后,可以利用TcpServer类来创建服务器并监听指定的端口。当有新的客户端请求到达时,muduo C会自动调用用户定义的回调函数处理请求。 在处理请求时,可以使用muduo C提供的ThreadPool来创建多个工作线程。这些工作线程将负责处理具体的业务逻辑。通过将工作任务分配给不同的线程,可以充分利用多核服务器的计算资源,提高服务器的处理能力。 在具体的业务逻辑中,可以使用muduo C提供的Buffer类来处理网络数据。Buffer类提供了高效的数据读写操作,可以方便地进行数据解析与封装。 此外,muduo C还提供了TimerQueue类来处理定时任务,可以用于实现定时事件的调度与管理。这对于一些需要定期执行的任务非常有用,如心跳检测、定时备份等。 总之,使用muduo C网络可以简化Linux多线程服务端编程的开发过程,提供高效的并发能力。通过合理地利用多线程和其他的相关组件,可以实现高性能、稳定可靠的网络服务端应用程序。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值