IO多路复用——select

IO多路复用——select

  • 目录
    • 一、操作系统的五种IO模型
      • 1.同步阻塞IO
      • 2.同步非阻塞IO
      • 3.IO多路复用
      • 4.信号驱动IO
      • 5.异步IO
    • 二、select函数
      • 1、select函数说明:
      • 2、select流程图:
      • 3、select实现socket服务器代码:

目录

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

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

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

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

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

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

1.同步阻塞IO

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

2.同步非阻塞IO

  用户线程在发起IO请求后可以立即返回,如果此次读操作未取到数据,用户线程需要不断地发起IO请求,直到数据到达后读取数据,线程继续执行。
IO多路复用——select_第2张图片

3.IO多路复用

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

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流程图:

IO多路复用——select_第4张图片

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;
}

你可能感兴趣的:(网络Socket,linux,网络,c语言)