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

这篇具有很好参考价值的文章主要介绍了1.4.C++项目:仿muduo库实现并发服务器之buffer模块的设计。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

项目完整版在:

一、buffer模块: 缓冲区模块

1.4.C++项目:仿muduo库实现并发服务器之buffer模块的设计,CodeCrafters,c++,开发语言,服务器
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;
}

中秋快乐!文章来源地址https://www.toymoban.com/news/detail-729418.html

到了这里,关于1.4.C++项目:仿muduo库实现并发服务器之buffer模块的设计的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 1.16.C++项目:仿muduo库实现并发服务器之HttpContext以及HttpServer模块的设计

    添加请求—— 处理函数映射信息(GET/POST/PUT/DELETE) 设置静态资源根目录 设置是否启动超时连接关闭 设置线程池中线程数量 启动服务器 OnConnected - 用于给TcpServer设置协议上下文 OnMessage - 用于进行缓冲区数据解析处理 获取上下文,进行缓冲区数据对象 请求的路由查 找 静态资

    2024年02月07日
    浏览(52)
  • 【项目设计】仿 muduo 库实现 OneThreadOneEventLoop 式并发服务器

    本项目主要是模仿 muduo 库实现一个以主从 Reactor 为模型,以 OneThreadOneEventLoop 为事件驱动的高并发服务器组件。通过这个服务器组件,我们可以简洁快速的搭建出一个高性能的 TCP 服务器。并且组件内部会提供不同的应用层协议支持,组件使用者可以通过这些协议快速的完成

    2024年04月23日
    浏览(64)
  • 一、C++项目:仿muduo库实现高性能高并发服务器

    仿mudou库one thread oneloop式并发服务器实现 仿muduo库One Thread One Loop式主从Reactor模型实现高并发服务器: 通过实现的高并发服务器组件,可以简洁快速的完成一个高性能的服务器搭建。并且,通过组件内提供的不同应用层协议支持,也可以快速完成一个高性能应用服务器的搭建

    2024年02月07日
    浏览(48)
  • 仿muduo库实现one thread one loop式并发服务器

      文章目录 一、项目简介 二、项目整体认识 2、1 HTTP服务器 2、2 Reactor模型 三、预备知识 3、1 C++11 中的 bind 3、2 简单的秒级定时任务实现 3、3 正则库的简单使用 3、4 通用类型any类型的实现 四、服务器功能模块划分与实现 4、1 Buffer模块 4、2 Socket模块 4、3 Channel模块 4、

    2024年04月09日
    浏览(53)
  • 基于muduo网络库实现的集群聊天服务器

    !!!项目是照着腾讯课堂施磊老师的视频学习,仅供个人学习记录使用!!! !!!项目是照着腾讯课堂施磊老师的视频学习,仅供个人学习记录使用!!! !!!项目是照着腾讯课堂施磊老师的视频学习,仅供个人学习记录使用!!! 使用muduo网络库搭建网络核心模块

    2024年04月26日
    浏览(34)
  • 【实战项目】c++实现基于reactor的高并发服务器

    基于Reactor的高并发服务器,分为反应堆模型,多线程,I/O模型,服务器,Http请求和响应五部分 ​全局 Channel 描述了文件描述符以及读写事件,以及对应的读写销毁回调函数,对应存储arg读写回调对应的参数 ​Channel 异或 |:相同为0,异为1 按位与:只有11为1,其它组合全部

    2024年02月12日
    浏览(51)
  • 基于多反应堆的高并发服务器【C/C++/Reactor】(中)Channel 模块的实现

    在这篇文章中虽然实现了能够和多客户端建立连接,并且同时和多个客户端进行通信。 基于多反应堆的高并发服务器【C/C++/Reactor】(上)-CSDN博客 https://blog.csdn.net/weixin_41987016/article/details/135141316?spm=1001.2014.3001.5501 但是有一个 问题(O_O)? : 这个程序它是单线程的。如果我们想

    2024年02月03日
    浏览(54)
  • C++项目——集群聊天服务器项目(一)项目介绍、环境搭建、Boost库安装、Muduo库安装、Linux与vscode配置

    今天开始想更新一个C++项目,实现一个 支持跨服务器通信、支持负载均衡的集群聊天服务器项目 。项目会应用muduo网络库、CMake编译、MySQL数据库、JSon序列化与反序列化、Redis消息订阅模式以及Nginx负载均衡功能。 有兴趣的宝可以跟我一起实操起来,巩固自己的C++学习吧~ 本项

    2024年04月14日
    浏览(57)
  • 模拟实现消息队列项目(系列4) -- 服务器模块(内存管理)

    目录 前言 1. 创建MemoryDataCenter 2. 封装Exchange 和 Queue方法 3. 封装Binding操作 4. 封装Message操作 4.1 封装消息中心集合messageMap 4.2 封装消息与队列的关系集合queueMessageMap的操作 5. 封装未确认消息集合waitMessage的操作 6. 从硬盘中恢复数据到内存中 7. MemoryDataCenter单元测试 结语    

    2024年02月14日
    浏览(42)
  • C++项目:仿mudou库one thread one loop式并发服务器实现

    目录 1.实现目标 2.HTTP服务器 3.Reactor模型 3.1分类 4.功能模块划分: 4.1SERVER模块: 4.2HTTP协议模块: 5.简单的秒级定时任务实现 5.1Linux提供给我们的定时器 5.2时间轮思想: 6.正则库的简单使用 7.通用类型any类型的实现 8.日志宏的实现 9.缓冲区buffer类的实现 10.套接字Socket类实现 11.

    2024年02月08日
    浏览(41)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包