select服务器

unix下，可将I/O分为五种模型：

1. 阻塞I/O
2. 非阻塞I/O
3. I/O复用（多路转接：select、(e)poll）
4. 信号驱动
5. 异步I/O

其中前四种I/O模型为同步I/O，最后一个为异步I/O，而一个I/O操作可分为两步：

1. 等待数据就绪；
2. 数据的搬移.

而高性能I/O则体现在如何减少等待的时间，即在I/O模型中的I/O复用则是通知底层I/O就绪的高效方法。
系统提供select函数来实现多路复用输入/输出模型，select系统调用是用来让我们的程序监视多个文件句柄的状态变化的。程序会停在select这里等待，直到被监视的文件句柄有一个或多个发生了状态改变则返回（关于文件句柄，即为文件描述符，最熟悉的句柄是0、1、2三个，0是标准输入，1是标准输出，2是标准错误输出。0、1、2是整数表示的，对应的FILE *结构的表示就是stdin、stdout、stderr）.

此处要注意select只是负责I/O操作中的等待，其监测多个句柄，若此时一个或多个句柄的读、写、异常事件就绪，操作系统通知，select返回，进行读写等操作，此时读写则不会阻塞。

由于select一次监测多个文件描述符，所以其操作是以文件描述符集fd_set表示，其运用位图实现。
函数如下：

#include <sys/select.h>int select(int nfds,fd_set* readfds,fd_set* writefds,fd_set* exceptfds,struct timeval* timeout);

参数如下：
nfds:监测的文件描述符集中最大的文件描述符+1；
readfds/writefds/exceptfds:为输入输出型参数，分别代表读事件文件描述符集，写事件文件描述符集，异常事件文件描述符集，以readfds为例，输入时，代表其关心的特定fd读事件，若有一个读事件就绪，则返回；输出时，特定fd上的读事件是否发生，后两个参数含义相同。
timeout:结构为timeval，用来设置select()的等待时间，其结构定义如下：

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

如果参数timeout设为：
NULL：则表示select（）没有timeout，select将一直被阻塞，直到某个文件描述符上发生了事件；
0：仅检测描述符集合的状态，然后立即返回，并不等待外部事件的发生。
特定的时间值：如果在指定的时间段里没有事件发生，select将超时返回。
返回值：
执行成功则返回文件描述词状态已改变的个数；
如果返回0代表在描述词状态改变前已超过timeout时间，没有返回；
当有错误发生时则返回-1，错误原因存于errno，此时参数readfds，writefds，exceptfds和timeout的值变成不可预测。

以下为操作文件描述符集的宏函数：

FD_CLR(int fd,fd_set* set)；⽤//用来清除文件描述符集set中相关fd 的位FD_ISSET(int fd,fd_set *set)；//用来测试文件描述符集set中相关fd的位是否为真FD_SET（int fd,fd_set*set）；⽤//用来设置文件描述符集set中相关fd的位;FD_ZERO（fd_set *set）；⽤//用来清除文件描述符集set的全部位

select服务器的优点：

1. 其为单进程服务器，却可以处理多个客户端请求，不需要多进程多线程处理，从而性能高效，cpu调度压力小，资源占用少.
2. 其一次可以检测多个句柄，只要有一个状态改变则返回，从而效率高，等待时间少

select服务器的缺点：

1. 每次调用select，都需要把fd集合从用户态拷贝到内核态，返回时要将其从内核态切回用户态，开销在fd很多时会很大；
2. 同时每次调用select都需要在内核遍历传递进来的所有fd，这个开销在fd很多时也很大，性能降低；
3. select支持的文件描述符数量有上限，linux默认是1024.

代码如下：
select_server.c:

#include <stdio.h>#include <stdlib.h>#include <string.h>#include <sys/socket.h>#include <sys/types.h>#include <arpa/inet.h>#include <netinet/in.h>#include <sys/select.h>int fds[sizeof(fd_set)*8];       //定义中转数组大小 static void usage(const char* proc){    printf("usage:%s [local_ip] [local_port]\n",proc);}int startup(char* ip,int port)    //创建监听套接字 {    int sock=socket(AF_INET,SOCK_STREAM,0);    if(sock<0)    {        perror("socket");        close(sock);        exit(2);    }    int opt=1;    setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));      //服务器挂机立即启动     struct sockaddr_in server;    server.sin_family=AF_INET;    server.sin_port=htons(port);    server.sin_addr.s_addr=inet_addr(ip);    if(bind(sock,(struct sockaddr*)&server,sizeof(server))<0)    {        perror("bind");        close(sock);        exit(3);    }    if(listen(sock,10)<0)    {        perror("listen");        close(sock);        exit(4);    }    return sock;}int main(int argc,char* argv[]){    if(argc != 3)    //命令行使用方法     {        usage(argv[0]);        return 1;    }    int nums=sizeof(fds)/sizeof(fds[0]);           //数组大小     int i=0;    for( ;i<nums;++i)    {        fds[i]=-1;   //初始化为-1     }    int listen_sock=startup(argv[1],atoi(argv[2]));        //监听套接字     fds[0]=listen_sock;    fd_set rfds;     //读文件描述符集     fd_set wfds;    //写事件描述符集     printf("fd_set# %d\n",sizeof(fd_set)*8);    while(1)    {        FD_ZERO(&rfds);         //清0         FD_ZERO(&wfds);        int maxfd=-1;        int i=0;        for(;i<nums;++i)        {            if(fds[i]==-1)            {                continue;            }            FD_SET(fds[i],&rfds);       //将数组中的文件描述符加入读文件描述符集中             if(maxfd<fds[i])            {                maxfd=fds[i];    //取得最大文件描述符             }        }        struct timeval timeout={2,0};        switch(select(maxfd+1,&rfds,&wfds,NULL,&timeout))    //select函数I/O等待rfds里读事件与wfds的写事件         {            case -1:                perror("select");                break;            case 0:                printf("timeout\n");                break;            default:        //有一个fd等待成功，返回                 {                    i=0;                    for(;i<nums;++i)                    {                        struct sockaddr_in client;                        int len=sizeof(client);                        if(i==0 && FD_ISSET(fds[i],&rfds))    //若为监听套接字则创建连接                         {                            int new_sock=accept(listen_sock,(struct sockaddr*)&client,&len);                            if(new_sock<0)                            {                                perror("accept");                                close(new_sock);                            }                            else                            {                                printf("get a new client:[%s:%d]\n",inet_ntoa(client.sin_addr),ntohs(client.sin_port));                                int j=1;                                for(;j<nums;++j)                                {                                    if(fds[j]==-1)                                        break;                                }                                if(j==nums)                                {                                    close(new_sock);                                    continue;                                }                                fds[j]=new_sock;            //将新的套接字写入数组，下次更新到文件描述符集中rfds                             }                        }                        else if(i !=0 &&FD_ISSET(fds[i],&rfds))    //正常文件描述符集就绪则读                         {                            char buf[1024];                            ssize_t s=read(fds[i],buf,sizeof(buf)-1);                            if(s>0)                  //读成功                             {                                buf[s]=0;                                printf("client# %s\n",buf);                                FD_SET(fds[i],&wfds);    //则此fd要关心写事件，加入写文件描述符集中                             }                            else if(s==0)                            {                                printf("client close!!!\n");                                close(fds[i]);                                fds[i]=-1;                             }                            else                            {                                perror("read");                                continue;                             }                        }                        if(i != 0 && FD_ISSET(fds[i],&wfds))        //若写事件就绪则写                         {                            const char* msg="I am s erver!!!\n";                            ssize_t s=write(fds[i],msg,strlen(msg));                            if(s<0)                            {                                perror("write");                                 close(fds[i]);                                fds[i]=-1;                                continue;                            }                            FD_CLR(fds[i],&wfds);    //写完将此fd清除于wfds(即读完一个增加一个，写完一个清除一个)                         }                    }                }                break;        }    }    close(listen_sock);    return 0;}

select_client.c:

#include <stdio.h>#include <stdlib.h>#include <string.h>#include <sys/socket.h>#include <sys/types.h>#include <arpa/inet.h>#include <netinet/in.h>#include <sys/select.h>static void usage(const char* porc){    printf("usage:%s [server_ip] [server_port]\n",porc);}int main(int argc,char* argv[]){    if(argc != 3)   //用法     {        usage(argv[0]);    }    int sock=socket(AF_INET,SOCK_STREAM,0);    if(sock<0)    {        perror("socket");        exit(2);    }    struct sockaddr_in server;    server.sin_family=AF_INET;    server.sin_port=htons(atoi(argv[2]));    server.sin_addr.s_addr=inet_addr(argv[1]);    if(connect(sock,(struct sockaddr*) &server,sizeof(server))<0)    //连接     {        perror("connect");        exit(3);    }    char buf[1024];    while(1)    {        printf("please Enter# ");        fflush(stdout);        int fd=dup(1);    //先使fd也指向标准输出(1)stdout         ssize_t s=read(0,buf,sizeof(buf)-1);        if(s>0)        {            buf[s-1]=0;            //write(sock,buf,strlen(buf));            //dup2            close(1);            dup2(sock,1);    // 改变1内容指针，同指向sock             printf("%s",buf);   //则此时打印到标准输出的内容将打印到网络sock中             fflush(stdout);        }        else        {            perror("read");            exit(4);        }        dup2(fd,1);     //使1再次指向标准输出，恢复         ssize_t _s=read(sock,buf,sizeof(buf)-1);        if(_s>0)        {            buf[s]=0;            printf("server# %s\n",buf);        }    }    close(fd);    close(sock);    return 0;}

结果如下：