linux poll

 

IO多路复用之poll总结

 

1、基本知识

  poll的机制与select类似,与select在本质上没有多大差别,管理多个描述符也是进行轮询,根据描述符的状态进行处理,但是poll没有最大文件描述符数量的限制。poll和select同样存在一个缺点就是,包含大量文件描述符的数组被整体复制于用户态和内核的地址空间之间,而不论这些文件描述符是否就绪,它的开销随着文件描述符数量的增加而线性增大。

2、poll函数

  函数格式如下所示:

# include <poll.h>
int poll ( struct pollfd * fds, unsigned int nfds, int timeout);

pollfd结构体定义如下:

struct pollfd {

int fd;         /* 文件描述符 */
short events;         /* 等待的事件 */
short revents;       /* 实际发生了的事件 */
} ; 

  每一个pollfd结构体指定了一个被监视的文件描述符,可以传递多个结构体,指示poll()监视多个文件描述符。每个结构体的events域是监视该文件描述符的事件掩码,由用户来设置这个域。revents域是文件描述符的操作结果事件掩码,内核在调用返回时设置这个域。events域中请求的任何事件都可能在revents域中返回。合法的事件如下:

  POLLIN         有数据可读。

  POLLRDNORM       有普通数据可读。

  POLLRDBAND      有优先数据可读。

  POLLPRI         有紧迫数据可读。

  POLLOUT            写数据不会导致阻塞。

  POLLWRNORM       写普通数据不会导致阻塞。

  POLLWRBAND        写优先数据不会导致阻塞。

  POLLMSGSIGPOLL     消息可用。

  此外,revents域中还可能返回下列事件:
  POLLER     指定的文件描述符发生错误。

  POLLHUP   指定的文件描述符挂起事件。

  POLLNVAL  指定的文件描述符非法。

这些事件在events域中无意义,因为它们在合适的时候总是会从revents中返回。

  使用poll()和select()不一样,你不需要显式地请求异常情况报告。
  POLLIN | POLLPRI等价于select()的读事件,POLLOUT |POLLWRBAND等价于select()的写事件。POLLIN等价于POLLRDNORM |POLLRDBAND,而POLLOUT则等价于POLLWRNORM。例如,要同时监视一个文件描述符是否可读和可写,我们可以设置 events为POLLIN |POLLOUT。在poll返回时,我们可以检查revents中的标志,对应于文件描述符请求的events结构体。如果POLLIN事件被设置,则文件描述符可以被读取而不阻塞。如果POLLOUT被设置,则文件描述符可以写入而不导致阻塞。这些标志并不是互斥的:它们可能被同时设置,表示这个文件描述符的读取和写入操作都会正常返回而不阻塞。

  timeout参数指定等待的毫秒数,无论I/O是否准备好,poll都会返回。timeout指定为负数值表示无限超时,使poll()一直挂起直到一个指定事件发生;timeout为0指示poll调用立即返回并列出准备好I/O的文件描述符,但并不等待其它的事件。这种情况下,poll()就像它的名字那样,一旦选举出来,立即返回。


  返回值和错误代码
  成功时,poll()返回结构体中revents域不为0的文件描述符个数;如果在超时前没有任何事件发生,poll()返回0;失败时,poll()返回-1,并设置errno为下列值之一:
  EBADF         一个或多个结构体中指定的文件描述符无效。

  EFAULTfds   指针指向的地址超出进程的地址空间。

  EINTR      请求的事件之前产生一个信号,调用可以重新发起。

  EINVALnfds  参数超出PLIMIT_NOFILE值。

  ENOMEM       可用内存不足,无法完成请求。

3、测出程序

  编写一个echo server程序,功能是客户端向服务器发送信息,服务器接收输出并原样发送回给客户端,客户端接收到输出到终端。

  服务器端程序如下:

复制代码
  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include <string.h>
  4 #include <errno.h>
  5 
  6 #include <netinet/in.h>
  7 #include <sys/socket.h>
  8 #include <poll.h>
  9 #include <unistd.h>
 10 #include <sys/types.h>
 11 
 12 #define IPADDRESS   "127.0.0.1"
 13 #define PORT        8787
 14 #define MAXLINE     1024
 15 #define LISTENQ     5
 16 #define OPEN_MAX    1000
 17 #define INFTIM      -1
 18 
 19 //函数声明
 20 //创建套接字并进行绑定
 21 static int socket_bind(const char* ip,int port);
 22 //IO多路复用poll
 23 static void do_poll(int listenfd);
 24 //处理多个连接
 25 static void handle_connection(struct pollfd *connfds,int num);
 26 
 27 int main(int argc,char *argv[])
 28 {
 29     int  listenfd,connfd,sockfd;
 30     struct sockaddr_in cliaddr;
 31     socklen_t cliaddrlen;
 32     listenfd = socket_bind(IPADDRESS,PORT);
 33     listen(listenfd,LISTENQ);
 34     do_poll(listenfd);
 35     return 0;
 36 }
 37 
 38 static int socket_bind(const char* ip,int port)
 39 {
 40     int  listenfd;
 41     struct sockaddr_in servaddr;
 42     listenfd = socket(AF_INET,SOCK_STREAM,0);
 43     if (listenfd == -1)
 44     {
 45         perror("socket error:");
 46         exit(1);
 47     }
 48     bzero(&servaddr,sizeof(servaddr));
 49     servaddr.sin_family = AF_INET;
 50     inet_pton(AF_INET,ip,&servaddr.sin_addr);
 51     servaddr.sin_port = htons(port);
 52     if (bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr)) == -1)
 53     {
 54         perror("bind error: ");
 55         exit(1);
 56     }
 57     return listenfd;
 58 }
 59 
 60 static void do_poll(int listenfd)
 61 {
 62     int  connfd,sockfd;
 63     struct sockaddr_in cliaddr;
 64     socklen_t cliaddrlen;
 65     struct pollfd clientfds[OPEN_MAX];
 66     int maxi;
 67     int i;
 68     int nready;
 69     //添加监听描述符
 70     clientfds[0].fd = listenfd;
 71     clientfds[0].events = POLLIN;
 72     //初始化客户连接描述符
 73     for (i = 1;i < OPEN_MAX;i++)
 74         clientfds[i].fd = -1;
 75     maxi = 0;
 76     //循环处理
 77     for ( ; ; )
 78     {
 79         //获取可用描述符的个数
 80         nready = poll(clientfds,maxi+1,INFTIM);
 81         if (nready == -1)
 82         {
 83             perror("poll error:");
 84             exit(1);
 85         }
 86         //测试监听描述符是否准备好
 87         if (clientfds[0].revents & POLLIN)
 88         {
 89             cliaddrlen = sizeof(cliaddr);
 90             //接受新的连接
 91             if ((connfd = accept(listenfd,(struct sockaddr*)&cliaddr,&cliaddrlen)) == -1)
 92             {
 93                 if (errno == EINTR)
 94                     continue;
 95                 else
 96                 {
 97                    perror("accept error:");
 98                    exit(1);
 99                 }
100             }
101             fprintf(stdout,"accept a new client: %s:%d\n", inet_ntoa(cliaddr.sin_addr),cliaddr.sin_port);
102             //将新的连接描述符添加到数组中
103             for (i = 1;i < OPEN_MAX;i++)
104             {
105                 if (clientfds[i].fd < 0)
106                 {
107                     clientfds[i].fd = connfd;
108                     break;
109                 }
110             }
111             if (i == OPEN_MAX)
112             {
113                 fprintf(stderr,"too many clients.\n");
114                 exit(1);
115             }
116             //将新的描述符添加到读描述符集合中
117             clientfds[i].events = POLLIN;
118             //记录客户连接套接字的个数
119             maxi = (i > maxi ? i : maxi);
120             if (--nready <= 0)
121                 continue;
122         }
123         //处理客户连接
124         handle_connection(clientfds,maxi);
125     }
126 }
127 
128 static void handle_connection(struct pollfd *connfds,int num)
129 {
130     int i,n;
131     char buf[MAXLINE];
132     memset(buf,0,MAXLINE);
133     for (i = 1;i <= num;i++)
134     {
135         if (connfds[i].fd < 0)
136             continue;
137         //测试客户描述符是否准备好
138         if (connfds[i].revents & POLLIN)
139         {
140             //接收客户端发送的信息
141             n = read(connfds[i].fd,buf,MAXLINE);
142             if (n == 0)
143             {
144                 close(connfds[i].fd);
145                 connfds[i].fd = -1;
146                 continue;
147             }
148            // printf("read msg is: ");
149             write(STDOUT_FILENO,buf,n);
150             //向客户端发送buf
151             write(connfds[i].fd,buf,n);
152         }
153     }
154 }
复制代码

客户端代码如下所示:

复制代码
 1 #include <netinet/in.h>
 2 #include <sys/socket.h>
 3 #include <stdio.h>
 4 #include <string.h>
 5 #include <stdlib.h>
 6 #include <poll.h>
 7 #include <time.h>
 8 #include <unistd.h>
 9 #include <sys/types.h>
10 
11 #define MAXLINE     1024
12 #define IPADDRESS   "127.0.0.1"
13 #define SERV_PORT   8787
14 
15 #define max(a,b) (a > b) ? a : b
16 
17 static void handle_connection(int sockfd);
18 
19 int main(int argc,char *argv[])
20 {
21     int                 sockfd;
22     struct sockaddr_in  servaddr;
23     sockfd = socket(AF_INET,SOCK_STREAM,0);
24     bzero(&servaddr,sizeof(servaddr));
25     servaddr.sin_family = AF_INET;
26     servaddr.sin_port = htons(SERV_PORT);
27     inet_pton(AF_INET,IPADDRESS,&servaddr.sin_addr);
28     connect(sockfd,(struct sockaddr*)&servaddr,sizeof(servaddr));
29     //处理连接描述符
30     handle_connection(sockfd);
31     return 0;
32 }
33 
34 static void handle_connection(int sockfd)
35 {
36     char    sendline[MAXLINE],recvline[MAXLINE];
37     int     maxfdp,stdineof;
38     struct pollfd pfds[2];
39     int n;
40     //添加连接描述符
41     pfds[0].fd = sockfd;
42     pfds[0].events = POLLIN;
43     //添加标准输入描述符
44     pfds[1].fd = STDIN_FILENO;
45     pfds[1].events = POLLIN;
46     for (; ;)
47     {
48         poll(pfds,2,-1);
49         if (pfds[0].revents & POLLIN)
50         {
51             n = read(sockfd,recvline,MAXLINE);
52             if (n == 0)
53             {
54                     fprintf(stderr,"client: server is closed.\n");
55                     close(sockfd);
56             }
57             write(STDOUT_FILENO,recvline,n);
58         }
59         //测试标准输入是否准备好
60         if (pfds[1].revents & POLLIN)
61         {
62             n = read(STDIN_FILENO,sendline,MAXLINE);
63             if (n  == 0)
64             {
65                 shutdown(sockfd,SHUT_WR);
66         continue;
67             }
68             write(sockfd,sendline,n);
69         }
70     }
71 }
复制代码

4、程序测试结果

5、参考资料

http://blog.endlesscode.com/2010/03/27/select-poll-epoll-intro/

http://hi.baidu.com/xzf20082004/item/622fb01a1018c7f5746a846f

 

 

===================================================================

https://book.itheima.net/course/223/1277519158031949826/1277529226395787267

黑马

poll机制的工作原理及流程与select类似,但poll可监控的进程数量不受select中第二个因素——fd_set集合容量的限制,用户可在程序中自行设置被监测的文件描述符集的容量,当然poll在阻塞模式下也采用轮询的方式监测文件描述符集,因此应合理设置poll中监控进程的数量。poll机制主要通过poll()函数实现,下面对poll()函数进行讲解。

poll()函数存在于函数库poll.h中,其声明如下:

int poll(struct pollfd *fds, nfds_t nfds, int timeout);

poll()函数中参数fds是一个struct pollfd类型的指针,主要用于传入被监测的多个文件描述符,其数据类型struct pollfd的定义如下:

struct pollfd{
  int fd;       //文件描述符
  short events;   //等待的事件
  short revents;   //实际发生的事件
}

该结构体中的成员fd表示文件描述符,当将fd设置为-1时,表示取消对该文件描述符的监测;成员events用于设置程序等待的事件,该值由用户主动设置;成员revents用于设置文件描述符的操作结果对应的事件,该值在函数返回时被设置。poll可能涉及的事件及其对应的宏如表1所示。

表1 poll事件相关宏及其说明

事件事件说明
POLLIN 文件描述符中有数据可读(包括普通数据或优先数据)
POLLRDNORM 文件描述符中有普通数据可读
POLLRDBAND 文件描述符中有优先数据可读
POLLPRI 文件描述符中高优先级数据可读
POLLOUT 文件描述符中有数据可写(包括普通数据或优先数据)
POLLWRNORM 文件描述符中可写入普通数据
POLLWRBAND 文件描述符中可写入优先数据
POLLERR 发生错误事件
POLLHUP 发生挂起事件
POLLNVAL 非法请求

poll()函数中的参数nfds等同于select()函数中的参数nfds,用来设置pollt监控的文件描述符的范围,需设置为文件描述符最大值加1;参数timeout与select()函数中的参数timeout,都用于设置组设时长,但其取值略有差异,poll()函数中参数timeout的取值及其对应含义如下:

● 当timeout=-1时,poll()函数阻塞等待;

● 当timeout=0时,poll()函数将立即返回,以轮询的方式监测文件描述符表;

● 当timeout>0时,等待指定时长(单位为毫秒,若当前系统时间精度不够毫秒则向上取值)。

poll()函数若调用成功将返回就绪文件描述符数量;若等待超时,将返回0,表示没有已就绪的文件描述符;若调用出错,将返回-1,并设置errno。

案例4:使用poll模型搭建多路I/O转接服务器,使服务器可接收客户端数据,并将接收到的数据转为大写,写回客户端;使客户端可向服务器发送数据,并将服务器返回的数据打印到终端。

案例实现如下:

poll_s.c //服务器

 1    #include <stdio.h>
 2    #include <stdlib.h>
 3    #include <string.h>
 4    #include <netinet/in.h>
 5    #include <arpa/inet.h>
 6    #include <poll.h>
 7    #include <errno.h>
 8    #include "wrap.h"
 9    #define MAXLINE 80
 10    #define SERV_PORT 8000
 11    #define OPEN_MAX 1024
 12    int main()
 13    {
 14        int i, j, maxi, listenfd, connfd, sockfd;
 15        int nready;
 16        ssize_t n;
 17        char buf[MAXLINE], str[INET_ADDRSTRLEN];
 18        socklen_t clilen;
 19        struct pollfd client[OPEN_MAX];        //文件描述符与事件集合
 20        struct sockaddr_in cliaddr, servaddr;
 21        listenfd = Socket(AF_INET, SOCK_STREAM, 0);
 22        bzero(&servaddr, sizeof(servaddr));
 23        servaddr.sin_family = AF_INET;
 24        servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
 25        servaddr.sin_port = htons(SERV_PORT);
 26        Bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
 27        Listen(listenfd, 20);
 28         //初始化poll()的参数fds
 29        client[0].fd = listenfd;
 30        client[0].events = POLLRDNORM;    //设置listenfd监听普通读事件
 31        for (i = 1; i < OPEN_MAX; i++)
 32            client[i].fd = -1;         //将client[]中其余元素的fd成员初始化为-1
 33        maxi = 0;                     //记录client[]数组有效元素中最大元素下标
 34        //使用poll()机制循环检测文件描述符集合
 35         for (;;) {
 36            nready = poll(client, maxi + 1, -1);    //阻塞等待请求到达
 37             //通过listenfd状态判断是否有客户端连接请求,如有则建立连接
 38            if (client[0].revents & POLLRDNORM) {
 39                clilen = sizeof(cliaddr);
 40                connfd = Accept(listenfd,(struct sockaddr *)&cliaddr,&clilen);
 41                printf("received from %s at PORT %d\n",
 42                    inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)),
 43                    ntohs(cliaddr.sin_port));
 44                 //将accept返回的connfd存放到client[]中的空闲位置
 45                for (i = 1; i < OPEN_MAX; i++){
 46                    if (client[i].fd < 0) {
 47                        client[i].fd = connfd;
 48                        break;
 49                    }
 50                 }
 51                if (i == OPEN_MAX)
 52                    perr_exit("too many clients");
 53                client[i].events = POLLRDNORM;     //设置刚刚返回的connfd,监控读事件
 54                if (i > maxi)                    //更新client[]中最大元素下标
 55                    maxi = i;
 56                if (--nready <= 0)                 //若无就绪事件,回到poll阻塞
 57                    continue;
 58            }
 59             //检测client[],处理有就绪事件的文件描述符
 60            for (i = 1; i <= maxi; i++){
 61                if ((sockfd = client[i].fd) < 0)
 62                    continue;
 63                if (client[i].revents & (POLLRDNORM | POLLERR)) {
 64                    if ((n = Read(sockfd, buf, MAXLINE)) < 0) {
 65                         //比较errno,若为RST则表示连接中断
 66                        if (errno == ECONNRESET){
 67                            printf("client[%d] aborted connection\n", i);
 68                            Close(sockfd);
 69                            client[i].fd = -1;
 70                        }
 71                        else
 72                            perr_exit("read error");
 73                    }
 74                    else if (n == 0) {//连接由客户端关闭
 75                        printf("client[%d] closed connection\n", i);
 76                        Close(sockfd);
 77                        client[i].fd = -1;
 78                    }
 79                    else {//若成功读取数据,则对数据进行操作
 80                        for (j = 0; j < n; j++)
 81                            buf[j] = toupper(buf[j]);
 82                        Writen(sockfd, buf, n);
 83                    }
 84                     //当就绪文件描述符数量为0时,终止循环
 85                    if (--nready <= 0)
 86                        break; 
 87                }
 88            }
 89        }
 90        return 0;
 91    }

poll_c.c //客户端

 30    #include <stdio.h>
 31    #include <string.h>
 32    #include <unistd.h>
 33    #include <netinet/in.h>
 34    #include "wrap.h"
 35    #define MAXLINE 80
 36    #define SERV_PORT 8000
 37    int main()
 38    {
 39        struct sockaddr_in servaddr;
 40        char buf[MAXLINE];
 41        int sockfd, n;
 42        sockfd = Socket(AF_INET, SOCK_STREAM, 0);
 43        bzero(&servaddr, sizeof(servaddr));
 44        servaddr.sin_family = AF_INET;
 45        inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);
 46        servaddr.sin_port = htons(SERV_PORT);
 47        Connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
 48        while (fgets(buf, MAXLINE, stdin) != NULL) {
 49            Write(sockfd, buf, strlen(buf));
 50            n = Read(sockfd, buf, MAXLINE);
 51            if (n == 0)
 52                printf("the other side has been closed.\n");
 53            else
 54                Write(STDOUT_FILENO, buf, n);
 55        }
 56        Close(sockfd);
 57        return 0;
 58    }

分别使用以下语句编译服务器端程序与客户端程序:

gcc poll_s.c wrap.c -o server
gcc poll_c.c wrap.c -o client

程序编译完成后,先执行服务器程序,打开服务器,之后在一个终端运行客户端程序(记为客户端1),并在该终端中输入客户端需要发送的数据,此时客户端与服务器端中打印的信息分别如下:

客户端1:

hello
HELLO

服务器端:

received from 127.0.0.1 at PORT 60315

打开新的终端,在该终端中再次运行客户端程序(记为客户端2),并输入要发送的数据,此时终端2与服务器端中打印的信息分别如下:

客户端2:

itheima
ITHEIMA

服务器端:

received from 127.0.0.1 at PORT 53187
received from 127.0.0.1 at PORT 53191

由程序执行结果可知,案例4实现成功。

 

 

参考:

来自:https://www.cnblogs.com/Anker/p/3261006.html

posted @ 2024-07-18 20:56  redrobot  阅读(3)  评论(0编辑  收藏  举报