C++网络编程I/O 多路复用之select

• 前言
• 一、相关函数
• • 1.1 结构体fd_set
  • 1.2 结构体timeval
  • 1.1 select
• 二、思路分析
• 三、代码
• 四、优化
• 总结

  I/O多路复用就是通过一种机制，一个进程可以监听多个文件描述符，这对提高程序的性能至关重要，一旦某个文件描述符就绪（一般是读就绪或者写就绪），能够通知程序进行相应的读写操作。

  与多进程或多线程的方式相比，使用 IO 多路复用技术无需创建多个进程或线程，也不必维护这些进程/线程，从而大大减小了系统的开销。select，poll，epoll都是IO多路复用的机制。但select，poll，epoll本质上都是同步I/O，因为他们都需要在读写事件就绪后自己负责进行读写，也就是说这个读写过程是阻塞的，而异步I/O则无需自己负责进行读写，异步I/O的实现会负责把数据从内核拷贝到用户空间。
一般情况，网络程序会在下面的几种情形下使用到I/O复用技术：

1. 客户端程序要同时处理用户输入和网络连接，必须使用I/O复用。如 聊天室程序。
2. 客户端程序要同时处理多个socket。如非阻塞connect技术。
3. 服务器要同时处理 TCP 请求和 UDP 请求。如 回射服务器。
4. 服务器要同时监听多个端口，或者处理多种服务。如 xinetd服务器。
5. TCP服务器要同时处理监听socket和连接socket。这是I/O复用使用最多的场合。

首先介绍select。其用途：在一段指定时间内，监听用户感兴趣的文件描述符上的可读、可写和异常事件。

可以直接使用 fd_set 创建一个 fd 集合变量，用于select函数的三个参数，readfds, writefds, exceptfds 分别表示读，写，异常事件的集合。fd_set能容纳文件描述符的数量由FD_SETSIZE（即1024）指定，所以这就限制了select能同时处理的文件描述符的总量。

fd_set r_set,all_set; //使用 fd_set 创建fd集合变量

void FD_ZERO(fd_set *set); //清空:清空一个文件描述符集合，即将集合set的位图所有二进制位置零
void FD_SET(int fd, fd_set *set);//添加:将待监听的文件描述符fd，添加到监听集合set中,即将位图的指定位置为1。
void FD_CLR(int fd, fd_set *set);//移除:将文件描述符fd从监听集合set中移除,即将位图的指定位置为0。
int FD_ISSET(int fd, fd_set *set);//判断指定fd是否在监听集合set中,在返回1，不在返回0。

timeval结构用于指定超时时间的秒数和微秒数。定义如下：

struct timeval
{
	long tv_sec; //秒数
	long tv_usec; // 微秒数
};

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

参数：

1. nfds：监听的所有文件描述符中，最大文件描述符+1
2. readfds: 监听可读事件的文件描述符集合，传入传出参数，如不关心，可传NULL。
3. writefds：监听可写事件的文件描述符集合，传入传出参数，如不关心，可传NULL。
4. exceptfds：监听异常事件的文件描述符集合，传入传出参数，如不关心，可传NULL。
5. timeout：设置 select 监听的超时时长，告知内核等待所指定描述字中的任何一个就绪可花多少时间。

timeout=0:表示检查后立刻返回，非阻塞监听，轮询
timeout=NULL:表示一直等待，阻塞监听
timeout>0:设置监听超时时长，表示等待至少一个事件发生时才返回，但是超时时间到达时即使没有事件也会返回。

返回值：
传出参数返回：
select调用返回时，除了那些已经就绪的描述符外，select将清除readfds、writefds和exceptfds中的所有没有就绪的描述符。这也是为什么说他是传入传出参数，里面的值已经改变。所以需要一个all_set备份，在调用select前重复对r_set赋值。
如果select调用中设置了等待时间 timeout，那么每次调用时都需要重新对这个时间赋值么？就像对fd_set处理一样。 传的是一个指针进去，select里面可能会改变这个地址里保存的内容，返回的是阻塞的剩余时间。所以对于select函数中的最后一个参数，需要在循环中设置，每次循环要重新赋值。
select 函数返回：

>0: readfds, writefds, exceptfds监听集合中， 满足对应事件的总数。
0： 在超时时间内没有任何文件描述符就绪，表示没有满足监听条件的文件描述符
-1： errno，如果errno为EINTR，则是select被某个信号中断，否则是出错。

代码思路：

int lfd=socket();  //创建监听套接字
int maxfd=lfd;  //记录最大文件描述符
setsockopt();  //设置端口复用
bind(); //绑定监听套接字lfd与Strcut scokaddr_in srv_addr(服务器IP和端口)
listen();  //把lfd转换成一个被动套接字，进入被动监听状态，用来被动接受来自其他主动套接字的连接请求，并设置监听上限。
fd_set r_set,all_set;  //创建读监听集合，all_set用于备份
FD_ZERO(&allset); 将r_set监听集合清空
FD_SET(lfd, &allset); 将 lfd 添加至r_set读集合中。
while(1){
	r_set=all_set; //重复对r_set赋值
	ret= select(maxfd+1,&r_set,NULL,NULL,NULL);
	if(ret < 0){} //出错处理
	if(ret > 0){ //有监听的描述符满足对应事件
		if(FD_ISSET(lfd, &rset)){  // 1：lfd在，0：lfd不在。
			cfd = accept(); // 建立连接，返回用于通信的文件描述符
			maxfd = cfd; //更新最大文件描述符
			FD_SET(cfd, &allset); 将cfd添加到监听通信描述符集合中。
		}
		for(i = lfd+1;i <= 最大文件描述符;i++){ //这里判断所有的cfd，无需对lfd再判断，因为lfd最开始创建，最小，所有可以加1。
		FD_ISSET(i, &rset); //有 read、write 事件
		read();
		//如果错误就exit，如果客户端关闭就FD_CLR(i,&all_set);，否则数据处理
		write();
		}
	}
}

//select_server.c
// Created  on 2022/5/24.
//
#include 
#include 
#include
#include 
#include 
#include 
#include 
#include 
#include 
#include "wrap.h"
#define IP "127.44.44.44"
#define PORT 6266

int main(int argc,char *argv[]){
    int lfd,cfd;
    int maxfd,ret,i;
    char buf[BUFSIZ];
    struct sockaddr_in srv_addr,clt_addr;
    socklen_t clt_addr_len;
    //memset(&saddr,0,sizeof(saddr));
    bzero(&srv_addr,sizeof(srv_addr));
    srv_addr.sin_family=AF_INET;
    srv_addr.sin_port= htons(PORT);
    srv_addr.sin_addr.s_addr= htonl(INADDR_ANY);
    lfd= Socket(AF_INET,SOCK_STREAM,0);
    int opt=1;
    setsockopt(lfd,SOL_SOCKET,SO_REUSEADDR,&opt, sizeof(opt));
    Bind(lfd,(struct sockaddr *)&srv_addr, sizeof(srv_addr));
    Listen(lfd,128);
    fd_set r_set,all_set;
    FD_ZERO(&all_set);
    FD_SET(lfd,&all_set);
    maxfd=lfd;

    while(1){
        r_set=all_set;
        ret= select(maxfd+1,&r_set,NULL,NULL,NULL);
        if(ret<0){
            sys_err("select");
        }
        if(FD_ISSET(lfd,&r_set)){
            clt_addr_len = sizeof(clt_addr);
            cfd= Accept(lfd,(struct sockaddr*)&clt_addr,&clt_addr_len);
            FD_SET(cfd,&all_set);
            if(maxfd
                maxfd=cfd;
            }
            if(ret==1){
                continue;
            }
        }
        for(i=lfd+1;i<=maxfd;i++){
            if(FD_ISSET(i,&r_set)){
                ret=read(i,buf, sizeof(buf));
                if(ret==0){
                    Close(i);
                    FD_CLR(i,&all_set);
                } else if(ret<0){
                    sys_err("read");
                } else{
                    //write(STDOUT_FILENO,buf,ret);
                    for(int j=0;j
                        buf[j]= toupper(buf[j]);
                    }
                    write(STDOUT_FILENO,buf,ret);
                    write(i,buf,ret);
                }

            }

        }
    }
    Close(lfd);
    return 0;
}

select 代码里有个可以优化的地方，用数组存下文件描述符，这样就不需要每次扫描一大堆无关文件描述符了。

之前的代码，如果最大 fd 是 1023，每次确定有事件发生的 fd 时，就要扫描 3-1023 的所有文件描述符，这看起来很蠢。于是定义一个数组，把要监听的文件描述符存下来，每次扫描这个数组就行了。看起来科学得多。
加个 client 数组，存要监听的描述符。

//select_witharray_server.c
// Created by 11406 on 2022/5/24.
//select 代码里有个可以优化的地方，用数组存下文件描述符，这样就不需要每次扫描一大堆无关文件描述符了

#include 
#include 
#include
#include 
#include 
#include 
#include 
#include 
#include 
#include "wrap.h"
#define IP "127.44.44.44"
#define PORT 6266

int main(int argc,char *argv[]){
    int lfd,cfd;
    int maxfd,ret,i,client[FD_SETSIZE]; 
    int maxi,nready ;
    char buf[BUFSIZ],clie_ip[INET_ADDRSTRLEN];  

    struct sockaddr_in srv_addr,clt_addr;
    socklen_t clt_addr_len;
    //memset(&saddr,0,sizeof(saddr));
    bzero(&srv_addr,sizeof(srv_addr));
    srv_addr.sin_family=AF_INET;
    srv_addr.sin_port= htons(PORT);
    srv_addr.sin_addr.s_addr= htonl(INADDR_ANY);
    lfd= Socket(AF_INET,SOCK_STREAM,0);
    int opt=1;
    setsockopt(lfd,SOL_SOCKET,SO_REUSEADDR,&opt, sizeof(opt));
    Bind(lfd,(struct sockaddr *)&srv_addr, sizeof(srv_addr));
    Listen(lfd,128);
    fd_set r_set,all_set;
    FD_ZERO(&all_set);
    FD_SET(lfd,&all_set);
    maxfd=lfd;
    maxi=-1;
    for(i=0;i 
        client[i]=-1;
    }

    while(1){
        r_set=all_set;
        nready= select(maxfd+1,&r_set,NULL,NULL,NULL);
        if(nready<0){
            sys_err("select");
        }
        if(FD_ISSET(lfd,&r_set)){
            clt_addr_len = sizeof(clt_addr);
            cfd= Accept(lfd,(struct sockaddr*)&clt_addr,&clt_addr_len);
            printf("received from %s at PORT %dn",
                   inet_ntop(AF_INET, &(clt_addr.sin_addr.s_addr), clie_ip, sizeof(clie_ip)),
                   ntohs(clt_addr.sin_port));
            FD_SET(cfd,&all_set);

            for (i = 0; i < FD_SETSIZE; i++){
                if (client[i] < 0) { 
                    client[i] = cfd; 
                    break;
                }
            }
            if (i == FD_SETSIZE) { 
                fputs("too many clientsn", stderr);
                exit(1);
            }
            if(maxfd
                maxfd=cfd;
            }
            if (i > maxi)
                maxi = i; 
            if(--nready==0){  //说明只有lfd监听到连接事件，下面读数据就不用运行了
                continue;
            }
        }
        for(i=0;i<=maxi;i++){
            if (client[i] < 0)
                continue;
            cfd = client[i];
            if(FD_ISSET(cfd,&r_set)){
                ret=read(cfd,buf, sizeof(buf));
                if(ret==0){
                    Close(cfd);
                    FD_CLR(cfd,&all_set);
                    client[i]=-1;
                } else if(ret<0){
                    sys_err("read");
                } else{
                    //write(STDOUT_FILENO,buf,ret);
                    for(int j=0;j
                        buf[j]= toupper(buf[j]);
                    }
                    write(STDOUT_FILENO,buf,ret);
                    write(cfd,buf,ret);
                }
                if(--nready==0){  //说明没有事件了，不用循环了
                    break;
                }
            }
        }
    }
    Close(lfd);
    return 0;
}

select目前几乎在所有的平台上支持，其良好跨平台支持也是它的一个优点。select的一 个缺点在于单个进程能够监视的文件描述符的数量存在最大限制，在Linux上一般为1024，可以通过修改宏定义甚至重新编译内核的方式提升这一限制，但 是这样也会造成效率的降低。检测满足条件的 fd，自己添加业务逻辑提高小。 提高了编码难度。