高性能服务器之Reactor设计

最新推荐文章于 2023-09-07 19:58:44 发布
最新推荐文章于 2023-09-07 19:58:44 发布
阅读量411 收藏 2
点赞数 5
分类专栏： Linux 博客 文章标签： 服务器 c++ 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_58724706/article/details/127682705
版权

                                   

        今天来针对上一节课讲的多路转接知识再进一步进行设计，Reactor是基于epoll的ET模式设计的，在现在的高校和企业中是广泛应用的，今天我们来实现一个简洁版，完整版博主可没那个实力~

目录

基本原理

代码实现 

epoll_server.cc

Accepter.hpp

Reactor.hpp

Service.hpp

Sock.hpp

Util.hpp

Makefile

测试结果

基本原理

        Reactor负责接收事件并关心对应文件描述符读写事件，当epoll中就绪队列有数据时，把事件派发给连接管理器，Accepter调用对应的读写模块。

代码实现 

epoll_server.cc

#include "Reactor.hpp"
#include"Sock.hpp"
#include<stdlib.h>
#include<unistd.h>
#include"Accepter.hpp"
#include"Util.hpp"

static void Usage(std::string proc)
{
    std::cout << "Usage: " << "\n\t" << proc << " port" << std::endl;
}
int main(int argc, char* argv[])
{
    if(argc != 2)
    {
        Usage(argv[0]);
        exit(1);
    }
    //1、创建socket, 监听
    int listen_sock = Sock::Socket();
    SetNonBlock(listen_sock);//listen_sock设置为非阻塞
    Sock::Bind(listen_sock, (uint16_t)atoi(argv[1]));
    Sock::Listen(listen_sock);

    //2、创建Reactor对象
    //Reactor 反应堆模式: 通过多路转接方案, 被动的采用事件派发的方式, 去反向的调用对应的回调函数
    //1. 检测到事件 -- epoll
    //2. 派发事件 - Dispatcher (事件派发 + IO) + 业务处理: 半同步半异步的处理方式
    //3. 链接 -- accepter
    //4. IO -- recver, sender
    Reactor* R = new Reactor();
    R->InitReactor();

    //3、 给Reactor反应堆中加柴火
    //3.1 有柴火
    Event* evp = new Event;
    evp->sock = listen_sock;
    evp->R = R; //指向柴火加的反应堆

    
    //Accepter链接管理器
    evp->RegisterCallBack(Accepter, nullptr, nullptr);

    //3.2 将准备好的柴火放入反应堆Reactor中
    R->InsertEvent(evp, EPOLLIN | EPOLLET); //设置ET模式

    //4. 开始进行事件派发
    for(; ;)
    {
        R->Dispatcher(1000); //事件派发
    }
    return 0;
}

Accepter.hpp

#pragma once

#include<iostream>
#include"Reactor.hpp"
#include"Sock.hpp"
#include"Service.hpp"
#include"Util.hpp"

int Accepter(Event* evp)
{
    std::cout << "有新的链接到来了, 就绪的sock是: " << evp->sock << std::endl;
    //经过这样的死循环，会不断的把链接构建成event结构添加到反应堆中
    while(true)
    {
        int sock = Sock::Accept(evp->sock);
        if(sock < 0)
        {
            std::cout << "Accept Done!" << std::endl;
            break;
        }
        std::cout << "Accept success: " << sock << std::endl;
        SetNonBlock(sock);
        //获取链接成功, IO socket
        Event* other_ev = new Event();
        other_ev->sock = sock;
        other_ev->R = evp->R; //为什么要让所有的Event指向自己所属的Reactor??

        //recver sender error 就是我们代码中的较顶层, 只负责读取!
        other_ev->RegisterCallBack(Recver, Sender, Error);

        //不能同时设置EPOLLOUT和EPOLLIN, 这样服务器会一直死循环，服务器性能大大降低
        evp->R->InsertEvent(other_ev, EPOLLIN|EPOLLET); 
    }
    return 0;
}

Reactor.hpp

#pragma once

#include<iostream>
#include<string>
#include<sys/epoll.h>
#include<unordered_map>
#include<stdlib.h>
#include<unistd.h>


//一般处理IO的时候, 我们只有三种接口需要处理
//处理写入
//处理读取
//处理异常

class Event; //声明
class Reactor;
#define SIZE 128
#define NUM 64

typedef int (*callback_t)(Event* ev); //函数指针类型

//需要让epoll管理的基本结点
class Event
{
public:
    int sock; //对应的文件描述符
    std::string inbuffer;//对应的sock, 对应的输入缓冲区->粘包问题解决
    std::string outbuffer; //对应的sock, 对应的输入缓冲区->epoll发送出去

    //sock设置回调
    callback_t recver;
    callback_t sender;
    callback_t errorer;

    //设置Event回指Reactor的指针
    Reactor* R;
public:
    Event()
    {
        sock = -1;
        recver = nullptr;
        sender = nullptr;
        errorer = nullptr;
        R = nullptr;
    }
    ~Event()
    {}
    //设置回调
    void RegisterCallBack(callback_t _recver, callback_t _sender, callback_t _errorer)
    {
        recver = _recver;
        sender = _sender;
        errorer = _errorer;
    }
};

//不需要关心任何sock的类型(listen, 读, 写)
//如何进行使用该类, 对Event进行管理
class Reactor
{
private:
    int epfd;
    std::unordered_map<int, Event*> events; //我的Epoll类管理的所有的Event的集合
public:
    Reactor()
        :epfd(-1)
    {}
    ~Reactor()
    {}
    void InitReactor()
    {
        epfd = epoll_create(SIZE);
        if(epfd < 0)
        {
            std::cerr << "epoll_create error" << std::endl;
            exit(2);
        }
        std::cout << "InitReactor success" << std::endl;
    }
    //增加
    bool InsertEvent(Event* evp, uint32_t evs)
    {
        //1、将sock中的sock插入到epoll中
        struct epoll_event ev;
        ev.events = evs;
        ev.data.fd = evp->sock;
        if(epoll_ctl(epfd, EPOLL_CTL_ADD, evp->sock, &ev) < 0) //-1失败, 0成功
        {
            std::cerr << "epoll_ctl add event failed" << std::endl;
            return false;
        }
        //2、将ev本身插入到unordered_map中
        events.insert({evp->sock, evp});//evp是维护的一个Event结点
        return true;
    }
    void DeleteEvent(Event* evp)
    {
        int sock = evp->sock;
        auto iter = events.find(sock);
        if(iter != events.end())//找到了
        {
            //1、将sock中的sock从epoll中删除
            epoll_ctl(epfd, EPOLL_CTL_DEL, sock, nullptr);//删除不关心events事件,所以设置成nullptr

            //2. 把特定的ev 从unordered_map中移除
            events.erase(iter);

            //3、close
            close(sock);

            //4、删除event结点 -->它是new出来的, 要手动释放
            delete evp;
        }
    }

    //关于修改, 也是最后看, 使能读写
    bool EnableRW(int sock, bool enbread, bool enbwrite)
    {
        struct epoll_event ev;
        ev.events = EPOLLET | (enbread ? EPOLLIN : 0) | (enbwrite ? EPOLLOUT : 0);
        ev.data.fd = sock;

        if(epoll_ctl(epfd, EPOLL_CTL_MOD, sock, &ev) < 0)
        {
            std::cerr << "epoll_ctl mod event failed" << std::endl;
            return false;
        }
        return true;
    }

    //判断sock是否是合法的
    bool IsSockOK(int sock)
    {
        auto iter = events.find(sock);
        return iter != events.end(); //找到就合法
    }

    //就绪事件的派发逻辑
    void Dispatcher(int timeout) //将就绪事件派发给sock
    {
        struct epoll_event revs[NUM];
        int n = epoll_wait(epfd, revs, NUM, timeout);
        for(int i = 0; i < n; i++) //n 表示就绪的fd个数, 维护在了数组里面
        {
            int sock = revs[i].data.fd;
            uint32_t revents = revs[i].events; //本次文件描述符就绪的事件
            //代表差错处理, 将所有的错误问题全部转化成为让IO函数去解决
            if(revents & EPOLLERR)
            {
                revents |= (EPOLLIN | EPOLLOUT); //设置读写
            }
            if(revents & EPOLLHUP) //对端链接关闭
            {
                revents |= (EPOLLIN | EPOLLOUT); //设置读写
            }
            //读数据就绪, 可能有bug,后面解决
            if(revents & EPOLLIN)
            {
                //直接调用回调方法, 执行对应的读取
                if(IsSockOK(sock) && events[sock]->recver) //recever是回调
                {
                    events[sock]->recver(events[sock]);
                }
            }
            if(revents & EPOLLOUT)
            {
                //直接调用回调方法, 执行对应的读取
                if(IsSockOK(sock) && events[sock]->sender)
                {
                    events[sock]->sender(events[sock]);
                }
            }
        }
    }
};

Service.hpp

#pragma once
#include "Reactor.hpp"
#include <vector>
#include <errno.h>
#include"Util.hpp"

#define ONCE_SIZE 128

//1: 本轮读取全部完成
//-1: 读取出错
//0: 对端关闭链接
static int RecverCore(int sock, std::string &inbuffer)
{
    while (true)
    {
        char buffer[ONCE_SIZE];
        ssize_t s = recv(sock, buffer, ONCE_SIZE - 1, 0);
        if (s > 0)
        {
            //读取成功
            buffer[s] = 0;
            inbuffer += buffer;
        }
        else if (s < 0)
        {
            if(errno == EINTR)
            {
                //IO被信号打断, 概率特别低
                continue;
            }
            //errno会被自动设置
            if (errno == EAGAIN || errno == EWOULDBLOCK)
            {
                // 1、读完, 底层没数据了
                return 1; //success
            }
            // 2、真的出错了
            return -1;
        }
        else // s == 0
        {
            return 0;
        }
    }
}

int Recver(Event *evp)
{
    std::cout << "Recver been called" << std::endl;
    // 1、真正的读取
    int result = RecverCore(evp->sock, evp->inbuffer);
    if(result <= 0)
    {
        //差错处理
        if(evp->errorer)
        {
            evp->errorer(evp);
        }
        return -1;
    }
    //1+2X2+3X5+6X
    // 2、分包 -- 一个或者多个报文 -- 解决粘包问题
    std::vector<std::string> tokens;
    std::string sep = "X";
    SplitSegment(evp->inbuffer, &tokens, sep); //从缓冲区读取字节到tokens

    // 3、反序列化 -- 针对一个报文 提取有效参与计算或者存储的信息
    for (auto &seg : tokens)
    {
        std::string data1, data2;
        if(Deserialize(seg, &data1, &data2)) //就是和业务强相关了
        {
            // 4、业务逻辑 -- 得到结果
            int x = atoi(data1.c_str());
            int y = atoi(data2.c_str());
            int z = x + y;
            // 5、构建响应 -- 添加到evp->outbuffer!!
            // 1+2X ---> 1+2=3X
            std::string res = data1;
            res += "+";
            res += data2;
            res += "=";
            res += std::to_string(z);
            res += sep;

            //send?? 不能直接send!!!
            evp->outbuffer += res; //把数据写入自己维护的缓冲区
        }
    }

    // 6、尝试直接/间接进行发送 -- 后续说明
    //必须条件成熟了(写事件就绪), 你才能发送呢??
    //一般只要将报文处理完毕, 才需要发送
    //写事件一般都是就绪的, 但是用户不一定是就绪的!
    //对于写事件, 我们通常是按需设置!!
    if(!(evp->outbuffer).empty())
    {
        //写打开的时候, 默认就是就绪的, 即便是发送缓冲区已经满了
        //epoll 只要用户重新设置了OUT事件, EPOLLOUT至少会触发一次
        evp->R->EnableRW(evp->sock, true, true); //读写使能开启
    }
    return 0;
}

//1: 数据全部发完
//0: 数据没有发完, 但是不能再发了
//-1:发送失败
int SenderCore(int sock, std::string& outbuffer)
{
    while(true)
    {
        int total = 0; //本轮累计发送的数据量
        const char* start = outbuffer.c_str();
        int size = outbuffer.size();
        ssize_t curr = send(sock, start + total, size - total, 0);
        if(curr > 0)
        {
            total += curr;
            if(total == size)
            {
                //全部将数据发送完成
                outbuffer.clear();
                return 1;
            }
        }
        else
        {
            //数据没有发送完成, 但是不能在发送了
            if(errno == EINTR) //IO信号中断
            {
                continue;
            }
            if(errno == EAGAIN || errno == EWOULDBLOCK) //发送缓冲区满了
            {
                outbuffer.erase(0, total);
                return 0;
            }
            return -1;
        }
    }
}
int Sender(Event *evp)
{
    std::cout << "Sender been called" << std::endl;
    //1: 数据全部发完
    //0: 数据没有发完, 但是不能再发了
    //-1:发送失败
    int result = SenderCore(evp->sock, evp->outbuffer);
    if(result == 1)
    {
        evp->R->EnableRW(evp->sock, true, false); //按需设置
    }
    else if(result == 0)
    {
        //可以什么也不做
        evp->R->EnableRW(evp->sock, true, false);
    }
    else
    {
        if(evp->errorer)
        {
            evp->errorer(evp); //errorer统一处理差错
        }
    }
    return 0;
}

int Error(Event *evp)
{
    std::cout << "Error been called" << std::endl;
    evp->R->DeleteEvent(evp);
    return 0;
}

Sock.hpp

#pragma once
#include <iostream>
#include <string>
#include <string.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

using namespace std;

class Sock
{
public:
    static int Socket()
    {
        int sock = socket(AF_INET, SOCK_STREAM, 0); // UDP
        if (sock < 0)
        {
            cerr << "socket err" << endl;
            exit(2);
        }
        return sock;
    }
    static void Bind(int sock, uint16_t port)
    {
        struct sockaddr_in local;
        memset(&local, 0, sizeof(local));
        local.sin_family = AF_INET;
        local.sin_port = htons(port);
        local.sin_addr.s_addr = INADDR_ANY; //服务端,ip地址

        if (bind(sock, (struct sockaddr *)&local, sizeof(local)) < 0)
        {
            cerr << "bind error" << endl;
            exit(3);
        }
    }

    static void Listen(int sock)
    {
        if (listen(sock, 5) < 0)
        {
            cerr << "listen error" << endl;
            exit(4);
        }
    }

    static int Accept(int sock)
    {
        struct sockaddr_in peer;
        socklen_t len = sizeof(peer);
        int fd = accept(sock, (struct sockaddr *)&peer, &len);
        if(fd >= 0)
        {
            return fd;
        }
        return -1;
    }

    static void Connect(int sock, string ip, uint16_t port)
    {
        struct sockaddr_in server;
        memset(&server, 0, sizeof(server));

        server.sin_family = AF_INET;
        server.sin_port = htons(port);
        server.sin_addr.s_addr = inet_addr(ip.c_str());//字符串->整型,大小端解决了
        //inet_ntoa 整型->字符串

        if(connect(sock, (struct sockaddr*)&server, sizeof(server)) == 0)
        {
            cout << "Connect Success" << endl;
        }
        else
        {
            cout << "Connect Failed" << endl;
            exit(5); 
        }
    }
};

Util.hpp

#pragma once
#include<iostream>
#include<unistd.h>
#include<fcntl.h>


//工具类
//设置一个sock成为非阻塞
void SetNonBlock(int sock)
{
    int f1 = fcntl(sock, F_GETFL);
    if(f1 < 0)
    {
        std::cerr << "fcntl failed" << std::endl;
        return;
    }
    fcntl(sock, F_SETFL, f1|O_NONBLOCK);//设置非阻塞
}

//1+2X2+3X5+6X
void SplitSegment(std::string& inbuffer, std::vector<std::string>* tokens, std::string sep)
{
    while(true)
    {
        std::cout << "inbuffer: " << inbuffer << std::endl; //查看缓冲区里还有什么
        auto pos = inbuffer.find(sep);
        if(pos == std::string::npos) //没有找到
        {
            break;
        }
        std::string sub = inbuffer.substr(0, pos); //[ )
        tokens->push_back(sub);
        inbuffer.erase(0, pos + sep.size()); //从0开始, 移除pos+sep.size()个
    }
}
bool Deserialize(const std::string& seg, std::string* out1, std::string* out2) //就是和业务强相关
{
    //1+2
    std::string op = "+";
    auto pos = seg.find("+");
    if(pos == std::string::npos) //没找到
    {
        return false;
    }
    *out1 = seg.substr(0, pos);
    *out2 = seg.substr(pos+op.size());
    return true;
}

Makefile

epoll_server:epoll_server.cc
	g++ -o $@ $^ -std=c++11
.PHONY:clean
clean:
	rm -f epoll_server

测试结果

 看到这里, 给博主点个赞吧~

                  

暴走的橙子～
关注
  • 5
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
基于C++11多线程主从Reactor模式的Web高性能服务器.zip
02-14
可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【附加价值】： 项目具有较高的学习借鉴价值，也可直接拿来修改复刻。 对于有一定基础或热衷于研究的人来说，可以在这些基础代码上进行修改和扩展，...
Easy-Reactor是一个基于Reactor模式的Linux C++网络服务器框架
02-08
Easy-Reactor是一个基于Reactor模式的Linux C++网络服务器框架，支持多线程TCP服务器，单线程TCP服务器，单线程UDP服务器等形式，可以让使用者完全专注于业务，快速开发出一个高效的服务器应用。 在工作中开发基础...
基于Reactor实现的Web服务器(可运行代码+图文解析)
vjhghjghj的博客
03-13 1156
Version1.0 架构 点击查看大图 其中线程池中工作线程取用任务队列里面的任务 也就是进行http报文分析 报文响应时候的流程如下 源码 详细的源码讲解请看注释 特性 1. 在整个epoll监听循环开始之前 先屏蔽掉SIGPIPE信号 //默认读写一个关闭的socket会触发sigpipe信号 该信号的默认操作是关闭进程 这明显是我们不想要的 //所以我们需要重...
【项目】Reactor模式的服务器
m0_72964546的博客
08-31 418
Reactor的优势和进程/线程做比较： 1.它是一个单进程的就可以并发处理请求的服务器，比进程/线程减少了创建、销毁、调度的时间；2它的等待一批fd，减少了单位等待时间；一个线程等待对应一个fd；3.有很高的复用性，替换业务逻辑就行了；
【Linux】高级IO --- Reactor服务器IO设计模式
The porters of knowledge
09-07 1922
epoll的ET和LT工作模式，为什么说ET模式是高效的？Reactor完整服务器的实现，处理读 写 异常事件，接入应用层序列化反序列化，协议定制等代码。
服务器模型reactor
zhpCSDN921011的博客
04-28 398
对高并发编程，网络连接上的消息处理，可以分为两个阶段：等待消息准备好、消息处理。当使用默认的阻塞套接字时，往往是把这两个阶段合而为一，这样操作套接字的代码所在的线程就得睡眠来等待消息准备好，这导致了高并发下线程会频繁的睡眠、唤醒，从而影响了 CPU 的使用效率。 高并发编程方法当然就是把两个阶段分开处理。即：等待消息准备好的代码段，与处理消息的代码段是分离的。当然，这也要求套接字必须是非阻塞的，否则，处理消息的代码段很容易导致条件不满足时，所在线程又进入了睡眠等待阶段。那么...
实战项目：基于主从Reactor模型实现高并发服务器
小张的博客
08-16 1411
仿muduo库One Thread One Loop式主从Reactor模型实现⾼并发服务器： 通过模拟实现的⾼并发服务器组件，可以简洁快速的完成⼀个⾼性能的服务器搭建。并且，通过组件内提供的不同应⽤层协议⽀持，也可以快速完成⼀个⾼性能应⽤服务器的搭建（项⽬中提供HTTP协议组件的⽀持）。项目主要实现的是⼀个⾼并发服务器组件，因此当前的项⽬中并不包含实际的业务内容。
开源 MQTT 服务器(基于reactor-netty实现高性能的、可扩展、支持千万级设备接入集群）
最新发布
04-29
开源 MQTT 服务器(基于reactor-netty实现高性能的、可扩展、支持千万级设备接入集群）支持 mqtt 3.1.1、mqtt 5 SMQTT基于reactor-netty(spring-webflux底层依赖) 开发，底层采用Reactor3反应堆模型,支持单机部署，...
WebServer：C ++高性能Web服务器
02-03
WebServer：C ++高性能Web服务器
自主设计Reactor服务器
cls的博客
03-25 673
epoll可以帮我们去检测哪些fd上的哪些事件就绪了，现在根据这仅有的54行代码，我们可以推测出将epoll设计成一个叫做就绪事件派发逻辑，说白了就是epoll可以告诉我们哪些fd就绪，哪些fd就绪了，我们就可以调用fd上的读写回调，所以我们最终就可以在epoll中进行事件派发，事件派发的时候，我们此时就可以通过epoll检测到哪些fd上的哪些事件就绪了，然后直接调用fd上的回调函数，就叫做把任务派发出去了，所以我们基于epoll写的这个事件派发的函数就可以称之为派发器。然后就开始事件派发。
【实战项目】c++实现基于reactor的高并发服务器
qq_40989769的博客
07-12 669
基于Reactor的高并发服务器，分为反应堆模型，多线程，I/O模型，服务器，Http请求和响应五部分全局。
基于Reactor模式下的epoll多路复用服务器
qq_61635026的博客
03-14 506
虽然当前服务器已经实现了多路复用的功能了，但是处理连接请求和业务逻辑等所有的工作都是由当前的服务器来完成的。况且当前的业务逻辑只是进行简单的运算，处理的连接数量也很少，因此对应服务器而言并没有什么压力。如果需要处理更加复杂的业务逻辑或者是同时面临大量的连接，那么此时服务器就会显得有些吃力了。可再当前服务器的基础之上引入线程池，当读事件回调函数读取完相关的请求之后，就可以将响应的业务逻辑交给线程池进行处理，当线程池处理完毕之后，再将处理结果返回给服务器，由服务器组织响应给客户端程序。
epoll高度封装reactor,几乎所有可见服务器的底层框架
小杰312的博客
04-02 4984
epoll高度封装reactor,几乎所有可见服务器的底层框架
如何构建一个高性能的服务器
nameless_233的博客
07-19 161
根据个人理解，写了我认为的高性能服务器所需要的技术。
高性能服务器架构 的几个注意点 (High-Performance Server Architecture)
dengweidan3299的博客
02-25 181
High-Performance Server Architecture 高性能服务器架构 来源：http://pl.atyp.us/content/tech/servers.html译文来源：http://www.lupaworld.com/home/space-341888-do-blog-id-136718.html （map注：本人看了一遍，“于我心有戚戚焉”，翻译得也很好...
高性能服务器设计
老程序员专栏
03-11 1157
高性能服务器设计 Jeff Darcy's notes on high-performance server design Introduction 引论 我想通过这篇文章跟大家共享一下我多年来怎样开发“服务器”这类应用的一些想法和观点（这类应用用名词“server”来表示，还是有点牵强）。 The purpose of this document is to share s
常见服务器模型
weixin_42496943的博客
09-07 1421
常见服务器模型对比，已经优缺点分析 1. 迭代式服务器 accept + read / write 特 点： 这种迭代器其实不是并发服务器， 而是迭代服务器， 因为他一次只能服务一个客户端， 属于单线程。 长连接：需要read – write 之间循环接受客户端请求， 但此时该模型只能服务一个客户端 短链接：如果想要支持短链接，其中的 计算 - 处理 - 打包 操作不能太耗时， 应为太过耗时会影响其他客户端连接到来。 2. fork/thread - per - connection 特 点：
Reactor（反应器）模式初探
热门推荐
皮斯特劳沃
11-13 2万+
前言           本文针对Reactor模式从四个方面进行了阐述，首先简单介绍了Reactor模式是什么；其次，阐述了为什么使用Reactor模式；再次，针对实际生活的应用场景，分析了在什么场景下使用Reactor模式；最后，着重分析讲解了如何使用Reactor模式，以及代码示例。 1、What：Reactor模式是什么？           反应器设计模式(Reactor
服务器Reactor架构浅析
夜夜夜夜
12-20 4276
Reactor模式是一个架构模式，它主要解决的问题是高并发场景下的服务器的性能问题。原来的服务器与客户端的链接是一对一的，也就是说一个客户端socket接到后，对应一个线程去接收和处理，这种模式的好处，是思路很清晰，一个线程处理一个socket请求，但是这种太消耗线程资源，因为毕竟socket不是实时都有数据接入的。例如网卡属于是典型的慢速设备，因此，如何能高效的利用一些模式，可以改变这种局面，这个
c++ reactor
05-13
C++ reactor是一种网络编程模式，用于实现高性能、高并发的网络服务器。它的基本思想是将I/O操作（如读写socket）异步化，使用事件驱动的方式来处理网络请求，从而避免了在处理一个请求时阻塞整个进程，提高了服务器的并发性能。 在C++ reactor中，主要包含以下组件： 1. Event Loop：负责接收和分发事件，包括读写socket事件、定时器事件等。 2. Event Demultiplexer：负责将不同的事件分发给对应的事件处理器（如读写事件分发给对应的读写处理器）。 3. Event Handler：负责处理具体的事件，如读数据、写数据等。 4. Reactor：负责管理整个系统的事件循环和事件处理器，提供注册和撤销事件处理器的接口。 C++ reactor的优点在于能够处理大量的并发请求，同时能够提供可靠的事件处理机制，避免了I/O操作的阻塞，提高了服务器的性能和可靠性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值