Socket编程实践(8) --Select-I/O复用

五种I/O模型介绍

(1)阻塞I/O[默认]

   当上层应用App调用recv系统调用时，如果对等方没有发送数据(Linux内核缓冲区中没有数据),上层应用Application1将阻塞;当对等方发送了数据，Linux内核recv端缓冲区数据到达,内核会把数据copy给用户空间。然后上层应用App解除阻塞,执行下一步操作。

 

(2)非阻塞I/O[少用]

   上层应用App将套接字设置成非阻塞模式, 然后循环调用recv函数，接受数据。若缓冲区没有数据，上层应用不会阻塞，recv返回值为-1，错误码是EWOULDBLOCK。

   上层应用程序不断轮询有没有数据到来。造成上层应用忙等待。大量消耗CPU。因此非阻塞模式很少直接用。应用范围小，一般和IO复用配合使用。

 

(3)I/O多路复用[重点]

   上层应用App调用select等其他IO复用系统调用（该机制由Linux内核支持，避免了App忙等待），进行轮询文件描述符的状态变化; 当select管理的文件描述符没有数据（或者状态没有变化时），上层应用也会阻塞。

   好处是:select机制可以管理多个文件描述符; 可以将select看成一个管理者，用select来管理多个IO, 一旦检测到的一个IO或者多个IO，有我们感兴事件发生时，select函数将返回，返回值为检测到的事件个数。进而可以利用select相关API函数，操作具体事件。

   select函数可以设置等待时间，避免了上层应用App长期僵死。

   和阻塞IO模型相比，select I/O复用模型相当于提前阻塞了。等到有数据到来时，再调用recv就不会发生阻塞。

 

(4)信号驱动I/O[并不常用]

   上层应用App建立SIGIO信号处理程序。当缓冲区有数据到来，内核会发送信号告诉上层应用App; 当上层应用App接收到信号后，调用recv函数，因缓冲区有数据，recv函数一般不会阻塞。

   这种用于模型用的比较少，属于典型的“拉模式(上层应用被动的去Linux内核空间中拉数据)”。即：上层应用App,需要调用recv函数把数据拉进来,会有时间延迟,我们无法避免在延迟时,又有新的信号的产生。

 

(5)异步I/O[并不常用]

   上层应用App调用aio_read函数，同时提交一个应用层的缓冲区buf；调用完毕后，不会阻塞。上层应用程序App可以继续其他任务; 当TCP/IP协议缓冲区有数据时，Linux主动的把内核数据copy到用户空间。然后再给上层应用App发送信号；告诉App数据到来,需要处理！

   异步IO属于典型的“推模式”, 是效率最高的一种模式，上层应用程序App有异步处理的能力（在Linux内核的支持下,处理其他任务的同时，也可支持IO通讯, 与Windows平台下的完成端口作用类似IOCP）。

 

Select-I/O复用

#include 
#include 
#include 
#include 
int select(int nfds, fd_set *readfds, fd_set *writefds,
           fd_set *exceptfds, struct timeval *timeout);

    select实现的是一个管理者的功能: 用select来管理多个IO, 一旦其中的一个IO或者多个IO检测到我们所感兴趣的事件, select就返回, 返回值就是检测到的事件个数, 并且由第2~4个参数返回那些IO发送了事件, 这样我们就可以遍历这些事件, 进而处理这些事件;

参数:

nfds: is the highest-numbered file descriptor in any of the three sets,plus 1[读,写,异常集合中的最大文件描述符+1].

fd_set[四个宏用来对fd_set进行操作]

       FD_CLR(int fd, fd_set *set);

       FD_ISSET(int fd, fd_set *set);

       FD_SET(int fd, fd_set *set);

       FD_ZERO(fd_set *set);

timeout[从调用开始到select返回前，会经历的最大等待时间, 注意此处是指的是相对时间]

//timeval结构:
struct timeval
{
    long    tv_sec;	    /* seconds */
    long	tv_usec;    /* microseconds */
};
//一些调用使用3个空的set, n为0, 一个非空的timeout来达到较为精确的sleep.

Linux中, select函数改变了timeout值，用来指示还剩下的时间，但很多实现并不改timeout。

为了较好的可移植性，timeout在循环中一般常被重新赋初值。

 

Timeout取值:

    timeout== NULL

        无限等待,被信号打断时返回-1, errno 设置成 EINTR

    timeout->tv_sec == 0 && tvptr->tv_usec == 0

        不等待立即返回

    timeout->tv_sec != 0 || tvptr->tv_usec != 0

        等待特定时间长度, 超时返回0

 

返回值:

  On success, select() and pselect() return the number of  file  descriptors  contained  in  

the  three  returned descriptor sets (that is, the total number of bits that are  set  in  

readfds,  writefds,  exceptfds) which  may  be  zero if the timeout expires before anything 

interesting happens.  On error, -1 is returned, and errno is set appropriately; the sets  

and  timeout  become  undefined, so do not rely on their contents after an error.

   如果成功，返回所有sets中描述符的个数；如果超时，返回0；如果出错，返回-1.

 

读, 写, 异常事件发生条件
可读:	可写:	异常:
套接口缓冲区有数据可读(连接的对等方发送数据过来, 填充了本地套接口缓冲区, 所以导致套接口缓冲区有数据可读);	套接口发送缓冲区有空间容纳数据(因为大部分时间发送缓冲区是未满的, 因此我们一般不关心这个事件);	套接口存在带外数据;
连接的读一半(对端)关闭(对方调用了close), 即接收到FIN段, 读操作将返回0;	连接的写一半关闭. 即收到RST段之后, 再次调用write操作;
如果是监听套接口, 已完成队列不为空时;	套接口发生了一个错误待处理, 错误可以通过getsockopt指定SO_ERROR选项来获取;
套接口发生了一个错误等待处理, 错误可以通过getsockopt指定SO_ERROR选项来获取;

/**示例1: 用select来改进echo回声服务器的client端的echoClient函数
使得可以在单进程的情况下同时监听多个文件描述符;
**/
void echoClient(int sockfd)
{
    char buf[512];
    fd_set rset;
    //确保标准输入不会被重定向
    int fd_stdin = fileno(stdin);
    int maxfd = fd_stdin > sockfd ? fd_stdin : sockfd;
    while (true)
    {
        FD_ZERO(&rset);
        FD_SET(fd_stdin, &rset);
        FD_SET(sockfd, &rset);
        int nReady = select(maxfd+1, &rset, NULL, NULL, NULL);
        if (nReady == -1)
            err_exit("select error");
        else if (nReady == 0)
            continue;

        /** nReady > 0: 检测到了可读事件 **/

        if (FD_ISSET(fd_stdin, &rset))
        {
            memset(buf, 0, sizeof(buf));
            if (fgets(buf, sizeof(buf), stdin) == NULL)
                break;
            if (writen(sockfd, buf, strlen(buf)) == -1)
                err_exit("write socket error");
        }
        if (FD_ISSET(sockfd, &rset))
        {
            memset(buf, 0, sizeof(buf));
            int readBytes = readline(sockfd, buf, sizeof(buf));
            if (readBytes == 0)
            {
                cerr << "server connect closed..." << endl;
                exit(EXIT_FAILURE);
            }
            else if (readBytes == -1)
                err_exit("read-line socket error");

            cout << buf;
        }
    }
}

/**示例2: 用select来改进echo回声服务器的server端的接受连接与处理连接部分的代码:
使得可以在单进程的情况下处理多客户连接, 对于单核的CPU来说, 单进程使用select处理连接与监听套接字其效率不一定就会比多进程/多线程性能差;

**/
    struct sockaddr_in clientAddr;
    socklen_t addrLen;
    int maxfd = listenfd;
    fd_set rset;
    fd_set allset;
    FD_ZERO(&rset);
    FD_ZERO(&allset);
    FD_SET(listenfd, &allset);

    //用于保存已连接的客户端套接字
    int client[FD_SETSIZE];
    for (int i = 0; i < FD_SETSIZE; ++i)
        client[i] = -1;
    int maxi = 0;   //用于保存最大的不空闲的位置, 用于select返回之后遍历数组

    while (true)
    {
        rset = allset;
        int nReady = select(maxfd+1, &rset, NULL, NULL, NULL);
        if (nReady == -1)
        {
            if (errno == EINTR)
                continue;
            err_exit("select error");
        }
        //nReady == 0表示超时, 但是此处是一定不会发生的
        else if (nReady == 0)
            continue;

        if (FD_ISSET(listenfd, &rset))
        {
            addrLen = sizeof(clientAddr);
            int connfd = accept(listenfd, (struct sockaddr *)&clientAddr, &addrLen);
            if (connfd == -1)
                err_exit("accept error");

            int i;
            for (i = 0; i < FD_SETSIZE; ++i)
            {
                if (client[i] < 0)
                {
                    client[i] = connfd;
                    if (i > maxi)
                        maxi = i;
                    break;
                }
            }
            if (i == FD_SETSIZE)
            {
                cerr << "too many clients" << endl;
                exit(EXIT_FAILURE);
            }
            //打印客户IP地址与端口号
            cout << "Client information: " << inet_ntoa(clientAddr.sin_addr)
                 << ", " << ntohs(clientAddr.sin_port) << endl;
            //将连接套接口放入allset, 并更新maxfd
            FD_SET(connfd, &allset);
            if (connfd > maxfd)
                maxfd = connfd;

            if (--nReady <= 0)
                continue;
        }

        /**如果是已连接套接口发生了可读事件**/
        for (int i = 0; i <= maxi; ++i)
            if ((client[i] != -1) && FD_ISSET(client[i], &rset))
            {
                char buf[512] = {0};
                int readBytes = readline(client[i], buf, sizeof(buf));
                if (readBytes == -1)
                    err_exit("readline error");
                else if (readBytes == 0)
                {
                    cerr << "client connect closed..." << endl;
                    FD_CLR(client[i], &allset);
                    close(client[i]);
                    client[i] = -1;
                }
                //注意此处: Server从Client获取数据之后并没有立即回射回去,
                //        而是等待四秒钟之后再进行回射
                sleep(4);
                cout << buf;
                if (writen(client[i], buf, readBytes) == -1)
                    err_exit("writen error");

                if (--nReady <= 0)
                    break;
            }
    }

完整源代码请参照:

http://download.csdn.net/detail/hanqing280441589/8486517

转载于:https://www.cnblogs.com/itrena/p/5926936.html