linux网络编程之socket（十二）：select函数的并发限制和 poll 函数应用举例

最新推荐文章于 2023-06-15 21:06:03 发布
最新推荐文章于 2023-06-15 21:06:03 发布
阅读量551 收藏
点赞数

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


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

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


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

 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h>

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

#define ERR_EXIT(m) \
         do \
        { \
                perror(m); \
                exit(EXIT_FAILURE); \
        }  while( 0)


int main( void)
{
     int count =  0;
     while( 1)
    {
         int sock;
         if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) <  0)
        {
            sleep( 4);
            ERR_EXIT( "socket");
        }

         struct sockaddr_in servaddr;
        memset(&servaddr,  0,  sizeof(servaddr));
        servaddr.sin_family = AF_INET;
        servaddr.sin_port = htons( 5188);
        servaddr.sin_addr.s_addr = inet_addr( "127.0.0.1");

         if (connect(sock, ( struct sockaddr *)&servaddr,  sizeof(servaddr)) <  0)
            ERR_EXIT( "connect");

         struct sockaddr_in localaddr;
        socklen_t addrlen =  sizeof(localaddr);
         if (getsockname(sock, ( struct sockaddr *)&localaddr, &addrlen) <  0)
            ERR_EXIT( "getsockname");

        printf( "ip=%s port=%d\n", inet_ntoa(localaddr.sin_addr), ntohs(localaddr.sin_port));
        printf( "count = %d\n", ++count);

    }

     return  0;
}

启动select 的服务器端程序，再启动客户端测试程序：

simba@ubuntu:~/Documents/code/linux_programming/UNP/socket$ ./echoser_select 

......................................................................

count = 1015
recv connect ip=127.0.0.1 port=51299
count = 1016
recv connect ip=127.0.0.1 port=51300
count = 1017
recv connect ip=127.0.0.1 port=51301
count = 1018
recv connect ip=127.0.0.1 port=51302
count = 1019
recv connect ip=127.0.0.1 port=51303
count = 1020
recv connect ip=127.0.0.1 port=51304
accept error: Too many open files


simba@ubuntu:~/Documents/code/linux_programming/UNP/socket$ ./conntest 

....................................................................................................

count = 1015
ip=127.0.0.1 port=51299
count = 1016
ip=127.0.0.1 port=51300
count = 1017
ip=127.0.0.1 port=51301
count = 1018
ip=127.0.0.1 port=51302
count = 1019
ip=127.0.0.1 port=51303
count = 1020
ip=127.0.0.1 port=51304
count = 1021
socket: Too many open files


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


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


将 sleep(4); 注释掉，观察服务器端的输出如下：

simba@ubuntu:~/Documents/code/linux_programming/UNP/socket$ ./echoser_select 

...........................................................

count = 1018
recv connect ip=127.0.0.1 port=52323
client close 
count = 1019
recv connect ip=127.0.0.1 port=52324
client close 
count = 1020
recv connect ip=127.0.0.1 port=52325
client close 
count = 1021
recv connect ip=127.0.0.1 port=52234
client close 
client close 


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


二、poll 函数应用举例

 #include <poll.h>

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

参数1：结构体数组指针，struct pollfd {

               int   fd;         /* file descriptor */
               short events;     /* requested events */
               short revents;    /* returned events */
           };

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


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

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


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

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

 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
/*************************************************************************
    > File Name: echoser.c
    > Author: Simba
    > Mail: dameng34@163.com
    > Created Time: Fri 01 Mar 2013 06:15:27 PM CST
 ************************************************************************/

#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<unistd.h>
#include<stdlib.h>
#include<errno.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<string.h>
#include<signal.h>
#include<sys/wait.h>
#include<poll.h>
#include  "read_write.h"

#define ERR_EXIT(m) \
     do { \
        perror(m); \
        exit(EXIT_FAILURE); \
    }  while ( 0)


int main( void)
{
     int count =  0;
    signal(SIGPIPE, SIG_IGN);
     int listenfd;  //被动套接字(文件描述符），即只可以accept, 监听套接字
     if ((listenfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) <  0)
         //  listenfd = socket(AF_INET, SOCK_STREAM, 0)
        ERR_EXIT( "socket error");

     struct sockaddr_in servaddr;
    memset(&servaddr,  0,  sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons( 5188);
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
     /* servaddr.sin_addr.s_addr = inet_addr("127.0.0.1"); */
     /* inet_aton("127.0.0.1", &servaddr.sin_addr); */

     int on =  1;
     if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on,  sizeof(on)) <  0)
        ERR_EXIT( "setsockopt error");

     if (bind(listenfd, ( struct sockaddr *)&servaddr,  sizeof(servaddr)) <  0)
        ERR_EXIT( "bind error");

     if (listen(listenfd, SOMAXCONN) <  0)  //listen应在socket和bind之后，而在accept之前
        ERR_EXIT( "listen error");

     struct sockaddr_in peeraddr;  //传出参数
    socklen_t peerlen =  sizeof(peeraddr);  //传入传出参数，必须有初始值
     int conn;  // 已连接套接字(变为主动套接字，即可以主动connect)
     int i;

     struct pollfd client[ 2048];
     int maxi =  0;  //client[i]最大不空闲位置的下标
     for (i =  0; i <  2048; i++)
        client[i].fd = - 1;

     int nready;
    client[ 0].fd = listenfd;
    client[ 0].events = POLLIN;

     while ( 1)
    {
         /* poll检测[0, maxi + 1) */
        nready = poll(client, maxi +  1, - 1);
         if (nready == - 1)
        {
             if (errno == EINTR)
                 continue;
            ERR_EXIT( "poll error");
        }

         if (nready ==  0)
             continue;

         if (client[ 0].revents & POLLIN)
        {

            conn = accept(listenfd, ( struct sockaddr *)&peeraddr, &peerlen);  //accept不再阻塞
             if (conn == - 1)
                ERR_EXIT( "accept error");

             for (i =  1; i <  2048; i++)
            {
                 if (client[i].fd <  0)
                {
                    client[i].fd = conn;
                     if (i > maxi)
                        maxi = i;
                     break;
                }
            }

             if (i ==  2048)
            {
                fprintf(stderr,  "too many clients\n");
                exit(EXIT_FAILURE);
            }

            printf( "count = %d\n", ++count);
            printf( "recv connect ip=%s port=%d\n", inet_ntoa(peeraddr.sin_addr),
                   ntohs(peeraddr.sin_port));

            client[i].events = POLLIN;

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

         for (i =  1; i <= maxi; i++)
        {
            conn = client[i].fd;
             if (conn == - 1)
                 continue;
             if (client[i].revents & POLLIN)
            {

                 char recvbuf[ 1024] = { 0};
                 int ret = readline(conn, recvbuf,  1024);
                 if (ret == - 1)
                    ERR_EXIT( "readline error");
                 else  if (ret  ==  0)    //客户端关闭
                {
                    printf( "client  close \n");
                    client[i].fd = - 1;
                    close(conn);
                }

                fputs(recvbuf, stdout);
                writen(conn, recvbuf, strlen(recvbuf));

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


    }

     return  0;
}

/* poll 只受一个进程所能打开的最大文件描述符限制，这个可以使用ulimit -n调整 */

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

simba@ubuntu:~/Documents/code/linux_programming/UNP/socket$ ulimit -n 2048

simba@ubuntu:~/Documents/code/linux_programming/UNP/socket$ ./echoser_select 

.............................................................................................

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


simba@ubuntu:~/Documents/code/linux_programming/UNP/socket$ ulimit -n 2048

simba@ubuntu:~/Documents/code/linux_programming/UNP/socket$ ./conntest

................................................................................

count = 2039
ip=127.0.0.1 port=57431
count = 2040
ip=127.0.0.1 port=57432
count = 2041
ip=127.0.0.1 port=57433
count = 2042
ip=127.0.0.1 port=57434
count = 2043
ip=127.0.0.1 port=57435
count = 2044
ip=127.0.0.1 port=57436
count = 2045
socket: Too many open files


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

simba@ubuntu:~/Documents/code/linux_programming/UNP/socket$ cat /proc/sys/fs/file-max 

101078

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


参考：

《Linux C 编程一站式学习》

《TCP/IP详解 卷一》

《UNP》
FishBear_move_on
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux网络编程，包括tcp/upd，select/poll/epoll/pdf
04-14
总之，Linux网络编程是一项重要的技能，它涉及到网络通信的基本原理以及多路复用技术的使用，对于开发网络应用程序来说是必不可少的技能。Linux网络编程是指在Linux操作系统上开发网络应用程序的过程。它主要涉及到...
九、网络编程之 select 详解
weixin_45004203的博客
06-29 1204
本文讨论 select 相关知识。
网络编程select，poll，epoll模型
qq_61667084的博客
05-13 122
本文资源全部来自于B站。
【网络】（十）select的限制与解决方法poll
CMbug的专栏
09-15 1063
在前面的《第七篇》和《第八篇》文章中已经使用select函数对服务器和客户端进行了重写，但这有个问题存在，如果有非常多的客户端需要连接到服务器，那很可能连接到1020个客户端时，服务端就会报错了，原因在于用select实现的并发服务器能够达到的并发数，受两方面限制 一个进程能打开的最大文件描述符限制，这可通过调整内核参数修改！ select中的fd_set集合容量的限制（FD_SETSIZE）,它不
[转载]高并发的socket的高性能设计
tecoes的博客
05-10 460
高性能数据传输系统的框架设计 1 引言 随着互联网和物联网的高速发展，使用网络的人数和电子设备的数量急剧增长，其也对互联网后台服务程序提出了更高的性能和并发要求。本文的主要目的是阐述在单机上如何进行高并发、高性能消息传输系统的框架设计，以及该系统的常用技术，但不对其技术细节进行讨论。如您有更好的设计方案和思路，望共分享之！[注：此篇用select来讲解，虽在大并发的情况下，epoll拥有更高的效率，但整体设计思路是一致的] 首先来看看课本和学习资料上关于处理并发网络编程的三...
linux网络编程中Select和poll服务程序
01-16
linux操作系统下通过Select和Poll两种模型实现的高并发的通信服务程序示例
Linux网络编程socket编程学习
05-09
自学Linux网络编程关于socket的编写，包括 server.c 和 client.c 的编写；很详细的介绍了网络套接字socket的C/S模型TCP协议的服务器端和客户端的程序函数以及编写过程；重点介绍多路I/O转接服务器的实现，包括select...
Unix网络编程 第6章 I/O服用： select和poll函数 第6章.tar.gz 对本章的代码简易的练习
01-09
I/O复用：select和poll函数 对本章的代码练习
Linux poll函数深入理解
01-09
poll函数与select函数差不多 　函数原型： #include <poll> int poll(struct pollfd fd[]， nfds_t nfds， int timeout); struct pollfd的结构如下： struct pollfd{ int fd； // 文件描述符 short event；//...
关于socket select的理解
weixin_37859743的博客
10-24 944
socket通信中select函数的使用和解释 博文转载于https://www.cnblogs.com/gangzilife/p/9766292.html，我觉得对于select的说明比较明白。 Select在Socket编程中还是比较重要的，可是对于初学Socket的人来说都不太爱用Select写程序，他们只 是习惯写诸如 connect、accept、recv或recvfrom这样的阻塞程序（所谓阻塞方式block，顾名思义，就 是进程或是线程执行到这些函数时必须等待某个事件的发生，如果事件没
（P17）socket编程（十二）：select限制，poll
喜欢打篮球的普通人
06-16 360
文章目录1.select限制2.poll：与select差不多 1.select限制 命令： ulimit -n 2048，进程打开的文件描述符的数量 编程： 头文件中定义的 而且需要重新编译内核 客户端没有sleep 服务端 客户端 客户端加了sleep 服务端： 客户端： 客户端 0 1 2已经被标准输入，标准输出，标准错误输出所占用 1021个连接 创建第1022个套接字的时候失败了，客户端sleep(4)，就不会发送FIN段给对方了 服务端 收到这1021个连接，会在已完成连接队列中维护
socket通信中select函数的使用和解释
二楼窗外的毛白杨
12-06 561
原文地址：http://blog.sina.com.cn/s/blog_608740170100wwub.html
socket.select各操作系统限制实测
一线灵的博客
01-07 274
测试用例：预先创建1024各socket，之后启动yasio的io_service服务，cmake配置yasio时打开详细日志输出：-DYASIO_VERBOSE_LOG=TRUE。windows： select可以正常工作，不受socket句柄值大小限制，说明限制的是FD_SET注册进文件描述符监听的数量而非文件描述符值。测试代码： https://github.com/yasio/yasio/blob/dev/tests/issue384/main.cpp。
ssh 登录时常出现的几种错误以及解决方法（Linux）
a746742897的博客
03-12 1万+
ssh 登录时常出现的几种错误以及解决方法（Linux） 参考网址：https://blog.csdn.net/GX_1_11_real/article/details/80423409 前言 ssh是Linux系统中常用的远程登陆的命令，有的时候我们通过xshell等远程连接软件使用ssh去登陆远程的服务器的时候，会遇到一些问题。 下面是关于ss...
select并发服务器实现
kakaka666的博客
07-31 706
select()函数监视多个文件描述符，等待所监视的一个或者多个文件描述符变为“准备好”的事件状态。”准备好“状态是指：文件描述符不再是阻塞状态，可以用于某类IO操作了，包括可读，可写，发生异常三种。......
select实现并发服务器
JiaYu的博客
06-15 1169
select函数是一个用于在一组文件描述符上进行异步I/O多路复用的系统调用。它可以同时监视多个文件描述符，等待其中任何一个文件描述符准备就绪，然后进行相应的操作。函数主要用于实现多路复用的I/O操作，它允许同时监视多个文件描述符，以避免使用阻塞式I/O时每个文件描述符都需要单独的线程。函数，可以有效地管理并发连接、处理I/O事件和提高系统性能。下面是一个用C语言编写的使用。
select实现延时函数
10-20 1081
select实现延时函数
【Tabby SSH远程终端连接失败】Remote rejected opening a shell channel: Error: (SSH) Channel open failure
热门推荐
Xminyang的博客
09-08 1万+
根本原因是 当前用户的SSH远程连接终端数量达到了上限，比如CentOS7限制SSH单用户登陆数为10。 迷惑行为：表明看起来已打开的SSH终端窗口不足上限啊，为啥还是不能新增SSH终端窗口呢？其原因在于有些SSH终端窗口未正常关闭，再加上正打开的SSH终端窗口，就达到了SSH远程连接终端的数量上限。 这些往往是由用户的不当操作引起的，比如直接强制关闭终端窗口，而非使用``exit``来正常退出当前窗口。这些异常被关闭的SSH连接往往在数个小时之后才结束（长时间没有数据传输）。
linux poll函数线程资源限制
最新发布
10-05
在Linux中，poll函数用于等待一个或多个文件描述符的I/O事件。与select和epoll相比，poll函数的不足之处在于效率较低，因为它需要遍历整个文件描述符集合。 在Linux中使用poll函数时，有一个线程资源的限制，即可以同时处理的线程数量有限。这是因为操作系统对每个进程或线程的资源分配是有一定限制的，包括线程栈大小、文件描述符数量、内存使用等等。 当使用poll函数时，每个线程都会占用一定的系统资源。如果创建过多的线程并同时调用poll函数，可能会导致系统资源不足的问题，比如资源耗尽、内存溢出等。因此，需要合理控制线程的数量，以避免资源限制的问题。 为了克服线程资源限制，可以采取以下几种方法： 1. 使用线程池：通过线程池管理线程，在需要使用poll函数的时候从线程池中获取一个线程，并在使用完后将其放回线程池中，避免创建过多的线程，从而降低系统资源的消耗。 2. 调整系统资源限制：通过修改系统配置文件或运行时参数，增加线程栈大小、文件描述符数量等资源限制值，从而扩大系统能够处理的线程数量。但是需要注意，调整这些系统资源限制可能会影响其他方面的性能。 3. 使用更高效的I/O模型：如果对响应时间有严格要求，并且在处理大量并发连接的情况下，考虑使用更高效的I/O模型，如epoll等，以提高系统的性能和资源利用率。 总之，在使用linux的poll函数时，需要注意线程资源的限制，合理控制线程数量，防止资源耗尽等问题的发生。通过合理的线程管理和配置系统资源限制，可以提高应用程序的性能和可扩展性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值