【计算机网络】poll | epoll

文章目录

[1. poll](#1. poll)
- poll函数参数解析
- 代码解析
- - PollServer代码
- [poll 特点](#poll 特点)
[2. epoll](#2. epoll)

1. poll

poll函数参数解析

输入 man poll

poll的第一个参数是文件描述符
poll的第二个参数为等待的多个文件描述符(fd)数字层面最大的+1

poll函数中的最后一个参数 timeout 是一个纯输入型参数，单位是毫秒
若 timeout 为-1，则表示永久阻塞，直到文件描述符就绪
若 timeout为0，则表示非阻塞
若timeout 大于0，则表示在timeout事件以内以阻塞等待，超时则进行非阻塞等待

poll的返回值的含义与select 相同
第一种大于0表示有几个文件描述符是就绪的
第二种等于0进入timeout状态，即 5s以内没有任何一个文件描述符就绪
第三种小于0等待失败返回-1如：想要等待下标为1 和2的文件描述符，但是下标为2的文件描述符根本不存在，就会等待失败

在pollfd 结构体中
fd 表示文件描述符
events：用户告诉内核，需要关心那些文件描述符上的那些事件
revents ：内核会告诉用户，关心的那些文件描述符上的那些事件已经就绪

poll将输入参数和输出参数进行分离

poll就有对应的事件
常用的有
POLLIN 表示有数据可以读
POLLOUT 表示当前写的时候不会被阻塞

POLLIN 表示第一个比特位为1
POLLOUT 表示第三个比特位为1

代码解析

主要将第一个初始版本的select代码进行修改

由于poll 自带结构体，内部包含
fd (文件描述符)
events (用户告诉操作系统那些文件描述符上的事件需要关心)
revents (操作系统告诉用户关心的那些文件描述符上的事件已经就绪)

此时的fdaaray作为结构体指针，可以通过该指针去指向 pollfd结构体成员

当想要使用数组当前元素表示对应的文件描述符时，需指向对应的fd成员

想要表示 (用户告诉操作系统那些文件描述符上的事件需要关心)
需要通过指针去指向对应的成员 events
想要表示 (操作系统告诉用户关心的那些文件描述符上的事件已经就绪)
需要通过指针去指向对应的成员 revents

PollServer代码

cpp 复制代码

#include<iostream>
#include<string>
#include<sys/poll.h>
#include<cstring>
#include"Sock.hpp"
#include"Log.hpp"
#include"Err.hpp"
using namespace std;


  const static int gport=8888;    

  const static int N=4096;

  const static short defaultevent=0;

typedef pollfd type_t;

class PollServer
{
 public:
      PollServer(uint16_t port=gport)
      :port_(port),fdarray_(nullptr)
      {}

      void InitServer()//初始化
      {
           listensock_.Socket();//创建套接字
           listensock_.Bind(port_);//绑定
           listensock_.Listen();//设置监听状态
           
           fdarray_=new type_t[N];
           //对fdarray数组进行初始化
           for(int i=0;i<N;i++)
           {
             fdarray_[i].fd= defaultfd;
             fdarray_[i].events= defaultevent;
             fdarray_[i].revents=defaultevent;
           }
      }


     void Accepter()//获取新连接的动作
     {
             //这里再使用accept 就不会阻塞了
             //listen套接字底层一定有就绪的事件 即连接已经到来了
             string clientip;
             uint16_t  clientport;
            int sock=listensock_.Accept(&clientip,&clientport);//获取客户端IP和端口号
            if(sock<0)
            {
              return;
            }
            
            //当得到对应新连接的sock套接字，是不能进行read/recv
            //并不知道sock上的数据是否就绪的
            //所以需要将sock交给select,由select进行管理
            logMessage(Debug,"[%s:%d],sock:%d",clientip.c_str(),clientport,sock );
             //只需把新获取的sock 添加到 数组中
             int pos=1;
             for(;pos<N;pos++)
             {
                if(fdarray_[pos].fd==defaultfd)//说明没有被占用
                {
                   break;
                }
             }
             if(pos>=N)//整个数组中的位置全被占用了
             {
              //由于fdarray_是动态开辟空间的，所以可以动态扩容

              //若扩容失败，则close
                close(sock);
                logMessage(Warning,"sockfd[] array full");
             }
             else //找到了对应的位置
             {
                fdarray_[pos].fd=sock;
                fdarray_[pos].events=POLLIN;
                fdarray_[pos].revents=defaultevent;
             }
     }
     
      void  HandlerEvent()//处理就绪事件
      { 
             for(int i=0;i<N;i++)
             {
              int fd=fdarray_[i].fd;
              int revent= fdarray_[i].revents;

               if( (fd==defaultfd)&&(revent &POLLIN))//读事件就绪
               { 
                  continue;
               }
               //合法fd

               //若套接字为listensock套接字，并且读事件就绪
               if(fd==listensock_.Fd() &&(revent &POLLIN))
               {
                  Accepter();
               }
               //若套接字不是listensock套接字，并且读事件就绪 即普通的读取数据就绪
                else if ((fd != listensock_.Fd()) && (revent &POLLIN)) 
               {
                   char buffer[1024];
                   ssize_t s=recv(fd,buffer,sizeof(buffer)-1,0);
                   //读取不会被阻塞
                   if(s>0)//读取成功
                   {
                     buffer[s-1]=0;
                     cout<<"client# "<<buffer<<endl;

                     //发送回去 也要被select管理
                      string echo=buffer ;
                      echo+= "[select server echo ]";
                      send(fd,echo.c_str(),echo.size(),0);//发送消息 将echo内的数据 交给fd
                   }
                   else 
                   {
                     if(s==0)//读到文件结尾
                     {
                       logMessage(Info,"client quit...,fdarray_[i] -> defaultfd:%d->%d",fd,defaultfd);
                     }
                     else //读取失败 
                     {
                       logMessage(Warning,"recv error,client quit...,fdarray_[i] -> defaultfd:%d->%d",fd,defaultfd);
                     }  
                      close(fd);
                      fdarray_[i].fd=defaultfd;
                      fdarray_[i].events=defaultevent;
                      fdarray_[i].revents=defaultevent;
                   }   
                } 
             } 
      }
      

        void DebugPrint()
       {
         cout<<"fdarray_[]:"<<endl;
         for(int i=0;i<N;i++)
         {
          if(fdarray_[i].fd==defaultfd)
          {
            continue;
          }
          cout<<fdarray_[i].fd<<" ";
         }
         cout<<"\n";
       }

      void Start() //启动
      {
        //在网络中，新连接到来被当作 读事件就绪
        //对应不同的事件就绪，做出不同的动作
        
        fdarray_[0].fd=listensock_.Fd();
        fdarray_[0].events=POLLIN;//数据可读
        while(true) 
        {
          int timeout= -1;//永久阻塞  
            int n= poll(fdarray_,N,timeout);
            //timeout 设为nullptr后，全部为阻塞等待

            switch(n)
            {
              case 0:   //表示没有任何一个文件描述符就绪 
               logMessage(Debug,"timeout,%d: %s",errno,strerror(errno));
               break;

             case -1:  //等待失败 返回-1
              logMessage(Warning,"%d: %s",errno,strerror(errno));
              break;

             default:  //大于0 ，则表示成功 返回有多少文件描述符就绪
                logMessage(Debug,"有一个就绪事件发生了:%d",n);
                 HandlerEvent();//处理就绪事件
                 DebugPrint();//打印数组内容
               break;
            }
        }
      }
       
      ~PollServer()
       {
        listensock_.Close();
        if(fdarray_)
        {
          delete[]fdarray_;
        }
       }

 private:
     uint16_t port_;//端口号
      Sock listensock_;//创建Sock对象
      type_t* fdarray_;//自己定义一个数组,与位图大小相同，来进行已经获得的sock进行管理
};