I/O多路复用select服务器

一、五种I/O模型
linux下的I/O模型分为五种模型：分别是阻塞式I/O、非阻塞式I/O、I/O多路复用（多路转接）、信号驱动I/O（SIGIO）、异步I/O。
这五种I/O由分为两类：一类是同步I/O包括了前面四种，还有一类是异步I/O。
我们把I/O是分成两步的，第一步是“等”，第二步就是数据的搬迁。而对于同步I/O和异步I/O来说它们之间的区别就是同步I/O的数据搬迁工作要自己来完成，而异步I/O的数据搬迁工作是别人来完成的。而阻塞I/O和非阻塞I/O的最大不同就是“等”的方式是不同的。

二、select函数介绍
select系统调用的用途是：在一段指定的时间内，监听用户感兴趣的文件描述符上的可读、可写、异常事件。
我们看一下select函数的原型：

我们可以看到select函数里面有五个参数，下面一次做一个说明：
1、nfds：指定被监听的文件描述符的总数，通常设置为select监听的所有文件描述符的中的最大值再加1（文件描述符是从0开始的）。
2、readfds、writefds、exceptfds这三个参数都是输入输出型参数，它们表示的是可读、可写、异常事件的文件描述符的集合。这三个参数做输入型参数的意思是：关心特定的文件描述符上的指定事件；这三个参数作为输出型参数的意思是：关心的事件发生了变化已经就绪。这三个参数的类型都是fd_set的指针类型的结构体，fd_set结构体仅包含一个整形数组，数组的每一位元素的每一位（bit）标记了一个文件描述符。fd_set所能包含的文件描述符的数量由FD_SETSIZE指定，这就限制了select处理的文件描述符的总量，这样select的服务就是有上限的。
我们在访问fd_set这个数据结构的时候还有几个宏来访问fd_set，集体如下：
FD_ZERO（fd_set *fdset） //清除fdset所有位
FD_SET（int fd, fd_set *fdset） //设置fdset位
FD_CLR（int fd, fd_set *fdset） //清除fdset位
int FD_ISSET（nt fd, fd_set *fdset）//检查fdset是否被设置
3、timeout：

用来设置select函数的超时时间，select给我们提供了而一个微秒级的计时方式，如果timeout的成员tv_sec和tv_usec的成员都为0，select就会立即返回。
4、返回值：
select成功时就会返回就绪（可读、可写、异常）的文件描述符的总数，在超时时间内没有任何文件描述符就绪返回0，如果select失败就会返回-1，设置errno为EINTR。

三、代码展示
select_server.c：

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

int fds[sizeof(fd_set)*8];

static usage(const char* proc)
{
    printf("usage :%s [local_ip] [local_port]\n",proc);
}

int startup(const char* ip,int port)
{
    int sock = socket(AF_INET,SOCK_STREAM,0);
    if(sock < 0)
    {
        perror("socket");
        exit(2);
    }
    int opt = 1;
    setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));

    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_port = htons(port);
    local.sin_addr.s_addr = inet_addr(ip);//点分十进制化为四字节

    if(bind(sock,(struct sockaddr*)&local,sizeof(local)) < 0)
    {
        perror("bind");
        exit(3);
    }

    if(listen(sock,10) < 0)
    {
        perror("listen");
        exit(4);
    }
    return sock;
}

int main(int argc,char* argv[])
{
    if(argc != 3)
    {
        usage(argv[0]);
        return 1;
    }
    int listen_sock = startup(argv[1],atoi(argv[2]));
    printf("fd_set: %d\n",sizeof(fd_set)*8);
    int fds[sizeof(fd_set)];
    int nums = sizeof(fds)/sizeof(fds[0]);
    int i = 0;
    for(; i < nums; i++)
    {
        fds[i] = -1;
    }
    fds[0] = listen_sock;
    int maxfd = -1;
    fd_set rfds;//读事件
    fd_set wfds;//写事件
    while(1)
    {
        int maxfd = -1;
        struct timeval timeout = {2,0};
        FD_ZERO(&rfds);
        FD_ZERO(&wfds);
        i = 0;
        for(; i < nums;i++)
        {
            if(fds[i] == -1)
            {
                continue;
            }
            FD_SET(fds[i],&rfds);
            if(maxfd < fds[i])
            {
                maxfd = fds[i];
            }
        }
        switch(select(maxfd+1,&rfds,&wfds,NULL,&timeout))
        {                      
            case -1:   //select失败
                perror("select");
                break;
            case 0:    //超过时间没有任何描述符就绪
                printf("time out!\n");
                break;
            default:   //成功
                {
                //at least one fd ready!
                i = 0;
                for(; i < nums;i++)
                {
                    if(i == 0 && FD_ISSET(fds[i],&rfds))//listen_sock is ready, get connect
                    {
                        struct sockaddr_in client;
                        socklen_t len = sizeof(client);
                        int new_sock = accept(listen_sock,(struct sockaddr*)&client,&len);
                        if(new_sock < 0)
                        {
                            perror("accept");
                            continue;
                        }
                        //accept只是获得了一个新的连接  但是不能保证读和写正常
                        //如果对面一直不发数据  那么就会一直处于read里的等待情况  就会导致服务器的不能正常运行

                        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);
                        }
                        else
                        {
                            fds[j] = new_sock;
                        }
                    }
                    else if(i != 0 && FD_ISSET(fds[i],&rfds))//normal fd is ready
                    {
                        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);

                        }
                        else if(s == 0)
                        {
                            printf("client is quit！\n");
                            close(fds[i]);
                            fds[i] = -1;
                        }
                        else
                        {
                            perror("read");
                            close(fds[i]);
                            fds[i] = -1;
                        }
                    }
                    if(i !=0 && FD_ISSET(fds[i],&wfds))//普通的写操作
                    {
                        const char* msg = "hello client!\n";
                        ssize_t s = write(fds[i],msg,strlen(msg));
                        if(s < 0)
                        {
                            perror("write");
                        }
                        else
                        {
                            FD_CLR(fds[i],&wfds);
                        }
                    }
                }
                break;
            }
        }

    }
    close(listen_sock);
    return 0;
}

select_client.c：

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

static usage(const char* proc)
{
    printf("usage: [client_ip] [client_port]%s\n",proc);
}

int main(int argc,const char* argv[])
{
    if(argc != 3)
    {
        usage(argv[0]);
        return 1;
    }

    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];
    int fd;
    while(1)
    {
        printf("please Enter#: ");
        fflush(stdout);
        fd = dup(1);

        ssize_t s = read(0,buf,sizeof(buf)-1);
        if(s > 0)
        {
            buf[s-1] = 0;

            close(1);
            dup2(sock,1);
            printf("%s",buf);
            fflush(stdout);
        }
        else
        {
            perror("read");
            exit(4);
        }
        dup2(fd,1);
        ssize_t _s = read(sock,buf,sizeof(buf)-1);
        if(_s > 0)
        {
            buf[_s] = 0;
            printf("server echo#: %s\n",buf);
        }
    }
    close(fd);
    close(sock);
    return 0;
}

四、运行结果
服务器端运行情况：

客户端的运行情况：