I/O复用之select与pselect

最新推荐文章于 2022-08-31 14:49:31 发布

IT_Linux

最新推荐文章于 2022-08-31 14:49:31 发布

阅读量1.3k

点赞数

分类专栏： socket 文章标签： io linux select pselect

本文链接：https://blog.csdn.net/pngynghay/article/details/8169417

版权

socket 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

IO复用概念

有些进程需要一种预先告知内核的能力，使得内核一旦发现进程指定的一个或者多个I/O条件就绪（即是说，输入已经准备好读取，或者，描述字已经能承接更多的输出），它就通知进程，这个能力就成为I/O复用，是由select和poll这两个函数支持的。其中，关于poll的讲解可以参考http://blog.csdn.net/pngynghay/article/details/17327179。另外，select和poll的增强版本epoll模型，可以参考http://blog.csdn.net/pngynghay/article/details/8169455

典型的网络应用场合

当客户端需要处理多个描述字（通常是交互式输入和网络套接口）时，必须使用IO复用。
一个客户同时处理多个套接口是可能的，不过，比较少见。
如果一个TCP服务器既要处理监听套接口，又要处理已连接套接口，一般就要哦使用IO复用。
如果一个服务器既要处理TCP，又要处理UDP，一般要使用IO复用。
如果一个服务器要处理多个服务或者多个协议，一般就要使用IO复用。

注：IO复用并非只限于网络编程。

select函数

函数原型

int select(int maxfdp1, fd_set *readset, fd_set *writeset, fd_set *exceptset, const struct timeval *timeout)

返回值：就绪描述字的正数目，0表示超时，-1表示你出错

参数：

maxfdpl：指定待测试的描述字个数，它的值是待测试的最大描述字加1（因为描述字是从0开始的）；select.h中定义的FD_SETSIZE是数据类型fd_set中的描述字总数，通常为1024。

readset：读集合

writeset：写集合

exceptset：异常集合

timeout：告知内核等待所指定描述字中的任何一个就绪可花多长时间，timeval结构体用于指定这段时间的秒数和微秒数。如果该参数为NULL，那么，select函数将一直等待下去，直到有描述字准备好IO返回；如果该参数不为NULL，并且timeout为0（即定时器值的微秒数和秒数均为0），那么，select检查描述字后立即返回，成为轮询；如果该参数不为NULL，且timeout不为0，那么，select等待时间不超过timeout值，且在等待期间，如果有一个IO准备就绪，select也立即返回。

该函数允许进程指示内核等待多个事件中的任何一个发生，并仅在有一个或者多个事件发生或者经历一段指定的时间后才唤醒它。我们调用select函数告诉内核对哪些描述字感兴趣以及等待多长时间。

注：我们感兴趣的描述字不局限于套接口，任何描述字都可以使用select来测试。

利用select函数，判断套接字上是否存在数据，或者能否向一个套接字写入数据。目的是防止应用程序在套接字处于锁定模式时，调用recv（或send）从没有数据的套接字上接收数据，被迫进入阻塞状态。

fd_set是一个SOCKET队列，以下宏可以对该队列进行操作：

FD_CLR( s, *set) 从队列set删除句柄s;

FD_ISSET( s, *set) 检查句柄s是否存在与队列set中;

FD_SET( s, *set )把句柄s添加到队列set中;

FD_ZERO( *set ) 把set队列初始化成空队列.

注：select函数的三个fd_set参数所指向的描述字集，都是值-结果参数。调用该函数时，我们指定所关心的描述字的值，该函数返回时，结果表示哪些描述字已经准备就绪。该函数返回后，我们使用FD_ISSET宏来测试fd_set数据类型中的描述子。描述字集中任何与未就绪的描述字想对应的位均清0，为此，每次重新调用select函数时，我们都得再次把我们感兴趣的所有描述字集的位置1.

附Linux man部分信息

NAME
select, pselect, FD_CLR, FD_ISSET, FD_SET, FD_ZERO - synchronous I/O multiplexing

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

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

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

       void FD_CLR(int fd, fd_set *set);
       int FD_ISSET(int fd, fd_set *set);
       void FD_SET(int fd, fd_set *set);
       void FD_ZERO(fd_set *set);

#define _XOPEN_SOURCE 600
#include <sys/select.h>

       int pselect(int nfds, fd_set *readfds, fd_set *writefds,
                   fd_set *exceptfds, const struct timespec *timeout,
                   const sigset_t *sigmask);

DESCRIPTION
       select() and pselect() allow a program to monitor multiple file descriptors, waiting until one or
       more of the file descriptors become "ready" for some class of I/O operation (e.g., input possi-
       ble).   A file descriptor is considered ready if it is possible to perform the corresponding I/O
       operation (e.g., read(2)) without blocking.

The operation of select() and pselect() is identical, with three differences:

(i) select() uses a timeout that is a struct timeval (with seconds and microseconds), while
pselect() uses a struct timespec (with seconds and nanoseconds).

(ii) select() may update the timeout argument to indicate how much time was left. pselect()
does not change this argument.

(iii) select() has no sigmask argument, and behaves as pselect() called with NULL sigmask.

       Three independent sets of file descriptors are watched. Those listed in readfds will be watched
       to see if characters become available for reading (more precisely, to see if a read will not
       block; in particular, a file descriptor is also ready on end-of-file), those in writefds will be
       watched to see if a write will not block, and those in exceptfds will be watched for exceptions.
       On exit, the sets are modified in place to indicate which file descriptors actually changed sta-
       tus.   Each of the three file descriptor sets may be specified as NULL if no file descriptors are
       to be watched for the corresponding class of events.

       Four macros are provided to manipulate the sets. FD_ZERO() clears a set. FD_SET() and FD_CLR()
       respectively add and remove a given file descriptor from a set. FD_ISSET() tests to see if a file
       descriptor is part of the set; this is useful after select() returns.

nfds is the highest-numbered file descriptor in any of the three sets, plus 1.

       timeout is an upper bound on the amount of time elapsed before select() returns. It may be zero,
       causing select() to return immediately. (This is useful for polling.) If timeout is NULL (no time-
       out), select() can block indefinitely.

       sigmask is a pointer to a signal mask (see sigprocmask(2)); if it is not NULL, then pselect()
       first replaces the current signal mask by the one pointed to by sigmask, then does the ‘select’
       function, and then restores the original signal mask.

Other than the difference in the precision of the timeout argument, the following pselect() call:

ready = pselect(nfds, &readfds, &writefds, &exceptfds,
timeout, &sigmask);

is equivalent to atomically executing the following calls:

sigset_t origmask;

           sigprocmask(SIG_SETMASK, &sigmask, &origmask);
           ready = select(nfds, &readfds, &writefds, &exceptfds, timeout);
           sigprocmask(SIG_SETMASK, &origmask, NULL);

       The reason that pselect() is needed is that if one wants to wait for either a signal or for a file
       descriptor to become ready, then an atomic test is needed to prevent race conditions. (Suppose
       the signal handler sets a global flag and returns. Then a test of this global flag followed by a
       call of select() could hang indefinitely if the signal arrived just after the test but just before
       the call. By contrast, pselect() allows one to first block signals, handle the signals that have
       come in, then call pselect() with the desired sigmask, avoiding the race.)

The timeout
The time structures involved are defined in <sys/time.h> and look like

         struct timeval {
             long    tv_sec;         /* seconds */
             long    tv_usec;        /* microseconds */
         };

and

         struct timespec {
             long    tv_sec;         /* seconds */
             long    tv_nsec;        /* nanoseconds */
         };

(However, see below on the POSIX.1-2001 versions.)

Some code calls select() with all three sets empty, n zero, and a non-NULL timeout as a fairly
portable way to sleep with subsecond precision.

       On Linux, select() modifies timeout to reflect the amount of time not slept; most other implemen-
       tations do not do this. (POSIX.1-2001 permits either behaviour.) This causes problems both when
       Linux code which reads timeout is ported to other operating systems, and when code is ported to
       Linux that reuses a struct timeval for multiple select()s in a loop without reinitializing it.
       Consider timeout to be undefined after select() returns.

RETURN VALUE
       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.

ERRORS
EBADF An invalid file descriptor was given in one of the sets. (Perhaps a file descriptor that
was already closed, or one on which an error has occurred.)

EINTR A signal was caught.

EINVAL nfds is negative or the value contained within timeout is invalid.

ENOMEM unable to allocate memory for internal tables.

服务器程序如下：

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

/* According to POSIX.1-2001 */
#include <sys/select.h>
/* According to earlier standards */
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>


#define MAXLINE 1024
#define SERV_PORT 5000
#define LISTENQ 100 

void err_quit(char * msg)
{
        printf("err %s", msg);
        exit(0);
}

int main(int argc, char **argv)
{
        int i, maxi, maxfd, listenfd, connfd, sockfd;
        int nready, client[FD_SETSIZE];
        ssize_t n;
        fd_set rset, allset;
        char buf[MAXLINE];
        socklen_t clilen;
        struct sockaddr_in cliaddr, servaddr;

        listenfd = socket(AF_INET, SOCK_STREAM, 0);

        bzero(&servaddr, sizeof(servaddr));
        servaddr.sin_family      = AF_INET;
        servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
        servaddr.sin_port        = htons(SERV_PORT);

        bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr));

        listen(listenfd, LISTENQ);

        maxfd = listenfd;                       /* initialize */
        maxi = -1;                                      /* index into client[] array */
        for (i = 0; i < FD_SETSIZE; i++)
                client[i] = -1;                 /* -1 indicates available entry */
        FD_ZERO(&allset);
        FD_SET(listenfd, &allset);
        /* end fig01 */

        /* include fig02 */
        for ( ; ; ) {
                rset = allset;          /* structure assignment */
                nready = select(maxfd+1, &rset, NULL, NULL, NULL);

                if (FD_ISSET(listenfd, &rset)) {        /* new client connection */
                        clilen = sizeof(cliaddr);
                        connfd = accept(listenfd, (struct sockaddr *) &cliaddr, &clilen);
#ifdef  NOTDEF
                        printf("new client: %s, port %d\n",
                                        inet_ntop(AF_INET, &cliaddr.sin_addr, 4, NULL),
                                        ntohs(cliaddr.sin_port));
#endif

                        for (i = 0; i < FD_SETSIZE; i++)
                                if (client[i] < 0) {
                                        client[i] = connfd;     /* save descriptor */
                                        break;
                                }
                        if (i == FD_SETSIZE)
                                err_quit("too many clients");

                        FD_SET(connfd, &allset);        /* add new descriptor to set */
                        if (connfd > maxfd)
                                maxfd = connfd;                 /* for select */
                        if (i > maxi)
                                maxi = i;                               /* max index in client[] array */

                        if (--nready <= 0)
                                continue;                               /* no more readable descriptors */
                }

                for (i = 0; i <= maxi; i++) {   /* check all clients for data */
                        if ( (sockfd = client[i]) < 0)
                                continue;
                        if (FD_ISSET(sockfd, &rset)) {
                                if ( (n = read(sockfd, buf, MAXLINE)) == 0) {
                                        /*4connection closed by client */
                                        close(sockfd);
                                        FD_CLR(sockfd, &allset);
                                        client[i] = -1;
                                } else
                                        write(sockfd, buf, n);

                                if (--nready <= 0)
                                        break;                          /* no more readable descriptors */
                        }
                }
        }
}

关系到套接字列表的操作都需要使用循环,在轮询的时候,需要遍历一次,再新的一轮开始时,将列表加入队列又需要遍历一次.也就是说,Select在工作一次时,需要至少遍历2次列表,这是它效率较低的原因之一.在大规模的网络连接方面,还是推荐使用IOCP或EPOLL模型.但是Select模型可以使用在诸如对战类游戏上,比如类似星际这种,因为它小巧易于实现,而且对战类游戏的网络连接量并不大.

客户端程序同 http://blog.csdn.net/pngynghay/article/details/8169455中的客户端程序