select

2020-09-12

使用select函数实现I/O复用

Select函数允许进程指示内核等待多个事件中的一个发生，并只在或多个事件发生或经历一段指定时间后才唤醒。函数原型：

1
2
3

#include<sys/select.h>
#include <sys/time.h>
int select(int maxfdp1,fd_set *readset,fd_set *write_set,fd_set *exceptset,const struct timeval *timeout)

返回：若有就绪描述符就绪就返回就绪数目，若超时返回0，错误发生返回-1

maxfdp1 : 指定待测试的描述符的个数，值是待测最大描述符加1，从0,1,2…到maxfdp1-1都会被测试

readset : 让内核测试读的描述符集合

writeset : 让内核测试写的描述符集合

exceptset : 让内核测试异常条件的描述符集合

对于fd_set的初始化可设置需要使用以下4个宏

void FD_ZERO(fd_set *fdset);         //清空文件描述符集合fdset
void FD_SET(int fd,fd_set *fdset);   //将指定的文件描述符fd加入文件描述符集合fdset
int  FD_ISSET(int fd,fd_set *fdset); //将判断文件描述符fd是否在文件描述符集合fdset中
void FD_CLR(int fd,fd_set *fdset);   //将指定的文件描述符fd从文件描述符集合fdset中清除

Timeout : 是

struct timeval
{
  long tv_sec; //秒
  long tv_usec; //毫秒
};

的类型，表示告知内核等待所指定的描述符中任何一个就绪可花多长时间。这个参数有以下三种情况：

1）永远等待下去：直到有一个描述符准备好I/O才返回，这时需要将此参数设置为NULL

2）等待一段时间：在有一个描述符准备好I/O时返回，但不能超过timeout中设置的秒数和毫秒数

3）根本不等待：检查描述符后立即返回，这就是轮询。需要将传入的timeout中的秒数和毫秒数都设置为0

Tcp服务端例子：

#include <arpa/inet.h>
#include <netdb.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/errno.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <time.h>
#include <unistd.h>
#define PORT 40501
#define MAXLINE 4096
// 读取n个字符
size_t readn(int fd, void *ptr, size_t maxcn) {
  size_t noreadcn, readcn;
  char *buf = (char *)ptr;
  noreadcn = maxcn;
  while (noreadcn > 0) {
    if ((readcn = read(fd, buf, noreadcn)) < 0) {
      if (errno == EINTR) {
        printf("中断错误");
        readcn = 0;
      } else {
        return -1;
      }
    } else if (readcn == 0)
      break;             // EOF
    noreadcn -= readcn;  //读取的数据少于maxcn继续读
    buf += readcn;
    if (*buf == 0) break;
  }
  return (maxcn - noreadcn);
}
size_t writen(int fd, void *ptr, size_t maxcn) {
  size_t nowritecn, writecn;
  char *buf = (char *)ptr;
  nowritecn = maxcn;
  while (nowritecn > 0) {
    if ((writecn = write(fd, buf, nowritecn)) < 0) {
      if (errno == EINTR) {
        printf("中断错误");
        writecn = 0;
      } else {
        return -1;
      }
    } else if (writecn == 0)
      break;               // EOF
    nowritecn -= writecn;  //写入的数据少于maxcn继续写
    buf += writecn;
    if (*buf == 0) break;
  }
  return (maxcn - nowritecn);
}
int main(int argc, char *argv[]) {
  int i, maxi, maxfd, listenfd, sockfd, connfd;
  int nready, client[FD_SETSIZE];
  ssize_t n;
  fd_set rset, allset;
  char buf[MAXLINE];
  socklen_t clilen;
  struct sockaddr_in cliAddr, serverAddr;
  clilen = sizeof(cliAddr);
  bzero(&serverAddr, sizeof(serverAddr));
  bzero(&cliAddr, clilen);
  listenfd = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
  serverAddr.sin_family = AF_INET;
  serverAddr.sin_port = htons(PORT);
  serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);

  if (bind(listenfd, (struct sockaddr *)&serverAddr, sizeof(serverAddr)) < 0) {
    perror("bind error");
  }
  listen(listenfd, 1024);

  //设置 fd_set 
  maxfd = listenfd;
  maxi = -1;
  for (i = 0; i < FD_SETSIZE; i++) {
    client[i] = -1;
  }
  FD_ZERO(&allset);           //清空allset
  FD_SET(listenfd, &allset);  // 讲listenfd 添加到allsetj集合中
  while (1) {
    rset = allset;  //测试读集合
    nready = select(maxfd + 1, &rset, NULL, NULL, NULL);

    if (FD_ISSET(listenfd, &rset)) {  //有新的连接请求
      connfd = accept(listenfd, (struct sockaddr *)&cliAddr, &clilen);

      for (i = 0; i < FD_SETSIZE; i++) { //将新的连接描述符保存
        if (client[i] < 0) {
          client[i] = connfd;
          break;
        }
      }
      if (i == FD_SETSIZE) {         //达到最大
        printf("too many clients");
        exit(-1);
      }
      FD_SET(connfd, &allset);
      if (connfd > maxfd) maxfd = connfd;
      if (i > maxi) maxi = i;   //最大的连接个数
      --nready;
      if (nready <= 0) {   //没有可读的描述符
        continue;
      }
    }
    for (i = 0; i <= maxi; i++) {    //检查所有的客户端传来的数据
      if ((sockfd = client[i]) < 0) {
        continue;
      }
      if (FD_ISSET(sockfd, &allset)) {
        if ((n = readn(sockfd, buf, MAXLINE)) == 0) {
          close(sockfd);
          FD_CLR(sockfd, &allset);
          client[i] = -1;
        } else {
          writen(sockfd, buf, n);
        }
        if (--nready <= 0) break; //没有可读的文件描述符
      }
    }
  }
  return 0;
}

客户端：

#include <arpa/inet.h>
#include <netdb.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/errno.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <time.h>
#include <unistd.h>
#define PORT 40501
#define MAXLINE 4096
// 读取n个字符
size_t readn(int fd, void *ptr, size_t maxcn) {
  size_t noreadcn, readcn;
  char *buf = (char *)ptr;
  noreadcn = maxcn;
  while (noreadcn > 0) {
    if ((readcn = read(fd, buf, noreadcn)) < 0) {
      if (errno == EINTR) {
        printf("中断错误");
        readcn = 0;
      } else {
        return -1;
      }
    } else if (readcn == 0)
      break;             // EOF
    noreadcn -= readcn;  //读取的数据少于maxcn继续读
    buf += readcn;
    if (*buf == 0) break;
  }
  return (maxcn - noreadcn);
}
size_t writen(int fd, void *ptr, size_t maxcn) {
  size_t nowritecn, writecn;
  char *buf = (char *)ptr;
  nowritecn = maxcn;
  while (nowritecn > 0) {
    if ((writecn = write(fd, buf, nowritecn)) < 0) {
      if (errno == EINTR) {
        printf("中断错误");
        writecn = 0;
      } else {
        return -1;
      }
    } else if (writecn == 0)
      break;               // EOF
    nowritecn -= writecn;  //写入的数据少于maxcn继续写
    buf += writecn;
    if (*buf == 0) break;
  }
  return (maxcn - nowritecn);
}
int main(int argc, char *argv[]) {
  int sockfd;
  struct sockaddr_in serverAddr;
  int addresslen = sizeof(serverAddr);
  int pid;
  char mybuf[MAXLINE];
  char *buf = "client\n";
  int rc;
  sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
  bzero(&serverAddr, addresslen);
  serverAddr.sin_family = AF_INET;
  serverAddr.sin_port = htons(PORT);
  inet_pton(AF_INET, "127.0.0.1", &serverAddr.sin_addr);

  rc = connect(sockfd, (struct sockaddr *)&serverAddr, addresslen);
  if (rc < 0) {
    perror("connect error");
    exit(-1);
  }
  //写入数据
  writen(sockfd, (void *)buf, strlen(buf) + 1);
  printf("client send: %s\n", buf);

  //读取数据
  bzero(mybuf, MAXLINE);
  readn(sockfd, (void *)mybuf, MAXLINE);
  printf("server read: %s\n", mybuf);
  close(sockfd);
  return 0;
}