UNIX网络编程——select函数的并发限制和 poll 函数应用举例

http://blog.csdn.net/chenxun_2010/article/details/50489577

一、用select实现的并发服务器，能达到的并发数，受两方面限制

       1、一个进程能打开的最大文件描述符限制。这可以通过调整内核参数。可以通过ulimit -n来调整或者使用setrlimit函数设置， 但一个系统所能打开的最大数也是有限的，跟内存大小有关，可以通过cat /proc/sys/fs/file-max 查看

       2、select中的fd_set集合容量的限制（FD_SETSIZE，一般为1024） ，这需要重新编译内核。

可以写个测试程序，只建立连接，看看最多能够建立多少个连接，客户端程序如下：

[cpp]  view plain  copy

1. #include <sys/types.h>  
2. #include <sys/socket.h>  
3. #include <netinet/in.h>  
4. #include <arpa/inet.h>  
5. #include <signal.h>  
6. #include <stdlib.h>  
7. #include <stdio.h>  
8. #include <errno.h>  
9. #include <string.h>  
10.   
11. #define ERR_EXIT(m) \  
12.         do \  
13.         { \  
14.                 perror(m); \  
15.                 exit(EXIT_FAILURE); \  
16.         } while(0)  
17.   
18.   
19. int main(void)  
20. {  
21.     int count = 0;  
22.     while(1)  
23.     {  
24.         int sock;  
25.         if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)  
26.         {  
27.             sleep(4);  
28.             ERR_EXIT("socket");  
29.         }  
30.   
31.         struct sockaddr_in servaddr;  
32.         memset(&servaddr, 0, sizeof(servaddr));  
33.         servaddr.sin_family = AF_INET;  
34.         servaddr.sin_port = htons(5188);  
35.         servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");  
36.   
37.         if (connect(sock, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)  
38.             ERR_EXIT("connect");  
39.   
40.         struct sockaddr_in localaddr;  
41.         socklen_t addrlen = sizeof(localaddr);  
42.         if (getsockname(sock, (struct sockaddr *)&localaddr, &addrlen) < 0)  
43.             ERR_EXIT("getsockname");  
44.   
45.         printf("ip=%s port=%d\n", inet_ntoa(localaddr.sin_addr), ntohs(localaddr.sin_port));  
46.         printf("count = %d\n", ++count);  
47.   
48.     }  
49.   
50.     return 0;  
51. }  

服务器的代码serv.c

[cpp]  view plain  copy

1. #include<stdio.h>  
2. #include<sys/types.h>  
3. #include<sys/socket.h>  
4. #include<unistd.h>  
5. #include<stdlib.h>  
6. #include<errno.h>  
7. #include<arpa/inet.h>  
8. #include<netinet/in.h>  
9. #include<string.h>  
10. #include<signal.h>  
11. #include<sys/wait.h>  
12.   
13.   
14.   
15. #define ERR_EXIT(m) \  
16.     do { \  
17.         perror(m); \  
18.         exit(EXIT_FAILURE); \  
19.     } while (0)  
20.   
21.   
22. int main(void)  
23. {  
24.       
25.     signal(SIGPIPE, SIG_IGN);  
26.     int listenfd; //被动套接字(文件描述符），即只可以accept, 监听套接字  
27.     if ((listenfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)  
28. //  listenfd = socket(AF_INET, SOCK_STREAM, 0)    
29.         ERR_EXIT("socket error");  
30.   
31.     struct sockaddr_in servaddr;  
32.     memset(&servaddr, 0, sizeof(servaddr));  
33.     servaddr.sin_family = AF_INET;  
34.     servaddr.sin_port = htons(5188);  
35.     servaddr.sin_addr.s_addr = htonl(INADDR_ANY);   
36.     /* servaddr.sin_addr.s_addr = inet_addr("127.0.0.1"); */  
37.     /* inet_aton("127.0.0.1", &servaddr.sin_addr); */  
38.       
39.     int on = 1;  
40.     if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)  
41.         ERR_EXIT("setsockopt error");  
42.   
43.     if (bind(listenfd, (struct sockaddr*)&servaddr,sizeof(servaddr)) < 0)  
44.         ERR_EXIT("bind error");  
45.   
46.     if (listen(listenfd, SOMAXCONN) < 0) //listen应在socket和bind之后，而在accept之前  
47.         ERR_EXIT("listen error");  
48.       
49.     struct sockaddr_in peeraddr; //传出参数  
50.     socklen_t peerlen = sizeof(peeraddr); //传入传出参数，必须有初始值  
51.       
52.     int conn; // 已连接套接字(变为主动套接字，即可以主动connect)  
53.     int i;  
54.     int client[FD_SETSIZE];  
55.     int maxi = 0; // client数组中最大不空闲位置的下标  
56.     for (i = 0; i < FD_SETSIZE; i++)  
57.         client[i] = -1;  
58.   
59.     int nready;  
60.     int maxfd = listenfd;  
61.     fd_set rset;  
62.     fd_set allset;  
63.     FD_ZERO(&rset);  
64.     FD_ZERO(&allset);  
65.     FD_SET(listenfd, &allset);  
66.   
67.     int count = 0;  
68.     while (1) {  
69.         rset = allset;  
70.         nready = select(maxfd + 1, &rset, NULL, NULL, NULL);  
71.         if (nready == -1) {  
72.             if (errno == EINTR)  
73.                 continue;  
74.             ERR_EXIT("select error");  
75.         }  
76.   
77.         if (nready == 0)  
78.             continue;  
79.   
80.         if (FD_ISSET(listenfd, &rset)) {  
81.           
82.             conn = accept(listenfd, (struct sockaddr*)&peeraddr, &peerlen);  //accept不再阻塞  
83.             if (conn == -1)  
84.                 ERR_EXIT("accept error");  
85.             printf("count = %d\n", ++count);  
86.             for (i = 0; i < FD_SETSIZE; i++) {  
87.                 if (client[i] < 0) {  
88.                     client[i] = conn;  
89.                     if (i > maxi)  
90.                         maxi = i;  
91.                     break;  
92.                 }   
93.             }  
94.               
95.             if (i == FD_SETSIZE) {  
96.                 fprintf(stderr, "too many clients\n");  
97.                 exit(EXIT_FAILURE);  
98.             }  
99.   
100.             printf("recv connect ip=%s port=%d\n", inet_ntoa(peeraddr.sin_addr),  
101.                 ntohs(peeraddr.sin_port));  
102.   
103.             FD_SET(conn, &allset);  
104.             if (conn > maxfd)  
105.                 maxfd = conn;  
106.   
107.             if (--nready <= 0)  
108.                 continue;  
109.         }  
110.   
111.         for (i = 0; i <= maxi; i++) {  
112.             conn = client[i];  
113.             if (conn == -1)  
114.                 continue;  
115.   
116.             if (FD_ISSET(conn, &rset)) {  
117.                   
118.                 char recvbuf[1024] = {0};  
119.                 int ret = read(conn, recvbuf, 1024);  
120.                 if (ret == -1)  
121.                     ERR_EXIT("read error");  
122.                 else if (ret  == 0) { //客户端关闭   
123.                     printf("client close \n");  
124.                     FD_CLR(conn, &allset);  
125.                     client[i] = -1;  
126.                     close(conn);  
127.                 }  
128.           
129.                 fputs(recvbuf, stdout);  
130.                 write(conn, recvbuf, strlen(recvbuf));  
131.                   
132.                 if (--nready <= 0)  
133.                     break;   
134.             }  
135.         }  
136.   
137.   
138.     }  
139.           
140.     return 0;  
141. }  
142.   
143. /* select所能承受的最大并发数受 
144.  * 1.一个进程所能打开的最大文件描述符数，可以通过ulimit -n来调整 
145.  *   但一个系统所能打开的最大数也是有限的，跟内存有关，可以通过cat /proc/sys/fs/file-max 查看 
146.  * 2.FD_SETSIZE(fd_set)的限制，这个需要重新编译内核                                                                           
147.  */  

huangcheng@ubuntu:~$ ./serv  
count = 1  
recv connect ip=127.0.0.1 port=48370  
count = 2  
recv connect ip=127.0.0.1 port=48371  
count = 3  
recv connect ip=127.0.0.1 port=48372  
count = 4  
recv connect ip=127.0.0.1 port=48373  
....................................  
recv connect ip=127.0.0.1 port=49389  
count = 1020  
recv connect ip=127.0.0.1 port=49390  

accept error: Too many open files  
[cpp] view plaincopyprint?
huangcheng@ubuntu:~$ ./cli  
ip=127.0.0.1 port=46327  
count = 1  
ip=127.0.0.1 port=46328  
count = 2  
ip=127.0.0.1 port=46329  
count = 3  
ip=127.0.0.1 port=46330  
count = 4  
ip=127.0.0.1 port=46331  
count = 5  
ip=127.0.0.1 port=46332  
count = 6  
ip=127.0.0.1 port=46333  
.......................  
ip=127.0.0.1 port=47345  
count = 1020  
ip=127.0.0.1 port=47346  
count = 1021  
socket: Too many open files  

输出太多条目，上面只截取最后几条，从中可以看出对于客户端，最多只能开启1021个连接套接字，因为总共是1024个，还得除去0、1、2。而服务器端只能accept 返回1020个已连接套接字，因为除了0、1、2之外还有一个监听套接字，客户端某一个套接字（不一定是最后一个）虽然已经建立了连接，在已完成连接队列中，但accept 返回时达到最大描述符限制，返回错误，打印提示信息。

       也许有人会注意到上面有一行 sleep(4)；当客户端调用socket准备创建第1022个套接字时，如上所示也会提示错误，此时socket函数返回-1出错，如果没有睡眠4s后再退出进程会有什么问题呢？如果直接退出进程，会将客户端所打开的所有套接字关闭掉，即向服务器端发送了很多FIN段，而此时也许服务器端还一直在accept ，即还在从已连接队列中返回已连接套接字，此时服务器端除了关心监听套接字的可读事件，也开始关心前面已建立连接的套接字的可读事件，read 返回0，所以会有很多 client close 字段 参杂在条目的输出中，还有个问题就是，因为read 返回0，服务器端会将自身的已连接套接字关闭掉，那么也许刚才说的客户端某一个连接会被accept 返回，即测试不出服务器端真正的并发容量。

1. huangcheng@ubuntu:~$ ./serv  
2. count = 1  
3. recv connect ip=127.0.0.1 port=50413  
4. count = 2  
5. ....................................  
6. client close  
7. client close  
8. client close  
9. client close  
10. ...................................  
11. recv connect ip=127.0.0.1 port=51433  
12. client close  
13. count = 1021  
14. recv connect ip=127.0.0.1 port=51364  
15. client close  
16. client close  

      可以看到输出参杂着client close，且这次的count 达到了1021，原因就是服务器端前面已经有些套接字关闭了，所以accept 创建套接字不会出错，服务器进程也不会因为出错而退出，可以看到最后接收到的一个连接端口是51364，即不一定是客户端的最后一个连接。

二、poll 函数应用举例

[cpp]  view plain copy

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

参数1：结构体数组指针

[cpp]  view plain copy

1. struct pollfd {  
2.     int   fd;         /* file descriptor */  
3.     short events;     /* requested events */  
4.     short revents;    /* returned events */  
5. };  

结构体中的fd 即套接字描述符，events 即感兴趣的事件，如下图所示，revents 即返回的事件。

参数2：结构体数组的成员个数，即文件描述符个数。

参数3：即超时时间，若为-1，表示永不超时。

       poll 跟 select 还是很相似的，比较重要的区别在于poll 所能并发的个数跟FD_SETSIZE无关，只跟一个进程所能打开的文件描述符个数有关，可以在select 程序的基础上修改成poll 程序，在运行服务器端程序之前，使用ulimit -n 2048 将限制改成2048个，注意在运行客户端进程的终端也需更改，因为客户端也会有所限制，这只是临时性的更改，因为子进程会继承这个环境参数，而我们是在bash命令行启动程序的，故在进程运行期间，文件描述符的限制为2048个。

使用poll 函数的服务器端程序如下：

[cpp]  view plain  copy

1. #include<stdio.h>  
2. #include<sys/types.h>  
3. #include<sys/socket.h>  
4. #include<unistd.h>  
5. #include<stdlib.h>  
6. #include<errno.h>  
7. #include<arpa/inet.h>  
8. #include<netinet/in.h>  
9. #include<string.h>  
10. #include<signal.h>  
11. #include<sys/wait.h>  
12. #include<poll.h>  
13.   
14. #define ERR_EXIT(m) \  
15.     do { \  
16.         perror(m); \  
17.         exit(EXIT_FAILURE); \  
18.     } while (0)  
19.   
20.   
21. int main(void)  
22. {  
23.     int count = 0;  
24.     signal(SIGPIPE, SIG_IGN);  
25.     int listenfd; //被动套接字(文件描述符），即只可以accept, 监听套接字  
26.     if ((listenfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)  
27.         //  listenfd = socket(AF_INET, SOCK_STREAM, 0)  
28.         ERR_EXIT("socket error");  
29.   
30.     struct sockaddr_in servaddr;  
31.     memset(&servaddr, 0, sizeof(servaddr));  
32.     servaddr.sin_family = AF_INET;  
33.     servaddr.sin_port = htons(5188);  
34.     servaddr.sin_addr.s_addr = htonl(INADDR_ANY);  
35.     /* servaddr.sin_addr.s_addr = inet_addr("127.0.0.1"); */  
36.     /* inet_aton("127.0.0.1", &servaddr.sin_addr); */  
37.   
38.     int on = 1;  
39.     if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)  
40.         ERR_EXIT("setsockopt error");  
41.   
42.     if (bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)  
43.         ERR_EXIT("bind error");  
44.   
45.     if (listen(listenfd, SOMAXCONN) < 0) //listen应在socket和bind之后，而在accept之前  
46.         ERR_EXIT("listen error");  
47.   
48.     struct sockaddr_in peeraddr; //传出参数  
49.     socklen_t peerlen = sizeof(peeraddr); //传入传出参数，必须有初始值  
50.   
51.     int conn; // 已连接套接字(变为主动套接字，即可以主动connect)  
52.     int i;  
53.   
54.     struct pollfd client[2048];  
55.     int maxi = 0; //client[i]最大不空闲位置的下标  
56.   
57.     for (i = 0; i < 2048; i++)  
58.         client[i].fd = -1;  
59.   
60.     int nready;  
61.     client[0].fd = listenfd;  
62.     client[0].events = POLLIN;  
63.   
64.     while (1)  
65.     {  
66.         /* poll检测[0, maxi + 1) */  
67.         nready = poll(client, maxi + 1, -1);  
68.         if (nready == -1)  
69.         {  
70.             if (errno == EINTR)  
71.                 continue;  
72.             ERR_EXIT("poll error");  
73.         }  
74.   
75.         if (nready == 0)  
76.             continue;  
77.   
78.         if (client[0].revents & POLLIN)  
79.         {  
80.   
81.             conn = accept(listenfd, (struct sockaddr *)&peeraddr, &peerlen); //accept不再阻塞  
82.             if (conn == -1)  
83.                 ERR_EXIT("accept error");  
84.   
85.             for (i = 1; i < 2048; i++)  
86.             {  
87.                 if (client[i].fd < 0)  
88.                 {  
89.                     client[i].fd = conn;  
90.                     if (i > maxi)  
91.                         maxi = i;  
92.                     break;  
93.                 }  
94.             }  
95.   
96.             if (i == 2048)  
97.             {  
98.                 fprintf(stderr, "too many clients\n");  
99.                 exit(EXIT_FAILURE);  
100.             }  
101.   
102.             printf("count = %d\n", ++count);  
103.             printf("recv connect ip=%s port=%d\n", inet_ntoa(peeraddr.sin_addr),  
104.                    ntohs(peeraddr.sin_port));  
105.   
106.             client[i].events = POLLIN;  
107.   
108.             if (--nready <= 0)  
109.                 continue;  
110.         }  
111.   
112.         for (i = 1; i <= maxi; i++)  
113.         {  
114.             conn = client[i].fd;  
115.             if (conn == -1)  
116.                 continue;  
117.             if (client[i].revents & POLLIN)  
118.             {  
119.   
120.                 char recvbuf[1024] = {0};  
121.                 int ret = read(conn, recvbuf, 1024);  
122.                 if (ret == -1)  
123.                     ERR_EXIT("readline error");  
124.                 else if (ret  == 0)   //客户端关闭  
125.                 {  
126.                     printf("client  close \n");  
127.                     client[i].fd = -1;  
128.                     close(conn);  
129.                 }  
130.   
131.                 fputs(recvbuf, stdout);  
132.                 write(conn, recvbuf, strlen(recvbuf));  
133.   
134.                 if (--nready <= 0)  
135.                     break;  
136.             }  
137.         }  
138.   
139.   
140.     }  
141.   
142.     return 0;  
143. }  
144.   
145. /* poll 只受一个进程所能打开的最大文件描述符限制，这个可以使用ulimit -n调整 */  

参照前面对 select 函数 的解释不难理解上面的程序，就不再赘述了。来看一下输出：

[cpp]  view plain copy

1. root@ubuntu:/home/huangcheng# ulimit -n 2048  
2. root@ubuntu:/home/huangcheng# su - huangcheng  
3. huangcheng@ubuntu:~$ ulimit -n  
4. 2048  
5. huangcheng@ubuntu:~$ ./serv  
6. ...........................  
7. count = 2042  
8. recv connect ip=127.0.0.1 port=54499  
9. count = 2043  
10. recv connect ip=127.0.0.1 port=54500  
11. count = 2044  
12. recv connect ip=127.0.0.1 port=54501  
13. accept error: Too many open files  

[cpp]  view plain copy

1. root@ubuntu:/home/huangcheng# ulimit -n 2048  
2. root@ubuntu:/home/huangcheng# su - huangcheng  
3. huangcheng@ubuntu:~$ ulimit -n  
4. 2048  
5. huangcheng@ubuntu:~$./cli  
6. ..........................  
7. ip=127.0.0.1 port=54499  
8. count = 2043  
9. ip=127.0.0.1 port=54500  
10. count = 2044  
11. ip=127.0.0.1 port=54501  
12. count = 2045  
13. socket: Too many open files  

       可以看到现在最大的连接数已经是2045个了，虽然服务器端有某个连接没有accept 返回。即poll 比 select 能够承受更多的并发连接，只受一个进程所能打开的最大文件描述符个数限制。可以通过ulimit -n  修改，但一个系统所能打开的文件描述符个数也是有限的，这跟系统的内存大小有关系，所以说也不是可以无限地并 发，可以查看一下本机的容量：

[cpp]  view plain copy

1. huangcheng@ubuntu:~$ cat /proc/sys/fs/file-max  
2. 101598  

本机是虚拟机，内存2G，能够打开的文件描述符个数大约在10w个左右。