IO多路复用——select

目录

一、操作系统的五种IO模型

Linux下进行网络编程时会有同步/异步，阻塞和非阻塞四种调用方式

同步和异步的概念描述的是用户线程与内核的交互方式：

同步：同步是指用户线程发起IO请求后需要等待或者轮询内核IO操作完成后才能继续执行；
异步：异步是指用户线程发起IO请求后仍继续执行，当内核IO操作完成后通知用户线程，或是调用用户线程注册的回调函数。

阻塞和非阻塞的概念描述的是用户线程调用内核IO操作的方式：

阻塞：阻塞是指IO操作在没有接受完数据或者是没有得到结果前不会返回，需要彻底完成后才能返回到用户空间；
非阻塞：非阻塞是指IO操作被调用后立即返回给用户一个状态值，无需等到IO操作彻底完成后，此时会持续一个轮询状态直到得出结果。

1.同步阻塞IO

  传统的IO模型，也是最常见，最简单的IO模型，在Linux中默认情况下所有的socket都是阻塞模式。
  当用户进程调用read()系统调用时，会从用户进程空间转到内核空间处理，内核会等待数据（因为对于网络IO来说，很多时候数据一开始还未到达）此时进程会处于阻塞状态，直到数据到达后内核会将数据拷贝到用户内存中，然后内核返回结果，用户进程解除阻塞状态，重新开始运行。
用户线程发起IO操作请求，内核收到信息不返回直到获得数据后见数据拷贝到内存空间后返回，用户线程收到信息：

2.同步非阻塞IO

  用户线程在发起IO请求后可以立即返回，如果此次读操作未取到数据，用户线程需要不断地发起IO请求，直到数据到达后读取数据，线程继续执行。

3.IO多路复用

  多路复用IO是在高并发场景中使用最为广泛的一种IO模型。在并发环境下，多个线程需要向内核获取数据，而数据获取时间未知因此会发生阻塞，此时就会消耗操作系统的资源。IO多路复用是建立在内核提供的多路分离函数select基础之上的，使用select函数可以避免同步非阻塞IO模型中轮询的问题，使用一个线程监控多个线程（文件描述符），这样就可以只需要一个线程就可以完成数据状态的询问操作，只要有一个线程的相关数据就绪就可以分配对于的线程获取数据。
  在Linux下的socket网络编程中，该种模式下，用户首先可以将要进行IO操作的socket（文件描述符）添加到select中，然后阻塞等待select系统调用返回；当数据到达时，socket被激活，select函数返回，用户线程可进行read()系统调用。

4.信号驱动IO

  当用户线程发起一个IO请求操作时，会给对应的socket注册一个信号函数，调用sigaltion系统调用，然后用户线程会继续执行，当内核数据就绪时会发送一个信号给用户线程，提醒用户线程读取数据。

5.异步IO

  异步IO即经典的Proactor设计模式，也称为异步非阻塞IO。在异步IO模型中，当用户线程收到通知时，数据已经被内核读取完毕，（与信号驱动IO不同，收到通知时数据到达内核）并放在了用户线程指定缓冲区内，内核在IO完成后通知用户线程直接使用即可。

  同步阻塞IO、同步非阻塞IO、IO多路复用、信号驱动IO都是同步IO，用户线程是会阻塞的，内核等待数据直至数据准备好，将数据从内核拷贝到用户空间，内核返回结果，用户线程继续运行。异步IO不需要考虑整个IO操作是如何运行的，只需要发起请求，接收到内核返回成功信号时IO操作已经完成，直接使用数据。
  但相比与IO多路复用模型，信号驱动IO和异步IO并不十分受用，不少高性能并发服务持续使用IO多路复用+多线程任务处理的架构基本可以满足需求。

二、select函数

1、select函数说明：

  select()函数有着很好的跨平台性，几乎所以平台都支持，允许进程只是内核等待多个事件（文件描述符）中的任何一个发生，并只在有一个或多个事件发生或经历一段指定时间后才唤醒它，然后接下来判断是哪一个文件描述符发生了事件并进行相应处理。
  将各个客户端连接的文件描述符放入一个集合中，调用select函数监视文件描述符，会线性轮询扫描所有的fd（文件描述符）。

	   //包含的头文件：      
       /* According to POSIX.1-2001, POSIX.1-2008 */
       #include 
       /* According to earlier standards */
       #include 
       #include 
       #include 
       
       //函数原型：
       int select(int nfds, fd_set *readfds, fd_set *writefds,
                  fd_set *exceptfds, struct timeval *timeout);

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

	   //timeval的结构体
	   struct timeval
	   {
			long tv_sec; //seconds秒
			long tv_usec; //microseconds微秒
	    };	

参数说明： nfds指待测试的fd的总个数，它的值是待测试的最大文件描述符加1（因为文件描述符是从0开始的）。Linux内核从0开始到nfds-1扫描文件描述符，如果有数据出现事件(读、写、异常)将会返回，实际监测的描述符是nfds；
readfds、writefds和exceptfds指的是让内核测试读、写和异常条件的文件描述符的集合，readfds文件描述符有数到来可读，writefds文件描述符可写，exceptfd文件描述符异常。如果不需要测试的可以设置为NULL；
timeout指的是超时时间，如果设置为NULL则永不超时。

返回值：select函数的返回值是就绪描述符的数目，返回值小于0，出错；返回值等于0，超时；返回值大于0，有事件发生。

  在Linux内核有个参数__FD_SETSIZE定义了每个FD_SET的句柄个数，这也意味着select所用到的FD_SET是有限的，所以监听的IO最大连接数不能多于FD_ SIZE（32位操作系统1024，64位操作系统2048）

2、select流程图：

3、select实现socket服务器代码：

代码如下：

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

#define ARRAY_SIZE(x)   (sizeof(x)/sizeof(x[0]))//该宏求出数组中存在多少元素

static inline void msleep(unsigned long ms);
static inline void print_usage(char *progname);
int socket_server_init(char *listen_ip,int listen_port);

int main(int argc, char *argv[])
{
        int             listenfd,connfd;
        int             serv_port = 0;
        int             daemon_run = 0;
        char            *progname = NULL;
        int             opt;
        fd_set          rdset;
        int             rv;
        int             i,j;
        int             found;
        int             maxfd = 0;
        char            buf[1024];
        int             fds_array[64];

        struct option   long_option[] = {
                {"daemon",no_argument,NULL,'d'},
                {"port",required_argument,NULL,'p'},
                {"help",no_argument,NULL,'h'},
                {NULL,0,NULL,0}
        };

        progname = basename(argv[0]);
        
        while((opt = getopt_long(argc,argv,"dp:h",long_option,NULL)) != -1)
        {
                switch(opt)
                {
                        case 'd':
                                daemon_run = 1;
                                break;
                        case 'p':
                                serv_port=atoi(optarg);
                                break;
                        case 'h':
                                print_usage(progname);
                                return EXIT_SUCCESS;
                        default:
                                break;
                }
        }

        if(!serv_port)
        {
                print_usage(progname);
                return -1;
        }
	
        if((listenfd = socket_server_init(NULL,serv_port))<0)
        {
                printf("Error:%s server listen on port %d failure\n",argv[0],serv_port);
                return -2;
        }
        printf("%s server start to listen on port %d \n",argv[0],serv_port);
        
		//守护进程，在后台运行
        if(daemon_run)
        {
                daemon(0,0);
        }
		//将数组中的元素设为-1；
        for(i=0; i<ARRAY_SIZE(fds_array); i++)
        {
                fds_array[i]=-1;
        }
        fds_array[0] = listenfd;//将最开始的文件描述符加入到数组中
        
        for( ; ; )
        {
                FD_ZERO(&rdset);//将rdset集合清零
                for(i=0;i<ARRAY_SIZE(fds_array);i++)
                {
                        if(fds_array[i]<0)//小于0，文件描述符不存在
                        {
                                continue;
                        }
                        maxfd = fds_array[i]>maxfd ? fds_array[i] : maxfd;//三目运算符将文件描述符复制给maxfd
                        FD_SET(fds_array[i],&rdset);//将文件描述符加入到集合中
                }
				//调用select函数，此时将会在这里堵塞
                rv = select(maxfd+1,&rdset,NULL,NULL,NULL);
                if(rv < 0)//rv小于0，表示出错
                {
                        printf("select failure:%s\n",strerror(errno));
                        break;
                }

                else if(rv == 0)//rv等于0，表示超时
                {
                        printf("select get timeout\n");
                        continue;
                }
                
				//此时rv大于0，表示发生了事件，此时要判断是监听的文件描述符还是新的客户端进行连接
                if(FD_ISSET(listenfd,&rdset))
                {
               	//此时表示有新的客户端进行连接
                        if((connfd=accept(listenfd,(struct sockaddr *)NULL,NULL))<0)
                        {
                                printf("accept new client failure:%s\n",strerror(errno));
                                continue;
                        }
                        found = 0;
                        //将新的文件描述符加入到集合中
                        for(i=0;i<ARRAY_SIZE(fds_array);i++)
                        {
                                if(fds_array[i] < 0)
                                {
                                        printf("accept new clinet[%d] and add it into array\n",connfd );
                                        fds_array[i]= connfd;
                                        found = 1;
                                        break;
                                }
                        }
                        if(!found)
                        {
                        //监听的客户端已经达到最大值，不能进行处理
                                printf("accept new client[%d] but full,so refuse it\n",connfd);
                        }
                }

				//此时表示的是监听的文件描述符发生事件
                else
                {
                        //遍历数组找出发生事件的文件描述符
                        for(i=0;i<ARRAY_SIZE(fds_array);i++)
                        {
                        		//不是则继续遍历
                                if(fds_array[i]<0 || FD_ISSET(fds_array[i],&rdset))
                                {
                                        continue;
                                }
                                
								//找到该文件描述符后开始读取操作
                                if((read(fds_array[i],buf,sizeof(buf)))<= 0)
                                {
                                //发生异常或中断，此时关闭文件描述符，腾出位置给新的文件描述符
                                        printf("Read sockfd[%d] failure or get disconnect \n",fds_array[i]);
                                        close(fds_array[i]);
                                        fds_array[i] = -1;
                                }
                                else//此时表示读取成功，进行相应的操作
                                {
                                        printf("socket[%d] read get %d bytes data \n",fds_array[i],rv);
                                        for(j=0;j<rv;j++)
                                        {
                                                buf[j]=toupper(buf[j]);
                                        }

                                        if(write(fds_array[i],buf,rv) < 0)
                                        {
                                                printf("sokcet[%d] write failuer:%s \n",fds_array[i],strerror(errno));
                                                close(fds_array[i]);
                                                fds_array[i] = -1;
                                        }
                                }

                        }
                }
        }
Cleanup:
        close(listenfd);
        return 0;

}

static inline void msleep(unsigned long  ms)//设置时间
{
        struct timeval  tv;
        tv.tv_sec = ms/1000;
        tv.tv_usec = (ms%1000)*1000;

        select(0,NULL,NULL,NULL,&tv);
}

static inline void print_usage(char *progname)//提示信息显示
{
        printf("Usage:%s [OPTION]...\n",progname);
        printf("%s is a socket server program,which used to verify client and echo back string from it \n",progname);
        printf("-d(--daemon):background running\n");
        printf("-p(--port):sepcify server listen port\n");
        printf("-h(--help):print this help information\n");
}

//将服务器端的socket、bind和listen三个步骤抽象为一个函数
int socket_server_init(char *listen_ip,int listen_port)
{
        struct sockaddr_in      servaddr;
        int                     rv = 0;
        int                     on = 1;
        int                     listenfd;
		//创建socket
        if((listenfd = socket(AF_INET,SOCK_STREAM,0))< 0)
        {
                printf("Use socet() to create a TCP socket failure:%s\n",strerror(errno));
                return -1;
        }
		//释放端口
        setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on));

        memset(&servaddr,0,sizeof(servaddr));
        servaddr.sin_family = AF_INET;//设置IP
        servaddr.sin_port = htons(listen_port);//设置端口

        if(!listen_ip)
        {
                servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
        }
        else
        {
                if(inet_pton(AF_INET,listen_ip,&servaddr.sin_addr) <= 0)
                {
                        printf("inet_pton() ste listen IP address failure.\n");
                        rv = -2;
                        goto Cleanup;
                }
        }
		//调用bind()
        if(bind(listenfd,(struct sockaddr *)&servaddr,sizeof(servaddr))<0)
        {
                printf("Use bind() to bind the TCP socket failure:%s\n",strerror(errno));
                rv = -3;
                goto Cleanup;
        }
		//调用liste()
        if(listen(listenfd,13)<0)
        {
                printf("Use listen() failure:%s \n",strerror(errno));
                rv = -4;
                goto Cleanup;
        }

Cleanup:
        if(rv < 0)
                close(listenfd);
        else
                rv = listenfd;
        return rv;
}