网络编程---I/O多路转接之select

高级IO

  • 1. 五种IO模型
    • 1.1 阻塞IO
    • 1.2 非阻塞IO
    • 1.3 信号驱动IO
    • 1.4 多路复用、多路转接
    • 1.5 异步IO
  • 2. 非阻塞
  • 3. I/O多路转接之select
    • 3.1 select执行过程
    • 3.2 select完整代码实现

1. 五种IO模型

讲一个钓鱼的小故事:
钓鱼一共分为两步一步是还有一步是,那么真正有作用的其实是钓,可以把等待理解为无用的。

  • 张三:自己钓鱼的时候,等期间谁也不搭理,就专心的盯着自己的鱼漂是否有咬钩,如果咬钩了就将鱼捞起来。
  • 李四:自己钓鱼的时候,等待期间还不时的询问一下张三是否有钓上来鱼,即使张三一直也不搭理他但是他还是会不间断的过一会询问一下他,等到钓上鱼的时候就把鱼捞起来。
  • 王五:自己钓鱼的时候,给鱼竿上面绑了一个铃铛,他就直接拿起一本书看了起来,他知道当铃铛响的时候就是鱼上钩了,只要上钩就过来把鱼捞起来。
  • 赵六:是一个本地的小土豪很有钱,此时他一下子带了很多很多的鱼竿过来,然后将鱼竿全部撒饵放下去,然后自己就在跟前看有哪一个鱼竿咬钩了,就立马过去将鱼捞起来。
  • 田七:是一个超级大老板,他突然想要吃鱼,然后就给秘书小刘说:“我给你一个鱼竿和桶,你去帮我钓鱼,当桶都钓满的时候你就给我打电话,我过来把你接上,咱们一起去把这个鱼給烤掉”,然后就把小刘放在了鱼塘自己开着车去蒸桑拿了。

1.1 阻塞IO

阻塞IO就是上例中的张三在内核将数据准备好之前, 系统调用会一直等待. 所有的套接字, 默认都是阻塞方式。

阻塞IO是最常见的IO模型.
网络编程---I/O多路转接之select_第1张图片

1.2 非阻塞IO

非阻塞IO就是上例中的李四: 如果内核还未将数据准备好, 系统调用仍然会直接返回, 并且返回EWOULDBLOCK错误码.非阻塞IO往往需要程序员循环的方式反复尝试读写文件描述符, 这个过程称为轮询. 这对CPU来说是较大的浪费, 一般只有特定场景下才使用.

网络编程---I/O多路转接之select_第2张图片

1.3 信号驱动IO

信号驱动IO就是上例的王五: 内核将数据准备好的时候, 使用SIGIO信号通知应用程序进行IO操作。
网络编程---I/O多路转接之select_第3张图片

1.4 多路复用、多路转接

IO多路转接就是上例的赵六: 虽然从流程图上看起来和阻塞IO类似. 实际上最核心在于IO多路转接能够同时等待多个文件描述符的就绪状态.
网络编程---I/O多路转接之select_第4张图片

1.5 异步IO

异步IO就是上例的田七: 由内核在数据拷贝完成时, 通知应用程序(而信号驱动是告诉应用程序何时可以开始拷贝数据).
网络编程---I/O多路转接之select_第5张图片
小结

  • 任何IO过程中, 都包含两个步骤. 第一是等待, 第二是拷贝. 而且在实际的应用场景中, 等待消耗的时间往往都远远高于拷贝的时间. 让IO更高效, 最核心的办法就是让等待的时间尽量少.
  • 同步IO和异步IO最大的区别就是,是否最终要自己进行拷贝数据,如果需要自己拷贝数据那就是同步IO,如果不需要自己进行拷贝数据那就是异步IO,所以前四种都是同步IO。
  • 高级IO(高效IO)本质:等是没有做贡献的,所以尽可能的要减少等的比重
    IO = 等待 + 拷贝
    recv(读IO) = 读时间就绪 + 内核数据拷贝到用户空间
    send(写IO)= 写时间就绪 + 用户数据拷贝到内核空间

同步通信 vs 异步通信
同步和异步关注的是消息通信机制.

  • 所谓同步,就是在发出一个调用时,在没有得到结果之前,该调用就不返回. 但是一旦调用返回,就得到返回值了; 换句话说,就是由调用者主动等待这个调用的结果;
  • 异步则是相反,调用在发出之后,这个调用就直接返回了,所以没有返回结果; 换句话说,当一个异步过程调用发出后,调用者不会立刻得到结果; 而是在调用发出后,被调用者通过状态、通知来通知调用者,或通过回调函数处理这个调用.

阻塞 vs 非阻塞
阻塞和非阻塞关注的是程序在等待调用结果(消息,返回值)时的状态.

  • 阻塞调用是指调用结果返回之前,当前线程会被挂起. 调用线程只有在得到结果之后才会返回.
  • 非阻塞调用指在不能立刻得到结果之前,该调用不会阻塞当前线程

2. 非阻塞

fcntl

一个文件描述符, 默认都是阻塞IO,所来所接触的也都是阻塞IO,并没有接触过非阻塞的接口。

函数原型如下

#include
#include
int fcntl(int fd, int cmd, … /* arg */ );

传入的cmd的值不同, 后面追加的参数也不相同.
fcntl函数有5种功能:

  • 复制一个现有的描述符(cmd=F_DUPFD
  • 获得/设置文件描述符标记(cmd=F_GETFD或F_SETFD).
  • 获得/设置文件状态标记(cmd=F_GETFL或F_SETFL)(最重要).
  • 获得/设置异步I/O所有权(cmd=F_GETOWN或F_SETOWN).
  • 获得/设置记录锁(cmd=F_GETLK,F_SETLK或F_SETLKW)
  • 我们此处只是用第三种功能, 获取/设置文件状态标记, 就可以将一个文件描述符设置为非阻塞

轮询方式读取标准输入

#include
#include
#include
#include

void SetNonBlock(int fd)
{
  int f1 = fcntl(fd,F_GETFL); //获取文件描述符的属性
  if(f1 < 0)
  {
    perror("fcntl error!\n");
    return;
  }
  fcntl(fd,F_SETFL,f1 | O_NONBLOCK);
}

int main()
{
  char c = 0;
  SetNonBlock(0);
  while(1)
  {
    sleep(1);
    ssize_t s = read(0,&c,1);
    if(s > 0)
    {
      printf("%c\n",c);
    }
    else if(s < 0 && errno == EAGAIN)
    {
      printf("read cond not ok!\n");
    }
    else 
    {
      perror("read error!\n");
    }
    printf(".........................\n");
  }
  return 0;
}

网络编程---I/O多路转接之select_第6张图片

  • 使用F_GETFL将当前的文件描述符的属性出来(这是一个位图).
  • 然后再使用F_SETFL将文件描述符设置回去. 设置回去的同时, 加上一个O_NONBLOCK参数
  • 要知道到底是出错了,还是内核的接受缓冲区没有就绪
  • EAGAIN是try again的意思,是一个错误码的宏定义

3. I/O多路转接之select

select的核心作用就是等,就绪事件通知方式,单进程内,同时等待多个文件描述符。

系统提供select函数来实现多路复用输入/输出模型.

  • select系统调用是用来让我们的程序监视多个文件描述符的状态变化的;
  • 程序会停在select这里等待,直到被监视的文件描述符有一个或多个发生了状态改变

select函数原型
select的函数原型如下:

#include

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

参数解释:

  • 参数nfds是需要监视的最大的文件描述符值+1;(假设此时文件描述符是1和7,那么这个值就是8)
  • rdset,wrset,exset分别对应于需要检测的可读文件描述符的集合可写文件描述符的集合及异常文件描述符的集合;
  • 参数timeout为结构timeval,用来设置select()的等待时间

参数timeout取值:

  • NULL(阻塞方式等):则表示select()没有timeout,select将一直被阻塞,直到某个文件描述符上发生了事件;
  • 0(非阻塞方式等)仅检测描述符集合的状态,然后立即返回,并不等待外部事件的发生
  • 特定的时间值:如果在指定的时间段里没有事件发生,select将超时返回。

关于fd_set结构

  • 其实这个结构就是一个整数数组, 更严格的说, 是一个 “位图. 使用位图中对应的位来表示要监视的文件描述符.
  • fd_set:位图结构,比特位的位置代表是哪一个文件描述符,就以readfds为例,这个参数即使输入型参数也是输出型参数,比特位的内容(输入):是否需要关心特定文件描述符的读事件就绪(用户想告诉操作系统:你应该帮我关心那些文件描述符读事件就绪),比特位的内容(输出):所关心的特定文件描述符的读事件已经就绪(操作系统告诉用户) ,此时应该对返回的位图进行遍历检查那个比特位是1,说明该文件描述符读时间已经就绪,不好的地方就在于,下一次需要对这个参数重新设定,恢复你需要特别关心的是那几个文件描述符。

提供了一组操作fd_set的接口, 来比较方便的操作位图

  • void FD_CLR(int fd, fd_set *set); // 用来清除描述词组set中相关fd 的位
  • int FD_ISSET(int fd, fd_set *set); // 用来测试描述词组set中相关fd 的位是否为真
  • void FD_SET(int fd, fd_set *set); // 用来设置描述词组set中相关fd的位
  • void FD_ZERO(fd_set *set); // 用来清除描述词组set的全部位

关于timeval结构

  • timeval结构用于描述一段时间长度,如果在这个时间内,需要监视的描述符没有事件发生则函数返回,返回值为0
    在这里插入图片描述

函数返回值

  • 执行成功则返回文件描述词状态已改变的个数
  • 如果返回0代表在描述词状态改变前已超过timeout时间,没有返回
  • 当有错误发生时则返回-1,错误原因存于errno,此时参数readfds,writefds, exceptfds和timeout的值变成不可预测。

错误值可能为(但是一般很少情况下才会出错,所以目前先不看):

  • EBADF 文件描述词为无效的或该文件已关闭
  • EINTR 此调用被信号所中断
  • EINVAL 参数n 为负值。
  • ENOMEM 核心内存不足

3.1 select执行过程

理解select模型的关键在于理解fd_set,为说明方便,取fd_set长度为1字节,fd_set中的每一bit可以对应一个文件描述符fd。则1字节长的fd_set最大可以对应8个fd.

  • (1)执行fd_set set; FD_ZERO(&set);则set用位表示是0000,0000。
  • (2)若fd=5,执行FD_SET(fd,&set);后set变为0001,0000(第5位置为1)
  • (3)若再加入fd=2,fd=1,则set变为0001,0011
  • (4)执行select(6,&set,0,0,0)阻塞等待
  • (5)若fd=1,fd=2上都发生可读事件,则select返回,此时set变为0000,0011。注意:没有事件发生的fd=5被清空

socket就绪条件

读就绪

  • socket内核中, 接收缓冲区中的字节数, 大于等于低水位标记SO_RCVLOWAT(并不是接收缓冲区只要一有数据,就立马读,而是设置了一个低水位标记,为了保证读取的效率). 此时可以无阻塞的读该文件描述符, 并且返回值大于0;
  • socket TCP通信中, 对端关闭连接, 此时对该socket读, 则返回0;
  • 监听的socket上有新的连接请求,这个请求是以读事件报告给操作系统的;
  • socket上有未处理的错误;

写就绪

  • socket内核中, 发送缓冲区中的可用字节数(发送缓冲区的空闲位置大小), 大于等于低水位标记SO_SNDLOWAT, 此时可以无阻塞的写, 并且返回值大于0;
  • socket的写操作被关闭(close或者shutdown). 对一个写操作被关闭的socket进行写操作, 会触发SIGPIPE信号;
  • socket使用非阻塞connect连接成功或失败之后;
  • socket上有未读取的错误;

3.2 select完整代码实现

main.cc

#include"SelectServer.hpp"

void Usage(std::string proc)
{
  cout << "Usage :\n\t" << proc << "port"<< endl;
}


//Server port
int main(int argc,char *argv[])
{
  if(argc != 2)
  {
    Usage(argv[0]);
    exit(1);
  }

  SelectServer *ssvr = new SelectServer(atoi(argv[1]));
  ssvr->InitServer();
  ssvr->Start();


  return 0;
}

Sock.hpp

#pragma once 

#include
#include
#include

#include
#include
#include
#include
#include

#include
#include
using namespace std;

#define BACKLOG 5
class Sock
{
  public:
    static int Socket()
    {
      int sock = socket(AF_INET,SOCK_STREAM,0);
      if(sock < 0)
      {
        cerr << "socket error!" << endl;
        exit(2);
      }
      return sock;
    }

    static void Bind(int sock,int port)
    {
      struct sockaddr_in local;
      bzero(&local,sizeof(local));

      local.sin_family = AF_INET;
      local.sin_port = htons(port);
      local.sin_addr.s_addr = htonl(INADDR_ANY);
      if(bind(sock,(struct sockaddr*)&local,sizeof(local)) < 0)
      {
        cerr << "bind error!"<< endl;
        exit(3);
      }
    }

    static void Listen(int sock)
    {
      if(listen(sock,BACKLOG) < 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)
      {
        cerr << "accept error!"<<endl;
      }
      return fd;
    }

    static void SetsockOpt(int sock)
    {
      //因为对于server来说,主动断开连接的时候会进入time_wait状态,所以要端口复用
      int opt = 1;
      setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));
    }
};

SelectServer.hpp

#pragma once

#include"Sock.hpp"

#define DFL_PORT 8080
#define NUM (sizeof(fd_set)*8)
#define DFL_FD -1

class SelectServer
{
  private:
    int port;
    int lsock;
    //需要一个辅助的数组,需要把所有打开的文件描述符都保存起来
    int fd_array[NUM];
  public:
    SelectServer(int _p = DFL_PORT)
      :port(_p)
    {}

    void InitServer()
    {
      for(int i = 0;i < NUM;++i)
      {
        fd_array[i] = DFL_FD;
      }
      lsock = Sock::Socket();
      Sock::SetsockOpt(lsock); //将listen socket 设置为端口复用
      Sock::Bind(lsock,port);
      Sock::Listen(lsock);

      fd_array[0] = lsock;
    }
    //找到数组中默认-1的,然后把这个位置给占掉
    void AddFd2Array(int sock)
    {
      int i = 0;
      for( ; i < NUM; i++)
      {
        if(fd_array[i] ==DFL_FD){
          break;
        }
      }
      
      //有可能不断的来新链接,然后把数组给弄满了
      if(i == NUM)
      {
        cerr << "fd array is full,close sock" << endl;
        close(sock);
      }
      else 
      {
        fd_array[i] = sock;
        cout << "fd: " << sock << " add to select..."<< endl;
      }
    }

    void DefFdFromArray(int index)
    {
      if(index >=0 && index < NUM){
        fd_array[index] = DFL_FD;
      }
    }

    void HandlerEvents(fd_set *rfds)
    {
      for(int i =0;i < NUM;++i)
      {
        if(fd_array[i] == DFL_FD)
        {
          continue;
        }
        //走到这里说明有文件描述符发生了改变,并判断该文件描述符是否属于原来的rfds集合中
        //只有你设置了关心的文件描述符,在返回的时候才会发生改变,没有设置的他压根不在乎
        if(FD_ISSET(fd_array[i],rfds))
        {
          //read ready
          //其实read ready就绪依旧存在两种情况,一种就是数据准备就绪了,还有一种情况是有了新链接
          if(fd_array[i] == lsock)
            //link event 
          {
            int sock = Sock::Accept(lsock);
            if(sock >= 0){
              //sock ok
              //获得一个新的文件描述符,一定不敢直接的读取,如果对方不给你发数据,那就直接阻塞了
              cout << "get a new link ... "<< endl;
              AddFd2Array(sock);
            }
          }
          //date ready event 应该进行IO
          else 
          {
            char buffer[1024];
            ssize_t s = recv(fd_array[i],buffer,sizeof(buffer),0);
            if(s > 0){
              buffer[s] = 0;
              cout << "client# " << buffer << endl;
            }
            else if(s == 0){
              cout << "client quit" << endl;
              close(fd_array[i]);
              //还需要把这个文件描述符从全局数组fd_array中删除掉
              DefFdFromArray(i);
            }
            else{
              cout << "fd error!"<< endl;
              close(fd_array[i]);
              DefFdFromArray(i);
            }
          }
        }
      }
    }

    void Start()
    {
      int maxfd = DFL_FD;//服务器一启动的时候文件描述符就只有lsock一个
      //timeout 能够设置三种值 当NULL表示没有timeout,一直阻塞式的等,当0表示非阻塞状态,当是一个确切的数值的时候,表示等特定的时间,如果时间到了没有时间发送,那么就超时返回
      for(;;)
      {
        //对于select来说,每一次都要重新的去设置这个位图结构的fd_set
        fd_set rfds;
        FD_ZERO(&rfds);
        cout << "fd_array: ";
        for(int i = 0;i < NUM; i++)
        {
          if(fd_array[i] != DFL_FD)
          {
            cout <<fd_array[i]<< " ";
            FD_SET(fd_array[i],&rfds);
            if(maxfd < fd_array[i])
            {
              maxfd = fd_array[i];
            }
          }
        }
        cout << endl;
        //这个timeout也是一个输入、输出型参数,第一次会等待5s,但是由于第一次没有事件发生timeout减为0,第二次及以后都不在等待,所以我们要每次进来都设置一次
        printf("begin select...\n");
        //struct timeval timeout = {5,0};
        switch(select(maxfd+1,&rfds,nullptr,nullptr, nullptr))
        {
          case 0:
            cout << "timeout"<< endl;
              break;
          case -1:
            cerr << "select error"<< endl;
              break;
          default:
              //此时的select的文件描述符时大于0
              //success
              HandlerEvents(&rfds);
              break;
        }
      }
    }

    ~SelectServer()
    {}
};

网络编程---I/O多路转接之select_第7张图片
缺点

  1. 监视的文件描述符是由上限的。(可监控的文件描述符个数取决与sizeof(fd_set)的值. 每bit表示一个文件描述符,则我服务器上支持的最大文件描述符是128*8=1024)
  2. 每次都要进行文件描述符的主动添加,过于麻烦
  3. 每次调用select,都需要把fd集合从用户态拷贝到内核态,这个开销在fd很多时会很大
  4. 同时每次调用select都需要在内核遍历传递进来的所有fd,这个开销在fd很多时也很大
  5. select支持的文件描述符数量太小

你可能感兴趣的:(计算机网络)