Linux下IO复用用并发服务器模型

IO复用意味着如果一个或多个I/O条件满足我们就能被通知到，这种能力就叫IO复用。利用select函数，可以实现IO复用的功能。select函数的定义如下：

int select (int maxfdp+1, fd_set *readset,fds_set *writeset,fd_set *execepset,const struct timeval * timeout);

函数的返回值是准备好描述字的正数目，0为超时，-1为出错。

参数maxfd+1指定被测试的描述字个数，它是被测试描述字最大值加1.

参数readset,writeset,execepset指定让内核测试的读、写、异常条件的描述字，如果不需要用到，则将其设为NULL。

select函数使用描述字符集为参数readset(writeset或者execepset）指定多个描述字，使用以下几个宏操作

 

void FD_ZERO(fd_set *fdset) /*将所有位置为0*/

void FD_SET(int fd,fd_set *fdset) /*将fd位置为1*/

void FD_CLR(int fd,fd_set *fdset) /*将fd位置为0*/

int FD_ISSET(int fd,fd_set *fdset) /*检测fa位是否置为1*/

timeout是一个timeval结构，这个结构用三种可能：

1、为空指针，select永远等待下去

2、等待固定时间：在不超过timeout指定时间内有描述字准备好I/O返回

3、根本不等待：检查描述字后立即返回

 

这个模型服务器端功能还是将客户端发过来的字符串中的小写字母全部转化为大学字母后发回客户端。客户端采用 linux多进程并发服务模型 中客户端的程序。代码如下：

 

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


#define PORT 1111
#define BACKLOG 5

typedef struct{
    int fd;
    struct sockaddr_in addr;
}clientinfo;

int process(clientinfo * client)
{
    char buf[1024];
    int n=0;
    if(0<(n=read(client->fd,buf,sizeof(buf)))){
        int i=0;
        buf[n]='\0';
        printf("got a message <%s> from %s\n",buf,inet_ntoa(client->addr.sin_addr));
        while(buf[i]!='\0'&&i<1024){
            if(buf[i]>='a'&&buf[i]<='z')
                buf[i]+=('A'-'a');
            i++;
        }
        write(client->fd,buf,strlen(buf));
    }
    return n;
}

int main(){
    int listenfd,connectfd;
    int nready;
    fd_set rset,allset;
    struct sockaddr_in server;
    clientinfo client[FD_SETSIZE];

    if(-1==(listenfd=socket(AF_INET,SOCK_STREAM,0))){
        perror("create socket error\n");
        exit(1);
    }

    int opt=SO_REUSEADDR;
    setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));

    bzero(&server,sizeof(struct sockaddr_in));
    server.sin_family=AF_INET;
    server.sin_port=htons(PORT);
    server.sin_addr.s_addr=htonl(INADDR_ANY);

    if(-1==(bind(listenfd,(struct sockaddr *)&server,sizeof(struct sockaddr )))){
        perror("bind error\n");
        exit(1);
    }

    if(-1==(listen(listenfd,BACKLOG))){
        perror("listen error\n");
        exit(1);
    }

    int maxfd=listenfd;
    int maxi=-1;

    int i;
    for(i=0;i<FD_SETSIZE;i++)
        client[i].fd=maxi;

    FD_ZERO(&allset);
    FD_SET(listenfd,&allset);

    struct sockaddr_in client_addr;
    int len=sizeof(client_addr);

    while(1){
        printf("waiting...\n");
        rset=allset;
        nready=select(maxfd+1,&rset,NULL,NULL,NULL);

        printf("nready= %d\n",nready);
        if(FD_ISSET(listenfd,&rset)){

            if(-1==(connectfd=accept(listenfd,(struct sockaddr *)&client_addr,&len))){
                perror("accept error\n");
                continue;
            }

            printf("get a connection from %s\n",inet_ntoa(client_addr.sin_addr));

            for(i=0;i<FD_SETSIZE;i++)
                if(client[i].fd<0){
                    client[i].fd=connectfd;
                    client[i].addr=client_addr;
                    break;
                }
            if(FD_SETSIZE == i)
                printf("too many clients\n");
            FD_SET(connectfd,&allset);

            if(connectfd>maxfd)
                maxfd=connectfd;
            if(i>maxi)
                maxi=i;
            if(--nready<=0)
                continue;
        }

        for(i=0;i<=maxi;i++){
            if(client[i].fd<0)
                continue;
            if(FD_ISSET(client[i].fd,&rset)){
                if(process(&client[i])<=0){
                    printf("client( %s ) closed connection\n",inet_ntoa(client[i].addr.sin_addr));
                    close(client[i].fd);
                    FD_CLR(client[i].fd,&allset);
                    client[i].fd=-1;

                }
                if(--nready<=0)
                    break;
            }
        }
    }
    close(listenfd);
    return 0;
}