【Linux】高级IO

前言

        本篇笔记记录五种IO模型的基本概念,重点针对多路转接IO模型对我们的网络服务器进行设计,从而达到提升效率的效果。

我的上一篇Linux笔记:【Linux】网络基础(3)_柒海啦的博客-CSDN博客

【Linux】高级IO_第1张图片

         让我们开始吧~

目录

一、五种IO模型

1.阻塞IO

2.非阻塞IO

3.信号驱动IO

4.多路转接IO

5.异步IO

IO模型之间的联系与区别

fcntl设置非阻塞IO

二、select与poll多路转接方案

1.select接口介绍

2.编写select的一般模式

3.总结一下select的优缺点:

4.poll接口介绍:

5.poll的优缺点

三、epoll多路转接方案

epoll_create

1.epoll的工作原理

epoll_ctl

epoll_wait

2.epoll的工作模式

四、基于epoll的Reactor模式


一、五种IO模型

        在本机通信的时候,实际上进程间通信就是一个IO的过程。

        学习了网络通信后,我们知道网络实际上也是一个进程向另一个进程进行通信,也是一个IO的过程。

        那么不妨重新介绍一下IO的概念:

IO = input && output

        依据于冯诺依曼结构来说,就是访问外设的过程。输入和输出,所以一般情况就是先等数据就绪,就绪完后就对齐进行拷贝。

        所以,IO还可以如下的进行表示:

IO = 等 + 数据拷贝

        对于输入来说,等就是等待对应层将数据放入接收缓冲区的过程,等待完成后在拷贝给应用层。

        对于输出来说,等就是等待发送缓冲区为空或者有剩余的过程,等待完成后从应用层拷贝到缓冲区内。

        对于上面的等 + 数据拷贝,我们可以以网络套接字编程中recv/read为例子。

        1.当我们read/recv的时候,如果底层缓冲区没有数据怎么办?阻塞进行等待。

        2.当我们read/recv的时候,如果底层缓冲区有数据,read/recv会怎么办?拷贝。

        但是往往拷贝就是一瞬间的事情,所以IO的时间取决于等待的过程。一个最简单的例子:C/C++使用scanf或者cin的时候就是输入IO操作,此时运行会发现运行窗口一直再等待阻塞。阻塞什么?等待输入数据!

        所以,我们想要提高IO的效率的话,就要从等这方面下手脚。这样也就存在下面的五种IO模型进行优化操作。

1.阻塞IO

        阻塞IO就是最常见的IO。我们之前的使用的IO绝大多数都是使用的阻塞IO。

        阻塞IO就是自己去等,一旦等待完成就完成拷贝。

【Linux】高级IO_第2张图片

2.非阻塞IO

        非阻塞IO就不同了,它会在等待数据的过程中不去阻塞等待,而是直接返回,下一次再次调用再去检查释放准备好,没有准备好也是直接返回.....直到数据等待好了就进行拷贝。

【Linux】高级IO_第3张图片

3.信号驱动IO

        我们将等待数据的过程交给专门的信号处理程序,一旦等待完成信号处理程序通知上层(SIGIO),上层便就调用接口直接进行拷贝。

【Linux】高级IO_第4张图片

4.多路转接IO

        通过一个系统调用,我们一次性批量等待大量的IO接口。一旦存在数据等待完成,上层一次性将批量等待的IO接口等待完成的完成拷贝数据。

        核心在于IO多路转接能够同时等待多个文件描述符的就绪状态。

【Linux】高级IO_第5张图片

5.异步IO

        内核帮助应用程序对特定文件描述符进行等待IO资源,当等待成功,内核拷贝数据完成后,在通知应用程序并且拷贝到用户空间。

【Linux】高级IO_第6张图片

IO模型之间的联系与区别

        首先,我们需要理解一下异步IO和同步IO之间的关系。

        这里的同步IO不同于线程中讲解的线程同步。此同步表示在IO过程中参与了其中的一个步骤(阻塞IO:等 + 拷贝,信号驱动IO:拷贝),在发起调用后,最终是自己获取的结果

        但是异步IO完全是交给别人去做,自己不参与IO的过程。也就是说它发起调用,会立即返回但是不会存在结果,是由别人-真正的被调用者通过状态、通知来通知调用者,处理别人获取的结果

        对于阻塞IO和非阻塞IO来说,阻塞IO在等待的过程中,是会被cpu链入对于资源的等待队列中的,所以当前线程实际上是会被挂起的。但是非阻塞IO如果不能得到结果,该调用是不会阻塞当前进程的。

        针对非阻塞IO的这种特性,我们代码书写的时候一般是循环来写的。那么我们有没有一种统一的方法对文件描述符设置为非阻塞IO的形式呢?(通过各个接口设置的方式不一样,并且都默认是阻塞IO,所以非阻塞IO是需要自己手动设置的)并且在实际操作中,我们如何对非阻塞IO究竟是出错还是-输入已经空了、输出已经满了进行判断呢?

fcntl设置非阻塞IO

        我们可以使用fcntl函数对文件描述符的属性进行设置。

man fcntl

头文件

       #include
       #include
函数描述

        int fcntl(int fd, int cmd, ... /* arg */ );

        fcntl()执行一个操作下面描述的fd打开的文件描述符。操作由cmd决定。

函数参数

        fd:操作的文件描述符。

        cmd:

                F_GETFL   获取文件访问模式和文件状态标志;Arg被忽略。

                F_SETFL   将文件状态标志设置为arg指定的值。文件访问方式(O_RDONLY, O_WRONLY, O_RDWR)

                ......

        arg:

                arg中的文件创建标志(即O_CREAT, O_EXCL, O_NOCTTY, O_TRUNC)被忽略。在Linux上这个命令只能修改O_APPEND、O_ASYNC、O_DIRECT、O_NOATIME和O_NONBLOCK标志。

                其中O_NONBLOCK标志就是非阻塞标志。

返回值

        出错了返回-1,并且设置error。

        设置了非阻塞IO后,由于是如果失败返回-1,设置错误码,这个失败包含两种情况:

        1.等待失败(比如in的时候接收缓冲区为空,或者out的时候发送缓冲区满了),这种情况是正常的。errno会被设置为EWOULDBLOCK或者EAGAIN。

        2.IO中断。这个调用被一个信号给中断。也就是说可能在等文件资源的时候,被系统唤醒,等待中断了。errno会被设置为EINTR。这也是正常的,重新进行即可,但是概率非常小。

        3.真正的错误。进行差错处理。

        我们下面利用我们经常使用的标准输入描述符进行实验,查看设置非阻塞IO的基本流程以及如何去使用非阻塞IO接口。

#include 
#include 
#include 
#include 

int main()
{
    // 注意标准输入描述符是默认打开的,并且是0号fd哦,当然也可以直接stdin
    int fl = fcntl(0, F_GETFL);  // 首先获取原本的文件标志状态,保证修改的时候不动原来的状态
    int flag = fcntl(0, F_SETFL, fl | O_NONBLOCK);  // 设置此文件的文件标志状态,增加非阻塞状态
    printf("请输入: ");
    char buffer[1024];
    while (true)
    {
        ssize_t n = read(0, buffer, sizeof(buffer) - 1);  // 0此时没有作用了,因为标准输入文件描述符标志状态设置为非阻塞了
        if (n > 0)
        {
            // 此时是读取成功的,进行打印
            buffer[n] = 0;
            std::cout << buffer << std::endl;
        }
        else if (n < 0)
        {
            // 读取失败,判断两种情况
            if (errno == EWOULDBLOCK || errno == EAGAIN)
            {
                // 此时只是读取缓冲区为空而已
                std::cout << "null" << std::endl;
                sleep(1);
            }
            else if (errno == EINTR)
            {
                // 此时小概率被IO中断了
                continue;
            }
            else{
                // 此时才是真正的错误
                std::cout << "read error:" << errno << strerror(errno) << std::endl;
                break;
            }
        }
    }
    return 0;
}

【Linux】高级IO_第7张图片

         现象果然如上面所说。

         那么,现在我们需要在我的自定义组件MySock文件中加入设置非阻塞的选项,供之后使用,就需要增加setNonBlock接口。针对于MySock文件,详细介绍可以在我的这两篇文章寻找答案,实际上就只是对套接字编程进行一个基本封装而已,加上了log日志打印文件而已。

【Linux】网络基础(1)_柒海啦的博客-CSDN博客

【Linux】网络套接字编程_柒海啦的博客-CSDN博客

        源文件可以在我的仓库中提出哦:linux日常练习/EpollTcpTest/ET/MySock.hpp · 刘凌宇/Linux_Test - Gitee.com 

        增加接口代码:

// 设置对此资源设置非阻塞IO,出错会设置致命出错日志
        static bool setNonBlock(int sock)
        {
            int fl = fcntl(sock, F_GETFL);  // 获取当前sock底层的读写标记位 - 保持当前的不变
            if (fl > 0)
            {
                int flag = fcntl(sock, F_SETFL, fl | O_NONBLOCK);  // 在不动原来的基础上进行一个非阻塞
                if (flag != -1) return true;
            }
            // 这里都是出错了
            logMessage(FATAL, "fcntl error %d:%s", errno, strerror(errno));
            return false;
        }

        观察上面的五种IO模型,在等待一批量的文件描述符的时候,除开多路转接IO外,其余都是一个一个进行等待的,但是多路转接IO是同时等待。这样的话它就在单位时间,等的比重就会非常低,所以效率就会很高。

        所以,下面我们针对多路转接,操作系统为我们提供了select、poll、epoll等接口实现,我们逐步用这些方案实现一个成熟的服务器出来。使用多路转接后,就不像之前服务器一样需要开多线程或者多进程执行,减少操作系统的压力。

二、select与poll多路转接方案

        前面我们已经提到过多路转接方案了。它这种IO模型是一次性等待一批文件描述符,从而缩短整体等待的时间,达到提高效率的效果。

        select接口就是系统给我们的一个多路转接方案,select只解决等的问题。所以它会:1.帮用户一次等待多个文件sock。2.当哪些文件sock就绪了,select通知用户,就绪的sock有哪些,用户调用io接口读取即可。

1.select接口介绍

man select

头文件

        #include

函数描述

        int select(int nfds, fd_set *readfds, fd_set *writefds,
                  fd_set *exceptfds, struct timeval *timeout);

        select()允许程序监视多个文件描述符,直到一个或多个文件描述符为某些类型的I/O操作(例如,可能的输入)“准备好了”。如果一个文件描述符能够在不阻塞的情况下执行相应的I/O操作(例如,read(2)),那么它就被认为是就绪的。

函数参数

        nfds:监听中最大的文件描述符+1。

        readfds、writefds、exceptfds

                操作系统提供的类型:fd_set。本质是一个位图,表示文件描述符集,并且存在上限:1024个。这三种,分别将fd设进去表示操作系统需要帮助我们关心什么IO操作:(读、写、异常是否就绪),然后返回的时候,对应fd_set如果存在对应的fd表示事件就绪了。所以它是一个输入输出参数

                对于fd_set这个位图结构,我们不能直接操作,需要利用系统提供的接口对位图进行扩展操作。

                void FD_CLR(int fd, fd_set *set);  // 删除位图中对应的fd。
                int  FD_ISSET(int fd, fd_set *set);  //检查对应fd是否存在位图中,存在返回1否则0.         
                void FD_SET(int fd, fd_set *set);  // 将对应fd添加到为位图中去
                void FD_ZERO(fd_set *set);  // 将此位图结构清空

        timeout:是一个结构体,用来描述时间 - 阻塞的时长:

                struct timeval-获取当前时区的时间。
                {time_t tv_sec - 时间戳
                suseconds_t tv_usec;  // 微妙级别的

                }

                输入参数的时候,表示阻塞一次需要多少时间。输出参数的时候表示基于需要的时间还剩下多少时间。

返回值

        如果成功,select()和pselect()返回三个返回的描述符中包含的文件描述符的数量。如果出错,返回-1并且设置errno。

2.编写select的一般模式

        通过上面的接口介绍,我们可以总结一下通过select编写IO的一般模式:

        1、nfds,随着获取的sock的越来越多,注定了nfds都可能发生变化。-最大文件描述符+1。

        2、rfds、wfds、efds都是输入输出型参数。输入输出不一定是一样的。每一次对rfds重新添加。
        3、timeout也是输入输出,每一次需要重置,前提是你需要的话。
        通过1、2将我们自己合法的文件描述符全部保存起来,用来支持:1-更新最大fd,2.更新fds-位图结构。
        所以我们就需要需要一个第三方数组,保存合法的fd。针对这个数组:1、遍历数组,更新最大值。2、遍历数组,添加关心的fd到set中。3、事件检测。4、遍历数组,找到就绪的事件,完成对应的动作:连接、读取。扩展:引入写入。(现在不好改写,epoll解决。)数组需要1024个即可。对于数组的处理:只要获取了sock,添加到数组里即可。如果满了,表示已经超过select监管个数了,满了,你没有位置了,丢弃此链接!如果存在,就添加到我们管理的文件描述表中即可。
        处理就绪套接字资源的时候,需要串行执行:原本是-1,跳过 ,如果FD_ISSET(fd, &fd_set)就是判断合法文件描述符是否事件就绪了。读事件就绪了就一定是read嘛,自然还有监听套接字。判断是否是监听套接字,监听套接字就获取链接添加sock,否则就是read!

        对于IO事件的处理,就read来说,分为三种情况,针对这三种情况分别要做不同的处理,编码的时候需要特别注意。

        下面,我们首先基于之前的log、mysock文件进行编写一个select实现的多路转接服务器,但是只处理读的事件,也就是说利用客户端进行测试的时候,服务器只需要打出信息即可,不做其他的处理。

#ifndef _SELECT_SERVER_H_
#define _SELECT_SERVER_H_

#include "MySock.hpp"
#include 
#include 
#include 

const int NUM = (sizeof(fd_set) * 8);  // 定义fd_set最多接收的fd个数 - fd_set是一个位图 一个字节是八个比特位(一个比特位从右到左表示0123.....)
const int FD_NONE = -1;  // 设定fd的初始值为-1,表示此处fd空缺,可以填入或者跳过

class SelectServer
{
public:
    SelectServer(const uint16_t port = 8080)
    {
        _listenSock = QiHai::Sock::socket();
        QiHai::Sock::bind(_listenSock, port);  // 服务器默认绑定0.0.0.0 ip
        QiHai::Sock::listen(_listenSock);
        // 首先对_fdsArray进行初始化,好存放我们需要处理的fd,并且处理后的结果
        for (int i = 0; i < NUM; ++i) _fdsArray[i] = FD_NONE;
        _fdsArray[0] = _listenSock;  // 默认监听套接字为第一个
    }

    void Start()
    {
        // 首先,将通过监听套接字获取链接视为一种IO资源,我们是读取其中的链接的
        fd_set rfds;
        while(true)
        {
            // 因为rfd为输入输出参数,所以每次循环需要对其进行更新
            FD_ZERO(&rfds);  // 将文件集清空 - 本质是一个位图
            // 每次需要重新将输入的fd_set位图结果进行更新
            int maxFd = _listenSock;
            for(int i = 0; i < NUM; ++i)
            {
                if (_fdsArray[i] != FD_NONE)
                {
                    FD_SET(_fdsArray[i], &rfds);
                    if (_fdsArray[i] > maxFd) maxFd = _fdsArray[i];
                } 
            }
            int n = select(maxFd + 1, &rfds, nullptr, nullptr, nullptr);  // 最后一个参数nullptr为阻塞进行处理
            switch(n)
            {
            case 0:
                // 表示当前链接的所有fd没有就绪的 - 还需要进行等待 但是阻塞等待的话就不存在了
                logMessage(DEBUG, "select timeout......");
                break;
            case -1:
                logMessage(WARNING, "select error:%d-%s", errno, strerror(errno));
                break;
            default:
                // 出现文件就绪成功 IO = 等待 + 拷贝,等待成功!
                HandlerEvent(rfds);                
                break;
            }
        }
    }

    ~SelectServer()
    {
        if (_listenSock >= 0) close(_listenSock);
    }
private:
    // 此时select负责的多个fd中存在就绪的了,需要对其进行处理
    void HandlerEvent(fd_set& rfds)
    {
        //明确rfds是一个输入输出型参数,此时是输出型参数,如果对应fd等待资源就绪,内核会进行一个设置
        for (int i = 0; i < NUM; ++i)
        {
            if (_fdsArray[i] == FD_NONE) continue;
            if (FD_ISSET(_fdsArray[i], &rfds))  // 表示此时对应的就绪了
            {
                if (_fdsArray[i] == _listenSock) Accepter();  // 表示连接服务
                else Recver(i); // 正常的读服务
            }
        }
    }

    void Accepter()
    {
        // 连接服务
        int sock = QiHai::Sock::accept(_listenSock);  // 此时是就绪的,不用阻塞进行等待了 debug模式里面会打印客户端ip和port
        int pos = 1;  //从1开始
        for (; pos < NUM; ++pos)
        {
            if (_fdsArray[pos] == FD_NONE) break;
        }

        if (pos == NUM)
        {
            // 此时select托管的fd满了,不好意思,只能抛弃此连接了
            close(sock);
            logMessage(WARNING, "accept error,_fdsArray overload......");
        }
        else _fdsArray[pos] = sock;
    }

    void Recver(int pos)
    {
        // 读取服务
        // 当前应该配合协议进行读取,但是当前为了实现简单没有对数据进行处理
        char buffer[1024];
        int n = recv(_fdsArray[pos], buffer, sizeof(buffer) - 1, 0);  // 应该也是无需阻塞等待,直接读取
        if (n > 0)
        {
            buffer[n] = '\0';
            logMessage(DEBUG, "fds[%d]# %s", pos, buffer);
        }
        else if (n == 0){
            // 对方关闭连接
            close(_fdsArray[pos]);
            _fdsArray[pos] = FD_NONE;
            logMessage(WARNING, "fds[%d] close, me too ......", pos);
        }
        else{
            // 读取出现错误
            logMessage(ERROR, "recv error %d-%s", errno, strerror(errno));
            close(_fdsArray[pos]);
            _fdsArray[pos] = FD_NONE;
        }
    }
private:
    int _listenSock;
    int _fdsArray[NUM];
};



#endif

        运行结果:

【Linux】高级IO_第8张图片

3.总结一下select的优缺点:

优点:-任何一个多路转接都是这样
        a、效率高!-和之前的比。单位事件内,等的比重小了。
        b、应用场景:有大量的连接,但是只有少量是活跃的!
        
缺点:
        a、为了维护第三方数组,select服务器充满了大量的遍历 - On OS底层关心的时候也是存在大量的遍历的。
        b、每一次都要对select输出参数重新设定。
        c、能够同时管理的fd的个数是存在上限的。-fd_set。-1024bit
        d、因为几乎每一个参数都是输入输出型的,决定了select一定频繁的用户到内核,内核到用户参数数据拷贝。
        e、编码比较复杂。(前四个缺点导致的)

         针对于select缺点中的fd的上限个数,以及参数是输入输出型的,poll函数对齐进行了优化。

4.poll接口介绍:

man poll

头文件

        #include

函数描述

        int poll(struct pollfd *fds, nfds_t nfds, int timeout);

        Poll()执行与select(2)类似的任务:它等待一组文件描述符中的一个准备好执行I/O。

函数参数

        fds:类型为pollfd,为内核提供:

                struct pollfd{

                        int fd;  // 不会对fd 用户和内核都不会改其
                        short events;  // 请求事件  -- 用户写的,内核只对其读取
                        short revents; // 响应事件,内核告诉用户哪些事件就绪了。

                };

                基于select,实际上把之前fd_set三个位图fd表示的两种意思分离了。就使用一个数组进行搞定。由于fd_set是固定的大小所以只能是固定的fd个数。而现在数组个数完全由用户决定,理论上没有上限的。并且由于输入输出参数的分离,就不用每次对参数进行重新设定了。

                其中请求和响应事件存在对应的宏作为读、写、异常的关心:

                POLLIN、POLLOUT、POLLERR、POLLPRI、    POLLRDHUP....

                (可读    可写    错误       高优先级数据可读    TCP对方关闭连接)

        nfds:决定等待的文件描述符个数。

        timeout:输入型参数,单位为毫秒,表示阻塞一次的时间。(同理,0为非阻塞,-1为阻塞,其余就是阻塞一次的时间)

返回值

        -1表示错误。否则就是等待就绪的文件描述符个数。

        poll的工作模式和select类似,这里不在过多赘述,我们可以直接在之前那份代码上简单修改几处就能修改为poll的工作模式。

#ifndef _POLL_SERVER_H_
#define _POLL_SERVER_H_

#include "MySock.hpp"
#include "poll.h"
#include 
#include 

const int FD_NONE = -1;  // 设定fd的初始值为-1,表示此处fd空缺,可以填入或者跳过

class PollServer
{
public:
    PollServer(const uint16_t port = 8080, int nfds = 1024):_nfds(nfds)
    {
        _listenSock = QiHai::Sock::socket();
        QiHai::Sock::bind(_listenSock, port);  // 服务器默认绑定0.0.0.0 ip
        QiHai::Sock::listen(_listenSock);

        _pollFds = new pollfd[_nfds];
        for (int i = 0; i < _nfds; ++i)
        {
            _pollFds[i].fd = FD_NONE;
            _pollFds[i].events = _pollFds[i].revents = 0;  // 置空
        }
        _pollFds[0].fd = _listenSock;
        _pollFds[0].events = POLLIN;  // 只读事件
    }

    void Start()
    {
        // 首先,将通过监听套接字获取链接视为一种IO资源,我们是读取其中的链接的
        while(true)
        {
            int n = poll(_pollFds, _nfds, -1); // 最后一个参数-1为阻塞的进行读取哦
            switch(n)
            {
            case 0:
                // 表示当前链接的所有fd没有就绪的 - 还需要进行等待 但是阻塞等待的话就不存在了
                logMessage(DEBUG, "poll timeout......");
                break;
            case -1:
                logMessage(WARNING, "poll error:%d-%s", errno, strerror(errno));
                break;
            default:
                // 出现文件就绪成功 IO = 等待 + 拷贝,等待成功!
                HandlerEvent();                
                break;
            }
        }
    }

    ~PollServer()
    {
        if (_listenSock >= 0) close(_listenSock);
        delete[] _pollFds;
    }
private:
    // 此时select负责的多个fd中存在就绪的了,需要对其进行处理
    void HandlerEvent()
    {
        //明确rfds是一个输入输出型参数,此时是输出型参数,如果对应fd等待资源就绪,内核会进行一个设置
        for (int i = 0; i < _nfds; ++i)
        {
            if (_pollFds[i].fd == FD_NONE) continue;
            if (_pollFds[i].revents & POLLIN)  // 表示此时对应的就绪了
            {
                if (_pollFds[i].fd == _listenSock) Accepter();  // 表示连接服务
                else Recver(i); // 正常的读服务
            }
        }
    }

    void Accepter()
    {
        // 连接服务
        int sock = QiHai::Sock::accept(_listenSock);  // 此时是就绪的,不用阻塞进行等待了 debug模式里面会打印客户端ip和port
        int pos = 1;  //从1开始
        for (; pos < _nfds; ++pos)
        {
            if (_pollFds[pos].fd == FD_NONE) break;
        }

        if (pos == _nfds)
        {
            // 此时select托管的fd满了,不好意思,只能抛弃此连接了
            close(sock);
            logMessage(WARNING, "accept error,_fdsArray overload......");
        }
        else{
            _pollFds[pos].fd = sock;
            _pollFds[pos].events = POLLIN;
        }
    }

    void Recver(int pos)
    {
        // 读取服务
        // 当前应该配合协议进行读取,但是当前为了实现简单没有对数据进行处理
        char buffer[1024];
        int n = recv(_pollFds[pos].fd, buffer, sizeof(buffer) - 1, 0);  // 应该也是无需阻塞等待,直接读取
        if (n > 0)
        {
            buffer[n] = '\0';
            logMessage(DEBUG, "fds[%d]# %s", pos, buffer);
        }
        else if (n == 0){
            // 对方关闭连接
            close(_pollFds[pos].fd);
            _pollFds[pos].fd = FD_NONE;
            logMessage(WARNING, "fds[%d] close, me too ......", pos);
        }
        else{
            // 读取出现错误
            logMessage(ERROR, "recv error %d-%s", errno, strerror(errno));
            close(_pollFds[pos].fd);
            _pollFds[pos].fd = FD_NONE;
        }
    }
private:
    int _listenSock;
    int _nfds;
    struct pollfd* _pollFds;
};



#endif

5.poll的优缺点

    优点:
        1.效率高
        2.有大量的链接,只有少量的是活跃的-节省资源
        3.输入输出参数分离,不需要进行大量的重置。
        4.poll参数级别,没有可以管理fd的上限。
    缺点:        
        ***1.poll仍然避免不了结构体数组,还是需要进行遍历的,在用户从检测事件就绪,内核检测fd就绪,都是一样。
        2.poll需要内核到用户的拷贝。 -- 少不了
        *3.poll编码也不容易。--比select容易。

        可以看到,虽然在一定程度上做了简化,参数分离,提高上限等操作,但是还是避免不大量的遍历。这些问题的原因就是用户在对这一批fd进行组织管理的。

        那么我们能不能将管理这一批fd也交给操作系统呢?并且操作系统做相关的回调设置,减少遍历的操作吗?当然可以,epoll就是这样完美解决这些问题的方案。

三、epoll多路转接方案

        epoll是为了处理大批量句柄而改进的poll的接口。

        epoll针对poll的缺点,-目的是为了解决用户来维护数组,并且不断循环拷贝(内核->用户)的过程,解决这些只能在内核层自己处理。

        所以首先在操作系统内部创建这个管理系统加了epoll_create进行创建,epoll_ctl提供了是否添加、修改、删除对应fd的一个监控模式,而epoll_wait则提供了拿出就绪文件描述符的功能。

epoll_create

man epoll_create

头文件

        #include

函数描述

        int epoll_create(int size);

        epoll_create()创建一个epoll实例。从Linux 2.6.8开始,size参数被忽略,但必须大于零;

        epoll_create()返回指向新的epoll实例的文件描述符。该文件描述符用于对epoll接口的所有后续调用。当不再需要时,该文件epoll_create()返回的描述符应该使用close关闭。当所有引用epoll实例的文件描述符都已关闭时,内核将销毁该实例并释放用于重用的关联资源。

        如果失败返回-1,并且设置errno。

1.epoll的工作原理

        因为操作系统需要在内核为我们维护,那么自然需要先组织。

        针对于用户想要关心的fd是否就绪,内核采用的是红黑树进行组织。红黑树是自平衡的搜索二叉树,可以通过此链接进行了解哦(红黑树的插入实现)~

        所以,这样就避免了像select、poll,利用用户的数组进行遍历,内核查看哪些需要进行关心,而是用户直接到内核进行注册,这样OS每次就对这颗树进行检查,避免频繁的遍历以及切换状态。

        另外,用户曾经在红黑树注册的fd的事件,会在底层网卡的驱动程序中设置一个回调函数(OS是如何直到网卡内存在数据呢?--TCP/IP协议栈,想传给上层网络层、传输层的时候  采用硬件中断的方式。网卡-中断通知>cpu-执行void(*hanlder[])()-中断向量表->read_netcard()此时就可以从网卡内搬到操作系统内部了。-此时在经过网络协议栈进行一步步,最后通知上层。转化为一个值保存到寄存器里-索引),设置了回调函数后,如果对应的事件就绪,此时不用关心红黑树,插入进就绪队列。此时不用再关心红黑树,直接队列送上去即可。-内核告诉用户哪些事件就绪了.

【Linux】高级IO_第9张图片

         针对于poll、select,他们的工作原理如下,可以做一个更好的比对:

    1.无论是select、poll都是需要用户自己维护数组进行保存fd和特定事件的。--成本、程序员承担
    2.select、poll都需要遍历。(内核和用户都要遍历)
    3.poll、select工作模式:
        a、通过系统调用,用户告诉内核哪些fd上的哪些事件
        b、通过系统的返回,内核告诉用户哪些fd的哪些事件已经发生了。

        所以,我们往epoll模型中的红黑树进行插入、修改、删除对应fd关心时,使用的接口就是epoll_ctl。

epoll_ctl

man epoll_ctl

头文件

        #include

函数描述

        int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

        这个系统调用对文件描述符epfd引用的epoll实例执行控制操作。它请求对目标文件描述符fd执行操作op。

函数参数

        epfd:epoll_create获得的epoll模型的文件描述符。

        op:对对应的fd如何操作。

                EPOLL_CTL_ADD  // 添加fd关心事件

                EPOLL_CTL_MOD  //更改更改与目标文件描述符fd关联的事件事件

                EPOLL_CTL_DEL   //从epfd引用的epoll实例中删除(取消注册)目标文件描述符fd。(需要注意,一般时先从epoll模型中删除fd,然后在close,否则可能存在bug)

        fd:添加对应关心的事件描述符。

        event:关心的事件。

                struct epoll_event // 系统创建的类型

                {

                        uint32_t events;  // epoll事件

                        epoll_data_t data;  // 用户数据变量

                };

                epoll事件:

                        EPOLLIN  读事件

                        EPOLLOUT  写事件

                        EPOLLHUP  关联文件描述符挂起。没有必要等它。(网络中对方关闭连接)

                        EPOLLERR  相关文件描述符发生错误。

                        EPOLLET  为关联的文件描述符设置边缘触发行为。(默认为水平触发行为,此行为为多路转接的工作模式,后续会讲)

                epoll_data_t 为一个联合体,用户自己设定想要返回什么信息:

                                   typedef union epoll_data {
                                               void        *ptr;
                                               int          fd;
                                               uint32_t     u32;
                                               uint64_t     u64;
                                    } epoll_data_t;

返回值

        成功返回0,失败返回-1,设置errno。

        当监视的fd存在关心事件就绪的时候,从epoll模型维护的就绪队列中提出来的方法时epoll_wait。

epoll_wait

man epoll_wait

头文件:

        #include

函数描述:

        int epoll_wait(int epfd, struct epoll_event *events,
                      int maxevents, int timeout);

        epoll_wait()系统调用等待文件描述符epfd引用的epoll实例上的事件。由事件指向的内存区域将包含调用者可用的事件。epoll_wait()最多返回maxevents。maxevents参数必须大于零。

函数参数:

        epfd:epoll模型的文件描述符。

        events:用户保存就绪事件的数组。

        maxevents:期望就绪事件个数。(返回来的事件个数最多不超过期望个数)

        timeout:和poll类似,大于0设置阻塞时间,等于0表示非阻塞,小于0表示阻塞等待。

返回值:

        当成功时,epoll_wait()返回为请求的I/O准备好的文件描述符的数量,如果在请求的超时毫秒内没有文件描述符准备好,则返回零。当一个发生错误时,epoll_wait()返回-1,并适当设置errno。(这个数量就是存在在数组的整个个数,从0下标开始到此返回数 - 1)

        实际上,人们针对于这个内核等待fd就绪事件发生,如何通知用户有着不同的操作模式。这里就涉及到了多路转接的工作模式了。

2.epoll的工作模式

        epoll针对事件就绪后通知用户的行为,增加了其工作模式,以便应对不同的IO模式。

        我们以快递小哥发送快递为例。

        假设快递小哥A拿到多个人的包裹,他在发送快递的时候,每一个快递都是等别人真正从他手中拿过的时候,他才进行下一个快递的发放。

        但是快递小哥B不同,他拿到多个包裹后,不同的快递通知不同的人时,每个只是通知一遍,通知后他会放到一个位置走了,继续下一个快递的发放。如果同一个人的快递临时多了一个,他会在通知这个人一遍。

        实际上,快递小哥A的工作模式就是水平触发模式(Level Triggered),简称LT。而快递小哥B的工作模式就是边缘触发模式(Edge Triggered),简称ET。

        默认条件下,epoll模型设置的是LT模式,对于poll和select的工作模式也是LT模式。就是说一旦存在关心的事件就绪了,会不断的通知你(通过wait接口返回的就绪个数)。但是ET只有数据首次到达或者发生变化的时候才会通知。

        针对于这两种模式,很明显,显然ET模式的工作效率会很高。但是即使是LT模式,我每次拿数据的时候也一次性拿完,效率是和ET模式下差不多的。

LT模式 VS ET模式原则上谁更高效?
    ET模式。
    1.更少的返回次数。
    2.ET模式会倒逼程序员将接收缓冲区中的数据全部取走,应用层就更快的取走了缓冲区的数据,单位时间下,此服务器在一定程度上会给发送方一个更大的接收窗口,对方就可以有更大的滑动窗口,提高IO吞吐。
    ET模式的代码复杂度比较高。

        所以,我们通过ET模式可以发现一个问题,它每次通知我们对应的fd关心事件的时候,如果是读取。没有读完的话,那么下次就读不到了,获取不到完整的数据(LT模式下下次还能继续)。所以在ET模式下,我们需要读取一次完整的读完。

        那么,这里就需要对IO的特性做出区别了。由于读取的时候,可能因为用户的接收缓冲区过小或者发生信号中断的话,就不能一次性的从接收缓冲区中读取完全,所以我们需要循环的去读。但是,如果是阻塞IO的话,读取完后发现接收缓冲区为空会发生阻塞,此时此进程就会被挂起。这怎么可以呢?所以需要非阻塞IO进行轮询读取,最后根据错误码进行判断是缓冲区空了还是失败了。

        所以,基于ET的工作环境,我们需要非阻塞IO进行读取。

四、基于epoll的Reactor模式

        那么,现在我们综合实现一个完善的服务器。利用epoll的多路转接接口和ET工作模式。

        需求如下:

1.实现网络版的计算器。

2.服务器对于超时连接-比如超时20s没有发送任何请求,需要主动断开。

3.采用epoll的多路转接,不出现任何多执行流。

        综合上述需求,我们实际编码的时候,需要自己定制协议(协议可以采用现成的Json,自己解决粘包即可)。之前的代码中,因为只解决了读的需求,每个fd都是共享一个自己的用户缓冲区,现在在ET、并且要处理读和写事件下,需要每个fd都能维护两个缓冲区,并且采用非阻塞IO的方式,实现TCP网络版的计算器。

        参考代码如下:(注:MySock、log头文件没有提供编码)

// Epoll.hpp

#ifndef __EPOLL_HPP__
#define __EPOLL_HPP__

#include 
#include 
#include "log.hpp"

// 创建epoll模型,使用此epoll模型进行操作
class Epoll
{
    const static int gsize = 256;
    const static int gtimeout = 10000;  // 10s
private:
    int _epfd;
public:
    Epoll():_epfd(-1)
    {}

    // 创建epoll模型
    bool EpollCreate()
    {
        _epfd = epoll_create(gsize);  // gsize需要注意是一个废弃的参数,这里随便设置即可
        if (_epfd < 0) logMessage(FATAL, "epoll_create error %d:%s", errno, strerror(errno));
        return _epfd != -1;
    }

    // 增添监听对象到epoll模型中来,并且说明需要关心的事件 如果需要使用ET模式进行监听,需要在event选项添加EPOLLET,需要注意,默认就是LT模式
    bool AddSockToEpoll(int sock, int event)
    {
        struct epoll_event epev;
        epev.events = event;
        epev.data.fd = sock;

        int flag = epoll_ctl(_epfd, EPOLL_CTL_ADD, sock, &epev);
        if (flag < 0) logMessage(FATAL, "epoll_ctl error %d:%s", errno, strerror(errno));
        return flag != -1;
    }

    // 修改sock在epoll所关心的状态
    bool CtlSockToEpoll(int sock, int event)
    {
        // 进来先添加ET模式
        event |= EPOLLET;
        struct epoll_event epev;
        epev.events = event;
        epev.data.fd = sock;

        int flag = epoll_ctl(_epfd, EPOLL_CTL_MOD, sock, &epev);
        if (flag < 0) logMessage(FATAL, "epoll_ctl error %d:%s", errno, strerror(errno));
        return flag != -1;
    }

    // 删除sock在epoll对应的监听
    bool DelFromEpoll(int sock)
    {
        int flag = epoll_ctl(_epfd, EPOLL_CTL_DEL, sock, nullptr);
        if (flag < 0) logMessage(FATAL, "epoll_ctl error %d:%s", errno, strerror(errno));
        return flag != -1;
    }

    // 从epoll模型的就绪队列取出num个(num是期望个数),并且以timeout毫秒的时候进行一次阻塞。-1为阻塞,0非阻塞,默认5s一次阻塞
    // 需要注意的是,如果是ET模型,只有等待对象的缓存区出现变化后才会通知,并且只通知一次,如果通知后没有取走或者取完,此就绪队列就不会存储其相关的就绪事件了
    int WaitEpoll(epoll_event events[], int num, int timeout = gtimeout)  // 默认5s进行进行一次阻塞
    {
        return epoll_wait(_epfd, events, num, timeout);
    }

    ~Epoll()
    {
        if (_epfd >= 0) close(_epfd);
    }
};

#endif
// Protocal.hpp 自己定制协议
#ifndef __PROTOCAL_HPP__
#define __PROTOCAL_HPP__

#include 
#include 
#include 
#include
// 自定义协议 - 使用json封装一下

namespace QiHai
{
    static const char* SEP_BEGIN = "{";
    static const char* SEP_END = "}";
    static const int SEP_LEN = strlen(SEP_END);

    // 请求
    class Request
    {
    public:
        Request() = default;
        Request(int x, int y, char op)
        :_x(x), _y(y), _op(op)
        {}

        // 序列化
        std::string serialization()
        {
            Json::Value root;
            root["x"] = _x;
            root["y"] = _y;
            root["op"] = _op;

            Json::FastWriter writer;
            return writer.write(root);
        }

        // 反序列化
        bool deserialization(std::string request)
        {
            Json::Reader read;
            Json::Value root;
            if (!read.parse(request, root)) return false;

            _x = root["x"].asInt();
            _y = root["y"].asInt();
            _op = root["op"].asInt();
            return true;
        }

        int _x;
        int _y;
        char _op;
    };

    // 响应
    class Response
    {
    public:
        Response() = default;
        Response(int state, int result)
        :_state(state), _result(result)
        {}
        
        // 序列化
        std::string serialization()
        {
            Json::Value root;
            root["state"] = _state;
            root["result"] = _result;

            Json::FastWriter writer;
            return writer.write(root);
        }

        // 反序列化
        bool deserialization(std::string request)
        {
            Json::Reader read;
            Json::Value root;
            if (!read.parse(request, root)) return false;

            _state = root["state"].asInt();
            _result = root["result"].asInt();
            return true;
        }

        int _state;  // 状态:1正确 0异常
        int _result;  // 结果:正常就是计算结果,否则就是错误编号
    };

    // 解决粘包以及不是独立的一个报文问题:这里采用的是Json的格式{"1":1}...
    void SpliteMessage(std::string& message, std::vector& messages)
    {
        while (true)
        {
            // 首先找到第一个{的位置
            auto begin = message.find(SEP_BEGIN);
            if (begin == std::string::npos) break;  // 没有找到一个完整报文
            auto end = message.find(SEP_END);
            if (end == std::string::npos) break;  // 同理

            std::cout << "DEBUG: " << message.substr(0, end + 1) << std::endl;
            messages.push_back(message.substr(0, end + 1));  // {}
            message.erase(0, end + SEP_LEN);
        }
    }
}

#endif
// TCPServer.hpp
#ifndef __TCPSERVER_HPP__
#define __TCPSERVER_HPP__

#include 
#include 
#include 
#include "MySock.hpp"
#include "log.hpp"
#include "Epoll.hpp"
#include "Protocal.hpp"

namespace QiHai
{
    // 用户管理
    class User
    {
    public:
        std::string _ip;
        std::uint16_t _port;

        User(std::string ip, uint16_t port)
        :_ip(ip), _port(port)
        {}
    };

    class TcpServer;
    class Connection;
    using func_t = std::function;  // 注意前面需要声明哦
    using service_logic = std::function;
    static const time_t MAX_TIME = 20;  // 最大时间间隔
    // 每个sock对应一个连接类进行管理,里面存在其输入输出缓冲区,以及对应读取、写入、异常的回调方法
    class Connection
    {
    public:
        int _sock;

        // 三个回调函数
        func_t _recv_cb;
        func_t _send_cb;
        func_t _except_cb;

        // 接收缓冲却和发送缓冲区
        std::string _inbuffer;  // 当前存在bug,不能处理二进制流,但是文本是可以的
        std::string _outbuffer;

        TcpServer* _tsvr;  // 对服务器的一个回调指针,后续会使用到

    public:
        time_t _time;  // 当前的时间戳

        Connection(int sock, TcpServer* tsvr)
        :_sock(sock), _tsvr(tsvr)
        {}

        // 设置三种回调函数
        void SetCallBack(func_t recv_cb, func_t send_cb, func_t except_cb)
        {
            _recv_cb = recv_cb;
            _send_cb = send_cb;
            _except_cb = except_cb;
        }

        ~Connection()
        {}
    };

    class TcpServer
    {
        const static uint16_t gport = 8080;
        const static int gnum = 128;
    private:
        int _listensock;
        uint16_t _port;
        Epoll _poll;
        std::unordered_map _connections;  // 组织链接
        std::unordered_map _users;  // 组织用户
        struct epoll_event* _revs;  // 读取就绪事件的缓冲区
        int _revs_num;  // 每次读就绪事件的大小,这里初始化的时候固定大小即可
        service_logic _call;  // 处理业务逻辑的函数,由上层提供
    private:
        // 将此sock建立一个连接对象描述起来,并且连接到map。设置三个回调函数。默认关心的事件是读取,写入和异常后续设置
        // 任何多路转接的服务器,一般默认只会打开对读取事件的关心,写入事件按需打开 
        void AddConnection(int sock, func_t recv_cb, func_t send_cb, func_t except_cb)
        {
            if(!QiHai::Sock::setNonBlock(sock)) exit(2);  // 设置其属性为非阻塞
            Connection* connection = new Connection(sock, this);
            connection->_time = time(nullptr);  // 初始时间戳
            connection->SetCallBack(recv_cb, send_cb, except_cb);
            _connections.insert(std::make_pair(sock, connection));
            // 添加入epoll模型中,默认关系读取事件
            if (!_poll.AddSockToEpoll(sock, EPOLLIN | EPOLLET)) exit(6);  // 主动设置为ET模式对其进行监听
        }

        // 专门处理监听套接字的读取回调函数
        void Accepter(Connection* conn)
        {
            logMessage(DEBUG, "Accepter wait......");
            std::string client_ip;
            uint16_t client_port;
            int err_num = 0;
            while(true)
            {
                int sock = QiHai::Sock::accept(conn->_sock, &err_num, &client_ip, &client_port);
                // 注意,sock设置的是非阻塞读取,所以循环的进行绑定,一次性读完
                if (sock < 0)
                {
                    if (err_num == EAGAIN || err_num == EWOULDBLOCK) break;  // 此时只是没有链接了,读完了
                    else if(err_num == EINTR) continue;  // 此时是被中断了
                    else{
                        logMessage(WARNING, "accept error...... %d:%s", err_num, strerror(err_num));
                        break;  // 此时错误了,但是影响不大,break即可
                    }
                }
                _users.insert(std::make_pair(sock, new User(client_ip, client_port)));
                AddConnection(sock, std::bind(&TcpServer::Recver, this, std::placeholders::_1), \
                                    std::bind(&TcpServer::Sender, this, std::placeholders::_1), \
                                    std::bind(&TcpServer::Excpeter, this, std::placeholders::_1));

                logMessage(DEBUG, "is %d connection! add Connection success!", sock);
            }
        }

        // 三大回调方法
        // 读回调
        void Recver(Connection* conn)
        {
            // 此链接读的事件响应,处理读的事件
            // 首先保证将本次从底层的读取缓冲区拿完到用户的缓冲区
            conn->_time = time(nullptr);  // 更新时间戳
            bool err = false;
            const int nums = 1024;
            while(true)
            {
                char buffer[nums];
                int n = recv(conn->_sock, buffer, sizeof(buffer) - 1, 0);  // 此时最后一个0没有多大意义。因为sock始终保证的就是非阻塞进行读取
                if(n > 0)
                {
                    // 读取成功
                    buffer[n] = '\0';
                    conn->_inbuffer += buffer;
                }
                else if(n == 0)
                {
                    // 对方关闭连接
                    logMessage(DEBUG, "sock-%d[%s:%d] close connection, server close connection!", \
                                       conn->_sock, _users[conn->_sock]->_ip.c_str(), _users[conn->_sock]->_port);
                    conn->_except_cb(conn);  // 调用异常处理方法
                    err = true;
                    break;
                }
                else
                {
                    // 小于0判断是否读取完毕
                    if (errno == EAGAIN || errno == EWOULDBLOCK) break;  // 读取完毕正常退出
                    else if (errno == EINTR) continue;  // 中断了,在继续读取
                    else
                    {
                        err = true;
                        // 此时真的出错了
                        logMessage(FATAL, "recv error %d:%s", errno, strerror(errno));
                        conn->_except_cb(conn);  // 调用异常处理方法
                        break;
                    }
                }
            }
            if (!err)
            {
                logMessage(DEBUG, "sock:%d[%s:%d]# %s", \
                           conn->_sock, _users[conn->_sock]->_ip.c_str(), _users[conn->_sock]->_port, conn->_inbuffer.c_str());
                // 此时需要保证读取的数据是一个一个独立完整的报文,然后传递给上层逻辑进行处理
                std::vector messages;
                QiHai::SpliteMessage(conn->_inbuffer, messages);  // test:{"x":1,"y":2,"op":43}{"x":2,"y":3,"op":47}{"x":0,"y":0,"op":37}{"x":1,
                for (auto& msg : messages)
                {
                    // 调用上层逻辑进行处理,服务器只是帮你提取出报文出来
                    _call(conn, msg);
                }
            }
        }

        void Sender(Connection* conn)
        {
            // 写也是非阻塞的写,也就是说,如果写入缓冲区满了也是会直接返回
            while(true)
            {
                int n = send(conn->_sock, conn->_outbuffer.c_str(), conn->_outbuffer.size(), 0);
                if (n > 0)
                {
                    // 写入成功
                    conn->_outbuffer.erase(0, n);
                    if (conn->_outbuffer.empty()) break;  // 写完了,退出
                }
                else{
                    if (errno == EAGAIN || errno == EWOULDBLOCK) break;  //  此时底层的发送缓冲区可能满了,不可发送,等下次机会 - 只要空了就会在执行这里
                    else if (errno == EINTR) continue;  // IO中断了,重新试一次
                    else{
                        // 此处出错了
                        logMessage(FATAL, "send error %d:%s", errno, strerror(errno));
                        conn->_except_cb(conn);
                        break;
                    }
                }
            }

            // 注意,如果将缓冲区内的数据发完了,需要关闭epoll对其写入事件的关心 - 因为一旦发送缓冲区变化了-变空 会通知的
            if (conn->_outbuffer.empty()) EnableReadWrite(conn, true, false);
            else EnableReadWrite(conn, true, true);
                // 保险起见,没发完的下次还要继续发
        }

        void Excpeter(Connection* conn)
        {
            User* user = _users[conn->_sock];
            _users.erase(conn->_sock);
            delete user;

            if (!_poll.DelFromEpoll(conn->_sock)) exit(6);  // 从epoll 模型中移除
            _connections.erase(conn->_sock);
            close(conn->_sock);  // 关闭此文件描述符
            delete conn;
        }

        bool IsConnectionExists(int sock)
        {
            auto res = _connections.find(sock);  // 可能后续因为异常,存在没有映射到此管理的表中的,这里需要检测一下
            return res != _connections.end();
        }
        
        void LoopOnce()
        {
            // 具体去就epoll就绪队列中获取
            int n = _poll.WaitEpoll(_revs, _revs_num);  // 默认10s阻塞一次
            if (n == 0)
            {
                logMessage(DEBUG, "events wait......");
            }
            else if (n < 0)
            {
                logMessage(FATAL, "epoll_wait error %d:%s", errno, strerror(errno));
                exit(7);
            }
            else{
                logMessage(DEBUG, "have events!");
                for (int i = 0; i < n; ++i)
                {
                    int sock = _revs[i].data.fd;
                    int event = _revs[i].events;

                    if (event & EPOLLERR) _revs[i].events |= (EPOLLIN | EPOLLOUT);  // 直接掉用recv、send报错后调用异常处理
                    if (event & EPOLLHUP) _revs[i].events |= (EPOLLIN | EPOLLOUT);  // 对方断开连接同理

                    if (event & EPOLLIN)
                    {
                        if(IsConnectionExists(sock) && _connections[sock]->_recv_cb)  // 首先是否找得到,然后判断是否注册了读取回调函数
                            _connections[sock]->_recv_cb(_connections[sock]);
                    }
                    if (event & EPOLLOUT)
                    {
                        if (IsConnectionExists(sock) && _connections[sock]->_send_cb)
                            _connections[sock]->_send_cb(_connections[sock]);
                    }
                }
            }
        }

        void Survivallink()  // 生存链接时间,发现大于MAX_TIME,主动断开连接
        {
            auto res = _connections.begin();
            while (res != _connections.end())
            {
                time_t t = time(nullptr);
                Connection* conn = res->second;
                ++res;
                if (t - conn->_time >= MAX_TIME && conn->_except_cb)  // 排除了sock
                {
                    logMessage(DEBUG, "sock:%d[%s:%d] No communication for a long time,close sock!",\
                                       conn->_sock, _users[conn->_sock]->_ip.c_str(), _users[conn->_sock]->_port);
                    conn->_except_cb(conn);
                }
            }
        }
    public:
        TcpServer(uint16_t port = gport)
        :_port(port), _revs(nullptr), _revs_num(gnum)
        {
            _listensock = QiHai::Sock::socket();
            if (_listensock < 0) exit(1);

            // 绑定
            if (!QiHai::Sock::bind(_listensock, _port)) exit(3);

            // 设置监听状态
            if (!QiHai::Sock::listen(_listensock)) exit(4);
            logMessage(DEBUG, "_listensock init success!");

            // 创建epoll模型
            if (!_poll.EpollCreate()) exit(5);
            logMessage(DEBUG, "epoll init success!");

            // 此时能否向以前那样,所有sock共享一个缓冲区呢(即裸的sock)?自然不能,可能存在多个sock是阶段性发送的,报文数据不完全。
            // 所以我们需要维护sock的每一个缓冲区,先描述在组织 使用类connection进行描述,使用哈希表实现的map进行一个组织
            // 在添加监听套接字对象到epoll之前,首先维护好一个就绪缓冲区
            _revs = new epoll_event[_revs_num];

            // 正式添加,我们增加一个接口,后续sock添加到里面都通过此接口 - 要建立连接类之类的,解耦一下
            AddConnection(_listensock, std::bind(&TcpServer::Accepter, this, std::placeholders::_1), nullptr, nullptr);
            logMessage(DEBUG, "listensock connection add success!");
        }

        // 修改连接在epoll模型的读写状态
        void EnableReadWrite(Connection* conn, bool readable, bool writeable)
        {
            int event = (readable ? EPOLLIN : 0) | (writeable ? EPOLLOUT : 0);
            if (!_poll.CtlSockToEpoll(conn->_sock, event)) exit(6);
        }

        // 服务器开始对特定事件等待并且进行一个派发
        void Dispather(service_logic func)
        {
            _call = func;  // 业务处理函数
            while(true)
            {
                Survivallink();  // 每次循环检查一次
                LoopOnce();  // 一次
            }
        }

        ~TcpServer()
        {
            close(_listensock);
            if (_revs != nullptr) delete[] _revs;
        }
    };


}

#endif
// main.cc 程序入口
#include "TcpServer.hpp"
#include 

void business(QiHai::Request& req, QiHai::Response& res)
{
    res._state = 1;
    switch (req._op)
    {
    case '+':
        res._result = req._x + req._y;
        break;
    case '-':
        res._result = req._x - req._y;
        break;
    case '*':
        res._result = req._x * req._y;
        break;
    case '/':
        if (req._y == 0)
        {
            res._state = 0;
            res._result = 1;  // 除0异常
        }
        else res._result = req._x / req._y;
        break;
    case '%':
        if (req._y == 0)
        {
            res._state = 0;
            res._result = 2;  // 模0异常
        }
        else res._result = req._x % req._y;
        break;
    default:
        res._state = 0;
        res._result = 3;  // 未知运算符
        break;
    }
}

void Natcb(QiHai::Connection* conn, std::string message)
{
    // 上层业务处理
    // 接收到一个报文后,因为是一个结构化的东西,首先进行反序列化
    QiHai::Request req;
    if (!req.deserialization(message))
    {
        logMessage(WARNING, "Request deserialization error!");
        return;
    }

    QiHai::Response res;
    business(req, res);
    conn->_outbuffer += res.serialization();
    conn->_tsvr->EnableReadWrite(conn, true, true);  // 修改一次写的状态,剩下由服务器进行处理
}

int main()
{
    std::unique_ptr server(new QiHai::TcpServer);
    server->Dispather(Natcb);

    // QiHai::Response res;
    // res.deserialization("{\"state\":1,\"result\":2}");
    // std::cout << res.serialization() << std::endl;

    // QiHai::Request req;
    // std::string msg = "{\"op\":43,\"x\":1,\"y\":2}";
    // req.deserialization(msg);
    // std::cout << req.serialization() << std::endl;

    // QiHai::Request req(1, 2, '+');
    // std::cout << req.serialization() << std::endl;
    return 0;
}

实现效果:

        由于没有实现此服务器的客户端,所以使用telnet模拟发送一个自己定制协议的报文,查看结果,并且在创建一个进行连接,长时间不请求,是否会断开:

【Linux】高级IO_第10张图片 

你可能感兴趣的:(网络,Linux,linux,运维,服务器)