IO多路复用之select总结

1、基本概念

　　IO多路复用是指内核一旦发现进程指定的一个或者多个IO条件准备读取，它就通知该进程。IO多路复用适用如下场合：

　　（1）当客户处理多个描述字时（一般是交互式输入和网络套接口），必须使用I/O复用。

　　（2）当一个客户同时处理多个套接口时，而这种情况是可能的，但很少出现。

　　（3）如果一个TCP服务器既要处理监听套接口，又要处理已连接套接口，一般也要用到I/O复用。

　　（4）如果一个服务器即要处理TCP，又要处理UDP，一般要使用I/O复用。

　　（5）如果一个服务器要处理多个服务或多个协议，一般要使用I/O复用。

　　 与多进程和多线程技术相比，I/O多路复用技术的最大优势是系统开销小，系统不必创建进程/线程，也不必维护这些进程/线程，从而大大减小了系统的开销。

2、select函数

        允许进程提示内核等待多个描述符的事件中的任何一个发生，并仅有一个或多个事件发生或经历一段时间后唤醒它。函数原型如下：

   #include <sys/select.h>
   #include <sys/time.h>
   int select(int maxfdp1,fd_set *readset,fd_set *writeset,fd_set *exceptset,const struct timeval *timeout)
   返回值：就绪描述符的数目，超时返回0，出错返回-1

       函数参数介绍如下：    

      （1）第一个参数maxfdp1指定待测试的描述字个数，它的值是待测试的最大描述字加1（因此把该参数命名为maxfdp1），描述字0、1、2...maxfdp1-1均将被测试。因为文件描述符是从0开始的。

      （2）中间的三个参数readset、writeset和exceptset指定我们要让内核测试读、写和异常条件的描述字。如果对某一个的条件不感兴趣，就可以把它设为空指针。struct fd_set可以理解为一个集合，这个集合中存放的是文件描述符，可通过以下四个宏进行设置：

          void FD_ZERO(fd_set *fdset);           //清空集合

          void FD_SET(int fd, fd_set *fdset);   //将一个给定的文件描述符加入集合之中

          void FD_CLR(int fd, fd_set *fdset);   //将一个给定的文件描述符从集合中删除

          int FD_ISSET(int fd, fd_set *fdset);   // 检查集合中指定的文件描述符是否可以读写 

     （3）timeout告知内核等待所指定描述字中的任何一个就绪可花多少时间。其timeval结构用于指定这段时间的秒数和微秒数。

       struct timeval

      {

                   long tv_sec;   //seconds

                   long tv_usec;  //microseconds

      };

        这个参数有三种可能：

              （1）永远等待下去：仅在有一个描述字准备好I/O时才返回。为此，把该参数设置为空指针NULL。

             （2）等待一段固定时间：在有一个描述字准备好I/O时返回，但是不超过由该参数所指向的timeval结构中指定的秒数和微秒数。

             （3）根本不等待：检查描述字后立即返回，这称为轮询。为此，该参数必须指向一个timeval结构，而且其中的定时器值必须为0。

  模型：

                

demo:

        程序的功能是：客户端向服务器发送信息，服务器接收并原样发送给客户端，客户端显示出接收到的信息。

服务器程序如下：

#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<sys/select.h>
#include<string.h>
#include<netinet/in.h>
#include<unistd.h>
#include<sys/shm.h>
#include<stdlib.h>

#define MAX_FD_SIZE 1024
#define PORT              6666
typedef struct ServerContext
{
    int CliCnt;    //当前fd的个数
    int CliFds[MAX_FD_SIZE];
    int MaxFD;
    int iServerFd;
    struct sockaddr_in SockAdd;
    fd_set AllFdSet;                    //所有fd的头
    struct timeval vl;

}T_ServerContext;

typedef T_ServerContext * PT_ServerContext;    //定义了一个类型

 //定义了一个结构体对象
static PT_ServerContext      g_ptSerContext;            
int main()
{

   int iServerFd;
   unsigned int i;
   //申请一个对象
   g_ptSerContext=(PT_ServerContext)malloc(sizeof(T_ServerContext));
   if(g_ptSerContext==NULL)
   	{
       perror("malloc server object error\n");
	  return 0;
   }
   //初始化对象
   memset(g_ptSerContext,0,sizeof(T_ServerContext));

   //设置对象
   for(i=0;i<MAX_FD_SIZE;i++)
   {
         g_ptSerContext->CliFds[i]=-1;		 
   }
   //创建监听socket
    g_ptSerContext->iServerFd=socket(AF_INET,SOCK_STREAM,0);

   if(-1==g_ptSerContext->iServerFd)
   {
   	perror("Create server socket error\n");
	return 0;
   }
   //初始化结构体
   bzero(&(g_ptSerContext->SockAdd),sizeof(g_ptSerContext->SockAdd));
   //绑定
   // 在Linux和Windows网络编程时需要用到htons和htonl函数，
   // 用来将主机字节顺序转换为网络字节顺序。
   g_ptSerContext->SockAdd.sin_family =AF_INET;
   g_ptSerContext->SockAdd.sin_port   =htons(PORT);
   g_ptSerContext->SockAdd.sin_addr.s_addr=htonl(INADDR_ANY);
   
   //调高端口的重用性
   int on;
        if(setsockopt(g_ptSerContext->iServerFd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(int))<<0)
   {
	     perror("setsockopt error\n");
	     return 0;
   }
   if(bind(g_ptSerContext->iServerFd,(struct sockaddr *)&g_ptSerContext->SockAdd,\
   	sizeof(g_ptSerContext->SockAdd))==-1)
   {
      perror("bind error\n");
	  return 0;
   }
   //设置监听
   if( listen(g_ptSerContext->iServerFd,MAX_FD_SIZE))
   {
       perror("listen error\n");
	   return 0;
   }
   //定义箱子的起始位置
   fd_set *ReadFdSet=&g_ptSerContext->AllFdSet;
   while(1)
    {
	     int iRet;
	     //初始化箱子
	     FD_ZERO(ReadFdSet);
	     //把监听句柄放入箱子
		 FD_SET(g_ptSerContext->iServerFd,ReadFdSet);
	     g_ptSerContext->MaxFD=g_ptSerContext->iServerFd;
	     for(i=0;i<MAX_FD_SIZE;i++)
	     {
	         int iTmpFd=g_ptSerContext->CliFds[i];
	         //将fd放入箱子里
	         FD_SET(iTmpFd,ReadFdSet);
		     //找寻最大的fd
		     g_ptSerContext->MaxFD=(iTmpFd>g_ptSerContext->MaxFD ? iTmpFd:g_ptSerContext->MaxFD);
		   
             }
	    //设置超时时间
            g_ptSerContext->vl.tv_sec =20;
	    g_ptSerContext->vl.tv_usec=0;
	    //select进行轮询
	iRet=select(g_ptSerContext->MaxFD+1,ReadFdSet,NULL,NULL,&g_ptSerContext->vl);
           //是否错误返回
         if(iRet==-1)
         {
            perror("select error\n");
	    return 0;
         }
	 //是否超时
	 if(iRet==0)
	 {
               printf("select time out\n");
               continue;  
	 }
             //是否有新的fd 接入
        if(FD_ISSET(g_ptSerContext->iServerFd,ReadFdSet))
        {
                //为监听句柄
           struct sockaddr_in Clinew;
	   socklen_t len=sizeof(Clinew);
	   int iConFd=-1;
	   while(iConFd==-1)
	  {
             iConFd=accept(g_ptSerContext->iServerFd,(struct sockaddr *)&Clinew,&len);
	     if(iConFd==-1)
	     {
		perror("iConFd error\n");
	     }
          }
          //将检测到的新链接客户端,放入服务端的链接句柄数组中
	  for(i=0;i<MAX_FD_SIZE;i++)
	  {
               //找到一个空位,存放新的fd
               if(g_ptSerContext->CliFds[i]<0)
                {
                    g_ptSerContext->CliFds[i]=iConFd;
		    g_ptSerContext->CliCnt++;        //监听个数
		      break;
	        }
                           
	 }
        }
	char aBuf[1024];
	//有链接SK进行数据通信
	for(i=0;i<g_ptSerContext->CliCnt;i++)
	{
        int iTmpFd=g_ptSerContext->CliFds[i];
	   if(iTmpFd<0)
	   {
              continue;
	   }
           //判断当前fd有数据可读
           if(FD_ISSET(iTmpFd,ReadFdSet))
               {
				  memset(aBuf,0,1024);
                  int iReadCnt=read(iTmpFd,aBuf,1024);
					  
	          if(iReadCnt<=0)
	          {
                   //read 发生错误
                   FD_CLR(iTmpFd,&g_ptSerContext->AllFdSet);
                   close(iTmpFd);
                   g_ptSerContext->CliFds[i]=-1;
		     continue;
		  }
		     printf("%s\n",aBuf);
	       }
	       char buf[1024]={0};
               //sprintf(buf,"hellp world %d",i);
	       scanf("%s",buf);
	       write(iTmpFd,buf,strlen(buf));      
		}
			
	}
     return 0;
}

客户端如下：

#include <stdio.h>  
#include <unistd.h>  
#include <stdlib.h>  
#include <string.h>  
#include <errno.h>  
#include <netinet/in.h>  
#include <sys/types.h>  
#include <sys/socket.h>  
#include  <arpa/inet.h>  
#include <sys/select.h>  
  
#define MAXLINE 1024  
#define SERV_PORT 6666 
  
//!> 注意输入是由stdin，接受是由server发送过来  
//!> 所以在client端也是需要select进行处理的  
void send_and_recv( int connfd )  
{  
    FILE * fp = stdin;  
    int   lens;  
    char send[MAXLINE];  
    char recv[MAXLINE];  
    fd_set rset;  
    FD_ZERO( &rset );  
    int maxfd = ( fileno( fp ) > connfd ? fileno( fp ) : connfd  + 1 );    
                                    //!> 输入和输出的最大值  
    int n;  
      
    while( 1 )  
    {  
        FD_SET( fileno( fp ), &rset );  
        FD_SET( connfd, &rset );            //!> 注意不要把rset看作是简单的一个变量  
                                //!> 注意它其实是可以包含一组套接字的哦，  
                                //!> 相当于是封装的数组！每次都要是新的哦！  
          
        if( select( maxfd, &rset, NULL, NULL, NULL ) == -1 )  
        {  
            printf("Client Select Error..\n");  
            exit(EXIT_FAILURE  );  
        }  
          
        //!> if 连接口有信息  
        if( FD_ISSET( connfd, &rset ) ) //!> if 连接端口有信息  
        {  
            printf( "client get from server ...\n" );  
            memset( recv, 0, sizeof( recv ) );  
            n = read( connfd, recv, MAXLINE );  
            if( n == 0 )  
            {  
                printf("Recv ok...\n");  
                break;  
            }  
            else if( n == -1 )  
            {  
                printf("Recv error...\n");  
                break;  
            }  
            else  
            {  
                lens = strlen( recv );  
                recv[lens] = '\0';  
                //!> 写到stdout  
                write( STDOUT_FILENO, recv, MAXLINE );  
                printf("\n");  
            }  
  
        }  
          
        //!> if 有stdin输入  
        if( FD_ISSET( fileno( fp ), &rset ) )   //!> if 有输入  
        {  
            //!> printf("client stdin ...\n");  
              
            memset( send, 0, sizeof( send ) );  
            if( fgets( send, MAXLINE, fp ) == NULL )  
            {  
                printf("End...\n");  
                exit( EXIT_FAILURE );  
            }  
            else  
            {  
                //!>if( str )  
                lens = strlen( send );  
                send[lens-1] = '\0';        //!> 减一的原因是不要回车字符  
                                            //!> 经验值：这一步非常重要的哦！！！！！！！！  
                if( strcmp( send, "q" ) == 0 )  
                {  
                    printf( "Bye..\n" );  
                    return;  
                }  
                  
                printf("Client send : %s\n", send);  
                write( connfd, send, strlen( send ) );  
            }  
        }  
          
    }  
      
}  

int main( int argc, char ** argv )  
{  
    //!> char * SERV_IP = "10.30.97.188";  
    char    buf[MAXLINE];  
    int     connfd;  
    struct sockaddr_in servaddr;  
      
    if( argc != 2 )  
    {  
        printf("Input server ip !\n");  
        exit( EXIT_FAILURE );  
    }  
      
    //!> 建立套接字  
    if( ( connfd = socket( AF_INET, SOCK_STREAM, 0 ) ) == -1 )  
    {  
        printf("Socket Error...\n");  
        exit( EXIT_FAILURE );  
    }  
  
    //!> 套接字信息  
    bzero(&servaddr, sizeof(servaddr));  
    servaddr.sin_family = AF_INET;  
    servaddr.sin_port = htons(SERV_PORT);  
    inet_pton(AF_INET, argv[1], &servaddr.sin_addr);  
      
    //!> 链接server  
    if( connect( connfd, ( struct sockaddr *  )&servaddr, sizeof( servaddr ) ) < 0 )  
    {  
        printf("Connect error..\n");  
        exit(EXIT_FAILURE);  
    } 
    */    
    /*else 
    { 
        printf("Connet ok..\n"); 
    }
	*/  
	send_and_recv( connfd );  
        
  
    close( connfd );  
    printf("Exit\n");  
      
   return 0;  
}