select并发服务器实现

1. select是什么？

        select()函数监视多个文件描述符，等待所监视的一个或者多个文件描述符变为“准备好”的事件状态。”准备好“状态是指：文件描述符不再是阻塞状态，可以用于某类IO操作了，包括可读，可写，发生异常三种。

2. select用法

/* According to POSIX.1-2001 */
#include <sys/select.h>

/* According to earlier standards */
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>

//select的函数格式：
int select(int nfds, fd_set *readfds, fd_set *writefds,
           fd_set *exceptfds, struct timeval *timeout);

void FD_CLR(int fd, fd_set *set); //清除文件句柄fd与fdset的联系。
int  FD_ISSET(int fd, fd_set *set); //检查fdset联系的文件句柄fd是否可读写，>0表示可读写。
void FD_SET(int fd, fd_set *set); //建立文件句柄fd与fdset的联系。 
void FD_ZERO(fd_set *set); //清空fdset与所有文件句柄的联系。 

参数：

1. int maxfdp是一个整数值，是指所有文件描述符的范围。
2. 结构体struct fd_set，存放的是文件描述符(file descriptor)，即文件读写句柄。
3. struct timeval用来代表时间值，有两个成员，一个是秒数，另一个是毫秒数。 若将NULL以形参传入，即不传入时间结构，就是将select置于阻塞状态，一定等到监视文件描述符集合中某个文件描述符发生变化为止；第二，若将时间值设为0秒0毫秒，就变成一个纯粹的非阻塞函数，不管文件描述符是否有变化，都立刻返回继续执行，文件无变化返回0，有变化返回一个正值；第三，timeout的值大于0，这就是等待的超时时间，即select在timeout时间内阻塞，超时时间之内有事件到来就返回了，否则在超时后不管怎样一定返回。

        struct timeval{      

                long tv_sec;   /*秒 */

                long tv_usec;  /*微秒 */   

        }

 返回值：如果有select会返回一个大于0的值。如果没有则在timeout的时间后select返回0，若发生错误返回负值。

3. 理解select模型

假如fd_set长度为1字节，fd_set中的每一位bit为一个文件描述符fd。则1字节长的fd_set最大可以对应8个fd。

（1）执行fd_set set；FD_ZERO(&set)；则set用位表示是0000,0000。

（2）若fd＝5，执行FD_SET(fd,&set)；后set变为0001,0000(第5位置为1)。

（3）若再加入fd＝2，fd=1,则set变为0001,0011

（4）执行select(6,&set,0,0,0)阻塞等待

（5）若fd=1,fd=2上都发生可读事件，则select返回，此时set变为0000,0011。

注意：没有事件发生的fd=5被清空。

select模型的特点：

（1） select使用位域的方式传回有状态的文件描述符，需要循环遍历每一个位判断是否就绪。当文件描述符个数很多，但是空闲的文件描述符大大多于就绪的文件描述符的时候，效率很低。

（2） 将监视fd加入select监控集合的同时，还要再使用一个设置fd集合保存，一是用于再select 返回后，设置fd作为源数据和fd_set进行FD_ISSET判断。二是select返回后会把以前加入的但并无事件发生的fd清空，则每次开始 select前都要重新从设置fd拷贝到监视fd，再将监视fd加入select监控集合。

4. 代码：

实现多个客户端接入和读写

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

//新客户端接入
int server_handler(int server)
{
    struct sockaddr_in addr = {0};
    socklen_t asize = sizeof(addr);

    return accept(server, (struct sockaddr*)&addr, &asize);
}

//客户端数据
int client_handler(int client)
{
    char buf[32] = {0};
    int ret = read(client, buf, sizeof(buf)-1);

    if( ret > 0 )
    {
        buf[ret] = 0;

        printf("Receive: %s\n", buf);

        if( strcmp(buf, "quit") != 0 )
        {
            ret = write(client, buf, ret);
        }
        else
        {
            ret = -1;
        }
    }

    return ret;
}

int main()
{
    int server = 0;
    struct sockaddr_in saddr = {0};
    int max = 0;
    int num = 0;
    fd_set reads = {0}; //设置fd
    fd_set temps = {0};	//监视的fd
    struct timeval timeout = {0};

    server = socket(PF_INET, SOCK_STREAM, 0);
    if( server == -1 )
    {
        printf("server socket error\n");
        return -1;
    }

    saddr.sin_family = AF_INET;
    saddr.sin_addr.s_addr = htonl(INADDR_ANY);
    saddr.sin_port = htons(8888);

    if( bind(server, (struct sockaddr*)&saddr, sizeof(saddr)) == -1 )
    {
        printf("server bind error\n");
        return -1;
    }

    if( listen(server, 1) == -1 )
    {
        printf("server listen error\n");
        return -1;
    }

    printf("server start success\n");

    FD_ZERO(&reads); //清零
    FD_SET(server, &reads); //假如监视fd

    max = server;

    while( 1 )
    {
        temps = reads; //因为无事件发生的fd会被清空，重新复制

        timeout.tv_sec = 0;
        timeout.tv_usec = 10000;

        num = select(max+1, &temps, 0, 0, &timeout);

        if( num > 0 )
        {
            for(int i=1; i<=max; i++)
            {
                if( FD_ISSET(i, &temps) ) //监视的fd,无事件发生的fd会被清空
                {
                    if( i == server )
                    {
                        int client = server_handler(server);

                        if( client > -1 )
                        {
                            FD_SET(client, &reads);

                            max = (client > max) ? client : max;

                            printf("accept client: %d\n", client); 
                        }
                    }
                    else
                    {
                        int r = client_handler(i);
                        if( r == -1 )
                        {
                            FD_CLR(i, &reads);
                            close(i);
                        }
                    }
                }
            }
        }
    }
    
    close(server);

    return 0;
}

总结

1.select()监视多个描述符，如果他们没有事件时，进程会将它们置于休眠状态。

2. 我们应该总是设置timeout=0，因为如果没有可用的数据，程序在运行时间里将无视可做。每次调用select之前，timeout都用重新设置。

3. select返回后，所有的文件描述符都应该被检查，看看他们是否准备好了。

4. read，recv，write，send，这几个函数不一定读/写你所请求的全部数据。

5. 由于select()修改其文件描述符集，如果调用在循环中使用，则必须在每次调用之前重新初始化这些集。

6. 相比于用线程，进程，IPCS，信号，内存共享等方式来解决问题，select函数更有效且轻松。系统调用poll和select相似，在监视稀疏文件集合的时候更加有效。poll现在也在被广泛的使用，但没有select简便。linux专用的epoll在监视大连数据时比select和poll更加有效。