读懂select函数

                                                           读懂select函数

1.定义：

select函数属于IO多路转接模型中的监控函数，主要是监控描述符的读写和异常。

2.接口：

void FD_ZERO(fd_set *set); 清空集合
fd_set: 描述符集合的结构体，里面只有一个数组，当位图使用，大小为1024。
set：为描述符集合。
void FD_SET(int fd, fd_set *set); 将描述符添加到集合中去。
fd:为描述符，set：是集合。
int  FD_ISSET(int fd, fd_set *set);判断fd描述符是不是在集合中。
void FD_CLR(int fd, fd_set *set);从集合中删除fd描述符。
int select(int nfds, fd_set *readfds, fd_set *writefds,fd_set *exceptfds, struct timeval *timeout);
nfds:表示三个集合中最大的描述符。（提高遍历的效率）
readfds，writefds，exceptfds 分别为监控的三种集合， 可读，可写，异常。
timeout 为监控的等待的超时时间。 若为NULL 则一直阻塞，等待有就绪描述符，
若为0则表示非阻塞，若大于0.则表示具体的等待时间。
返回值为，就绪的描述符个数，出错就是-1；

 

3.流程：

1.首先程序员定义事件的描述符集合（三种事件就对应了三种集合），然后初始化清空集合，将要监控的指定事件的描述符添加到指定的集合中。

2.将三个描述符集合拷贝到内核中去，便开始发起了监控，如果有描述符就绪，或者是等待的事件超时了，就会返回，在返回之前将三个集合中木就绪的描述符就从集合中移除，留下来的就是就绪的描述符。

3.程序员逐个去判断哪个描述符还在集合中，就知道哪个描述符现在就绪了，对其进行操作。

4.如果还要接着监控，就将描述符集合哎拷贝到内核中，重新开始监控，重复这一步操作。

4.优缺点：

优点：1.遵循posix标准，可以跨平台，移植性强。

           2.监控的超时等待时间，可以精确到微秒。

缺点：1.select监控的描述符有上限，默认是1024个。

           2.select监控的原理，是将描述符拷贝到内核中，进行轮询遍历监控，性能会随着描述符的增加而下降。

          3.select监控返回的是就绪描述符的个数，需要遍历才能确定是不是就绪事件。

          4 .select 每次会将未就绪的描述符移除集合，导致每次监控完，下一次监控前，都要讲描述符从用户态拷贝到内核态中。

5.代码的简单实现：

利用tcp协议，监控了可读事件。

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

#define MAXFD   10
int socket_create();
void fds_init(int fds[]);
void fds_add(int fds[], int fd);
void fds_del(int fds[], int fd);

int main()
{
    int sockfd = socket_create();
    assert( sockfd != -1 );

    int fds[10];

    fds_init(fds);

    fds_add(fds,sockfd);//监听套接字添加到数组

    fd_set fdset;

    while( 1 )
    {
        FD_ZERO(&fdset);//情况监控的集合

        int maxfd = -1;
        int i = 0;

        for( ;i < MAXFD; i++ )
        {
            if ( fds[i] == -1 )
            {
                continue;
            }

            FD_SET(fds[i],&fdset);//将描述副添加到监控集合中
            if ( maxfd < fds[i] )
            {
                maxfd = fds[i];
            }
        }


        struct timeval tv = {5,0};//设置超时时间

        int n = select(maxfd+1,&fdset,NULL,NULL,&tv);//发起监控，返回的时候：等待时间超时或者是有就绪描述符了
        if ( n == -1 )
        {
            perror("select error");
            continue;
        }
        else if ( n == 0 )  //等待时间超时
        {
            printf("time out\n");
            continue;
        }
        else  //有就绪的描述符了
        {
            int i = 0;
            for( ;i < MAXFD; i++ )
            {
                if ( fds[i] == -1 )
                {
                    continue;
                }

                if ( FD_ISSET(fds[i],&fdset) ) //判断是否有数据就绪
                {
                    if( fds[i] == sockfd )
                    {
                        //accept
                        struct sockaddr_in caddr;
                        int len = sizeof(caddr);
                        int c = accept(sockfd,(struct sockaddr*)&caddr,&len);
                        if ( c < 0 )
                        {
                            continue;
                        }

                        printf("accept c=%d\n",c);

                        fds_add(fds,c);
                    }
                    else
                    {
                        //recv
                        char buff[128] = {0};
                        int res = recv(fds[i],buff,127,0);
                        if ( res <= 0 )
                        {
                            close(fds[i]);
                            fds_del(fds,fds[i]);  //移除集合，下次就不监控了
                            printf("one client over\n");   
                            continue;
                        }

                        printf("read(%d):%s\n",fds[i],buff);

                        send(fds[i],"ok",2,0);
                    }
                }
            }
        }
    }

}

void fds_init(int fds[])
{
    int i = 0;
    for( ;i < MAXFD; i++ )
    {
        fds[i] = -1;
    }
}
void fds_add(int fds[], int fd)
{
    int i = 0;
    for( ; i < MAXFD; i++ )
    {
        if ( fds[i] == -1 )
        {
            fds[i] = fd;
            break;
        }
    }
}
void fds_del(int fds[], int fd)
{
    int i = 0;
    for(; i < MAXFD; i++ )
    {
        if ( fds[i] == fd )
        {
            fds[i] = -1;
            break;
        }
    }
}
int socket_create()
{
    int sockfd = socket(AF_INET,SOCK_STREAM,0);
    if ( sockfd == -1 )
    {
        return -1;
    }

    struct sockaddr_in saddr;
    memset(&saddr,0,sizeof(saddr));
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(6000);
    saddr.sin_addr.s_addr = inet_addr("127.0.0.1");

    int res = bind(sockfd,(struct sockaddr*)&saddr,sizeof(saddr));
    if ( res == -1 )
    {
        return -1;
    }

    listen(sockfd, 5);

    return sockfd;
    
}