IO多路复用-select,poll,epoll

马大xia
134 阅读1分钟 
本文是学习笔记,资料是B站视屏
https://www.bilibili.com/medialist/detail/ml302348722?type=1&spm_id_from=333.999.0.0

select

select函数使用实例代码

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/fcntl.h>

// 初始化服务端的监听端口。
int initserver(int port);

int main(int argc,char *argv[]){
  if (argc != 2){
    printf("usage: ./tcpselect port\n"); return -1;
  }

  // 初始化服务端用于监听的socket。
  int listensock = initserver(atoi(argv[1]));
  printf("listensock=%d\n",listensock);

  if (listensock < 0){
    printf("initserver() failed.\n"); return -1;
  }

  fd_set readfdset;  // 读事件的集合，包括监听socket和客户端连接上来的socket。
  int maxfd;  // readfdset中socket的最大值。

  // 初始化结构体，把listensock添加到集合中。
  FD_ZERO(&readfdset);

  FD_SET(listensock,&readfdset);
  maxfd = listensock;

  while (1){
    // 调用select函数时，会改变socket集合的内容，所以要把socket集合保存下来，传一个临时的给select。
    fd_set tmpfdset = readfdset;

    int infds = select(maxfd+1,&tmpfdset,NULL,NULL,NULL);
    // printf("select infds=%d\n",infds);

    // 返回失败。
    if (infds < 0){
      printf("select() failed.\n"); perror("select()"); break;
    }

    // 超时，在本程序中，select函数最后一个参数为空，不存在超时的情况，但以下代码还是留着。
    if (infds == 0){
      printf("select() timeout.\n"); continue;
    }

    // 检查有事情发生的socket，包括监听和客户端连接的socket。
    // 这里是客户端的socket事件，每次都要遍历整个集合，因为可能有多个socket有事件。
    for (int eventfd=0; eventfd <= maxfd; eventfd++){
      if (FD_ISSET(eventfd,&tmpfdset)<=0) continue;
      if (eventfd==listensock){ 
        // 如果发生事件的是listensock，表示有新的客户端连上来。
        struct sockaddr_in client;
        socklen_t len = sizeof(client);
        int clientsock = accept(listensock,(struct sockaddr*)&client,&len);
        if (clientsock < 0){
          printf("accept() failed.\n"); continue;
        }
        printf ("client(socket=%d) connected ok.\n",clientsock);
        // 把新的客户端socket加入集合。
          
        FD_SET(clientsock,&readfdset);
        if (maxfd < clientsock) maxfd = clientsock;
        continue;
      }
      else{
        // 客户端有数据过来或客户端的socket连接被断开。
        char buffer[1024];
        memset(buffer,0,sizeof(buffer));

        // 读取客户端的数据。
        ssize_t isize=read(eventfd,buffer,sizeof(buffer));

        // 发生了错误或socket被对方关闭。
        if (isize <=0){
          printf("client(eventfd=%d) disconnected.\n",eventfd);

          close(eventfd);  // 关闭客户端的socket。

          FD_CLR(eventfd,&readfdset);  // 从集合中移去客户端的socket。

          // 重新计算maxfd的值，注意，只有当eventfd==maxfd时才需要计算。
          if (eventfd == maxfd){
            for (int ii=maxfd;ii>0;ii--){
              if (FD_ISSET(ii,&readfdset)){
                maxfd = ii; break;
              }
            }
            printf("maxfd=%d\n",maxfd);
          }
          continue;
        }
        printf("recv(eventfd=%d,size=%d):%s\n",eventfd,isize,buffer);
        // 把收到的报文发回给客户端。
        write(eventfd,buffer,strlen(buffer));
      }
    }
  }

  return 0;
}

// 初始化服务端的监听端口。
int initserver(int port){
  int sock = socket(AF_INET,SOCK_STREAM,0);
  if (sock < 0){
    printf("socket() failed.\n"); return -1;
  }

  // Linux如下
  int opt = 1; unsigned int len = sizeof(opt);
  setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&opt,len);
  setsockopt(sock,SOL_SOCKET,SO_KEEPALIVE,&opt,len);

  struct sockaddr_in servaddr;
  servaddr.sin_family = AF_INET;
  servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
  servaddr.sin_port = htons(port);

  if (bind(sock,(struct sockaddr *)&servaddr,sizeof(servaddr)) < 0 ){
    printf("bind() failed.\n"); close(sock); return -1;
  }

  if (listen(sock,5) != 0 ){
    printf("listen() failed.\n"); close(sock); return -1;
  }
  return sock;
}

select函数相关参数

  • nfds 为maxfd,标识select遍历位图的最大个数
  • readfds 为读取fd 集合,本质就是位图,也是我们映像中的那个 fd set
  • writefds 为 写 fd 集合
  • exceptfds 为 异常 df 集合
  • timeout 超时时间
  • FD_CLR 为 从 fd集合中删除一个 fd,也就是把位图中的fd 置位为0
  • FD_ISSET 为 当断当前 fd 在 fd集合中是否有事件发生,就是判断当前fd,在fd集合(位图)上标识是不是1
  • FD_SET 为 向 fd集合中 添加一个需要监控的fd
  • FD_ZERO 为 清空fd集合,就是把位图全部置位

poll

poll函数使用实例代码

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <poll.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/fcntl.h>

// ulimit -n
#define MAXNFDS  1024

// 初始化服务端的监听端口。
int initserver(int port);

int main(int argc,char *argv[]){
  if (argc != 2){
    printf("usage: ./tcppoll port\n"); return -1;
  }

  // 初始化服务端用于监听的socket。
  int listensock = initserver(atoi(argv[1]));
  printf("listensock=%d\n",listensock);

  if (listensock < 0){
    printf("initserver() failed.\n"); return -1;
  }

  int maxfd;   // fds数组中需要监视的socket的大小。
  struct pollfd fds[MAXNFDS];  // fds存放需要监视的socket。

  for (int ii=0;ii<MAXNFDS;ii++) fds[ii].fd=-1; // 初始化数组，把全部的fd设置为-1。

  // 把listensock添加到数组中。
  fds[listensock].fd=listensock;
  fds[listensock].events=POLLIN;  // 有数据可读事件，包括新客户端的连接、客户端socket有数据可读和客户端socket断开三种情况。
  maxfd=listensock;

  while (1){
    int infds = poll(fds,maxfd+1,5000);
    // printf("poll infds=%d\n",infds);

    // 返回失败。
    if (infds < 0){
      printf("poll() failed.\n"); perror("poll():"); break;
    }

    // 超时。
    if (infds == 0){
      printf("poll() timeout.\n"); continue;
    }

    // 检查有事情发生的socket，包括监听和客户端连接的socket。
    // 这里是客户端的socket事件，每次都要遍历整个集合，因为可能有多个socket有事件。
    for (int eventfd=0; eventfd <= maxfd; eventfd++){
      if (fds[eventfd].fd<0) continue;

      if ((fds[eventfd].revents&POLLIN)==0) continue;

      fds[eventfd].revents=0;  // 先把revents清空。

      if (eventfd==listensock){
        // 如果发生事件的是listensock，表示有新的客户端连上来。
        struct sockaddr_in client;
        socklen_t len = sizeof(client);
        int clientsock = accept(listensock,(struct sockaddr*)&client,&len);
        if (clientsock < 0){
          printf("accept() failed.\n"); continue;
        }

        printf ("client(socket=%d) connected ok.\n",clientsock);

        if (clientsock>MAXNFDS){    
          printf("clientsock(%d)>MAXNFDS(%d)\n",clientsock,MAXNFDS); close(clientsock); continue;
        }

        fds[clientsock].fd=clientsock;
        fds[clientsock].events=POLLIN; 
        fds[clientsock].revents=0; 
        if (maxfd < clientsock) maxfd = clientsock;

        printf("maxfd=%d\n",maxfd);
        continue;
      }
      else {
        // 客户端有数据过来或客户端的socket连接被断开。
        char buffer[1024];
        memset(buffer,0,sizeof(buffer));

        // 读取客户端的数据。
        ssize_t isize=read(eventfd,buffer,sizeof(buffer));

        // 发生了错误或socket被对方关闭。
        if (isize <=0){
          printf("client(eventfd=%d) disconnected.\n",eventfd);

          close(eventfd);  // 关闭客户端的socket。

          fds[eventfd].fd=-1;

          // 重新计算maxfd的值，注意，只有当eventfd==maxfd时才需要计算。
          if (eventfd == maxfd){
            for (int ii=maxfd;ii>0;ii--){
              if ( fds[ii].fd != -1){
                maxfd = ii; break;
              }
            }

            printf("maxfd=%d\n",maxfd);
          }
          continue;
        }
        printf("recv(eventfd=%d,size=%d):%s\n",eventfd,isize,buffer);

        // 把收到的报文发回给客户端。
        write(eventfd,buffer,strlen(buffer));
      }
    }
  }

  return 0;
}

// 初始化服务端的监听端口。
int initserver(int port){
  int sock = socket(AF_INET,SOCK_STREAM,0);
  if (sock < 0){
    printf("socket() failed.\n"); return -1;
  }

  // Linux如下
  int opt = 1; unsigned int len = sizeof(opt);
  setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&opt,len);
  setsockopt(sock,SOL_SOCKET,SO_KEEPALIVE,&opt,len);

  struct sockaddr_in servaddr;
  servaddr.sin_family = AF_INET;
  servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
  servaddr.sin_port = htons(port);

  if (bind(sock,(struct sockaddr *)&servaddr,sizeof(servaddr)) < 0 ){
    printf("bind() failed.\n"); close(sock); return -1;
  }

  if (listen(sock,5) != 0 ){
    printf("listen() failed.\n"); close(sock); return -1;
  }
  return sock;
}

poll函数相关参数

  • fds 为 fd 集合,pollfd为结构体
  • nfds 为 最大监听的数据下标
  • timeout 为 超时时间

pollfd结构体

  • fd 为文件描述符,当fd 为 -1 时,表示是不需要关注这个fd,所以初始化的时候要这个值都为-1
  • events 为 需要监听的事件,分类如下图,我们只需要关注 POLLIN
  • revents 为 返回的事件,即现在发生的事件

epoll

epoll函数使用示例代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/epoll.h>
#include <sys/socket.h>
#include <sys/types.h>

#define MAXEVENTS 100

// 把socket设置为非阻塞的方式。
int setnonblocking(int sockfd);

// 初始化服务端的监听端口。
int initserver(int port);

int main(int argc,char *argv[]){
  if (argc != 2){
    printf("usage:./tcpepoll port\n"); return -1;
  }

  // 初始化服务端用于监听的socket。
  int listensock = initserver(atoi(argv[1]));
  printf("listensock=%d\n",listensock);

  if (listensock < 0){
    printf("initserver() failed.\n"); return -1;
  }

  int epollfd;

  char buffer[1024];
  memset(buffer,0,sizeof(buffer));

  // 创建一个描述符
  epollfd = epoll_create(1);

  // 添加监听描述符事件
  struct epoll_event ev;
  ev.data.fd = listensock;
  ev.events = EPOLLIN;
  epoll_ctl(epollfd,EPOLL_CTL_ADD,listensock,&ev);

  while (1){
    struct epoll_event events[MAXEVENTS]; // 存放有事件发生的结构数组。
    // 等待监视的socket有事件发生。
    int infds = epoll_wait(epollfd,events,MAXEVENTS,-1);
    // printf("epoll_wait infds=%d\n",infds);

    // 返回失败。
    if (infds < 0){
      printf("epoll_wait() failed.\n"); perror("epoll_wait()"); break;
    }

    // 超时。
    if (infds == 0)
    {
      printf("epoll_wait() timeout.\n"); continue;
    }

    // 遍历有事件发生的结构数组。
    for (int ii=0;ii<infds;ii++){
      if ((events[ii].data.fd == listensock) &&(events[ii].events & EPOLLIN)){
        // 如果发生事件的是listensock，表示有新的客户端连上来。
        struct sockaddr_in client;
        socklen_t len = sizeof(client);
        int clientsock = accept(listensock,(struct sockaddr*)&client,&len);
        if (clientsock < 0)
        {
          printf("accept() failed.\n"); continue;
        }

        // 把新的客户端添加到epoll中。
        memset(&ev,0,sizeof(struct epoll_event));
        ev.data.fd = clientsock;
        ev.events = EPOLLIN;
        epoll_ctl(epollfd,EPOLL_CTL_ADD,clientsock,&ev);
        printf ("client(socket=%d) connected ok.\n",clientsock);
        continue;
      }
      else if (events[ii].events & EPOLLIN){
        // 客户端有数据过来或客户端的socket连接被断开。
        char buffer[1024];
        memset(buffer,0,sizeof(buffer));
        // 读取客户端的数据。
        ssize_t isize=read(events[ii].data.fd,buffer,sizeof(buffer));
        // 发生了错误或socket被对方关闭。
        if (isize <=0){
          printf("client(eventfd=%d) disconnected.\n",events[ii].data.fd);

          // 把已断开的客户端从epoll中删除。
          memset(&ev,0,sizeof(struct epoll_event));
          ev.events = EPOLLIN;
          ev.data.fd = events[ii].data.fd;
          epoll_ctl(epollfd,EPOLL_CTL_DEL,events[ii].data.fd,&ev);
          close(events[ii].data.fd);
          continue;
        }

        printf("recv(eventfd=%d,size=%d):%s\n",events[ii].data.fd,isize,buffer);

        // 把收到的报文发回给客户端。
        write(events[ii].data.fd,buffer,strlen(buffer));
      }
    }
  }

  close(epollfd);

  return 0;
}

// 初始化服务端的监听端口。
int initserver(int port){
  int sock = socket(AF_INET,SOCK_STREAM,0);
  if (sock < 0){
    printf("socket() failed.\n"); return -1;
  }

  // Linux如下
  int opt = 1; unsigned int len = sizeof(opt);
  setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&opt,len);
  setsockopt(sock,SOL_SOCKET,SO_KEEPALIVE,&opt,len);

  struct sockaddr_in servaddr;
  servaddr.sin_family = AF_INET;
  servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
  servaddr.sin_port = htons(port);

  if (bind(sock,(struct sockaddr *)&servaddr,sizeof(servaddr)) < 0 ){
    printf("bind() failed.\n"); close(sock); return -1;
  }

  if (listen(sock,5) != 0 ){
    printf("listen() failed.\n"); close(sock); return -1;
  }

  return sock;
}

// 把socket设置为非阻塞的方式。
int setnonblocking(int sockfd){  
  if (fcntl(sockfd, F_SETFL, fcntl(sockfd, F_GETFD, 0)|O_NONBLOCK) == -1)  return -1;
  return 0;  
}

epoll_create

方法体

int epoll_create(int size)

参数

  1. size 表示你要创建的epoll大小,高版本的操作系统这个参数已经忽略了

描述

  1. epoll_create() 是一个系统函数,调用这个函数,将会在内核空间开辟一个epoll空间,返回一个描述符,标识这个空间

epoll_clt

方法体

参数

  • epdf 表示你要操作那个epoll
  • op 操作类型,修改,删除或者新增
  • fd 文件描述符(要把那个socket 放入epoll)
  • events 关注的事件集合

op

  • EPOLL_CTL_ADD 为 添加操作
  • EPOLL_CTL_MOD 为 修改操作
  • EPOLL_CTL_DEL 为 删除操作

epoll_event

  • events 为 关注的事件
  • data 为 fd

描述

  1. epoll_clt 是 epoll的事件注册函数,epoll与select不同,select是传递socket描述符集合让内核循环,epoll是先将用户感兴趣的数据注册到epoll空间内,此函数式非阻塞函数,作用仅仅是增删改epoll空间内维护的描述符集合信息

epoll_wait

方法体

int epoll_wait(int epfd,epoll_event[] events,int maxevents,int timeout)

参数

  • epollfd 为 你要访问的epoll描述符
  • events 为 当epoll返回时,这个里面会存着 socket 描述符,是个数组
  • maxevents 为 告诉 events 数组的长度,也是最大接收返回的个数
  • timeout 为 超时时间 如果是 0,表示非阻塞,1-表示一直阻塞,如果>0 是有阻塞的,阻塞时间为 timeout

描述

  1. 等待事件的发生,可以根据timeout的值设置是非阻塞
avatar
文章
阅读
粉丝