Linux下的socket编程实践（九） Select的限制和poll（并发的初步知识）

select的限制

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

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

2)select中的fd_set集合容量的限制(FD_SETSIZE,一般为1024),这需要重新编译内核才能改变。

对于第一个限制：

[cpp]  view plain  copy

1. nclude <sys/time.h>  
2. #include <sys/resource.h>  
3.   
4. int getrlimit(int resource, struct rlimit *rlim);  
5. int setrlimit(int resource, const struct rlimit *rlim);  

其中，resource的一个取值  RLIMIT_NOFILE 代表指定比进程可打开的最大文件描述词大一的值，超出此值，将会产生EMFILE错误。

[cpp]  view plain  copy

1. rlim：描述资源软硬限制的结构体，原型如下  
2.   
3. struct rlimit {  
4.     rlim_t rlim_cur; /* Soft limit */  
5.     rlim_t rlim_max; /* Hard limit (ceiling for rlim_cur) */  
6. };  

返回说明：
成功执行时，返回0。失败返回-1，errno被设为以下的某个值
EFAULT：rlim指针指向的空间不可访问
EINVAL：参数无效
EPERM：增加资源限制值时，权能不允许

软限制是一个建议性的, 最好不要超越的限制, 如果超越的话, 系统可能向进程发送信号以终止其运行.

而硬限制一般是软限制的上限;

resource可用值
RLIMIT_AS	进程可用的最大虚拟内存空间长度,包括堆栈、全局变量、动态内存
RLIMIT_CORE	内核生成的core文件的最大大小
RLIMIT_CPU	所用的全部cpu时间,以秒计算
RLIMIT_DATA	进程数据段(初始化DATA段, 未初始化BSS段和堆)限制(以B为单位)
RLIMIT_FSIZE	文件大小限制
RLIMIT_SIGPENDING	用户能够挂起的信号数量限制
RLIMIT_NOFILE	打开文件的最大数目
RLIMIT_NPROC	用户能够创建的进程数限制
RLIMIT_STACK	进程栈内存限制, 超过会产生SIGSEGV信号

进程的资源限制通常是在系统初启时由0#进程建立的,在更改资源限制时，须遵循下列三条规则：

　　1.任何一个进程都可将一个软限制更改为小于或等于其硬限制。

　　2.任何一个进程都可降低其硬限制值，但它必须大于或等于其软限制值。这种降低，对普通用户而言是不可逆反的。

　　3.只有超级用户可以提高硬限制。

[cpp]  view plain  copy

1. /**示例: getrlimit/setrlimit获取/设置进程打开文件数目**/    
2. int main()    
3. {    
4.     struct rlimit rl;    
5.     if (getrlimit(RLIMIT_NOFILE, &rl) == -1)    
6.         err_exit("getrlimit error");    
7.     cout << "Soft limit: " << rl.rlim_cur << endl;    
8.     cout << "Hard limit: " << rl.rlim_max << endl;    
9.     cout << "------------------------->"  << endl;    
10.     
11.     rl.rlim_cur = 2048;    
12.     rl.rlim_max = 2048;    
13.     if (setrlimit(RLIMIT_NOFILE, &rl) == -1)    
14.         err_exit("setrlimit error");    
15.     
16.     if (getrlimit(RLIMIT_NOFILE, &rl) == -1)    
17.         err_exit("getrlimit error");    
18.     cout << "Soft limit: " << rl.rlim_cur << endl;    
19.     cout << "Hard limit: " << rl.rlim_max << endl;    
20. }    

测试最多可以建立多少个链接，下面是客户端的代码：

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

我们来看一下server端输出：

recv connect ip=127.0.0.1 port=57430
count = 2039
recv connect ip=127.0.0.1 port=57431
count = 2040
recv connect ip=127.0.0.1 port=57432
count = 2041
recv connect ip=127.0.0.1 port=57433
count = 2042
recv connect ip=127.0.0.1 port=57434
count = 2043
recv connect ip=127.0.0.1 port=57435
count = 2044
recv connect ip=127.0.0.1 port=57436
accept error: Too many open files

解析:对于客户端，最多只能开启1021个连接套接字，因为总共是在Linux中最多可以打开1024个文件描述如，其中还得除去0，1，2。而服务器端只能accept 返回1020个已连接套接字，因为除了0,1,2之外还有一个监听套接字listenfd，客户端某一个套接字（不一定是最后一个）虽然已经建立了连接，在已完成连接队列中，但accept返回时达到最大描述符限制，返回错误，打印提示信息。

 

client在socket()返回-1是调用sleep(4)解析

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

poll调用

poll没有select第二个限制, 即FD_SETSIZE的限制, 不用修改内核，但是第一个限制暂时还是无法避免的;

[cpp]  view plain  copy

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

 参数nfds: 需要检测事件的个数, 结构体数组大小(也可表示为文件描述符个数)(The caller should specify the number of items in the fds array in nfds.)

 参数timeout: 超时时间(单位milliseconds, 毫秒),若为-1，表示永不超时。

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

使用poll 函数的服务器端程序如下，和select大概用法差不多：

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

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