Socket编程实践(10) --select的限制与poll的使用

最新推荐文章于 2022-08-30 15:58:59 发布
最新推荐文章于 2022-08-30 15:58:59 发布
阅读量3.7k 收藏 2
点赞数 2
分类专栏： Linux环境编程 Linux 环境编程深入 文章标签： select poll 限制 Socket套接字
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zjf280441589/article/details/44262751
版权

select的限制

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

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

/**示例: getrlimit/setrlimit获取/设置进程打开文件数目**/
int main()
{
    struct rlimit rl;
    if (getrlimit(RLIMIT_NOFILE, &rl) == -1)
        err_exit("getrlimit error");
    cout << "Soft limit: " << rl.rlim_cur << endl;
    cout << "Hard limit: " << rl.rlim_max << endl;
    cout << "------------------------->"  << endl;

    rl.rlim_cur = 2048;
    rl.rlim_max = 2048;
    if (setrlimit(RLIMIT_NOFILE, &rl) == -1)
        err_exit("setrlimit error");

    if (getrlimit(RLIMIT_NOFILE, &rl) == -1)
        err_exit("getrlimit error");
    cout << "Soft limit: " << rl.rlim_cur << endl;
    cout << "Hard limit: " << rl.rlim_max << endl;
}

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

/**测试: 测试服务器端最多能够建立多少个连接
server端完整源代码如下(注意使用的是<Socket编程实践(7)中的TCPServer类实现>):
**/
int main()
{
    signal(SIGPIPE, sigHandlerForSigPipe);
    try
    {
        TCPServer server(8001);
        int listenfd = server.getfd();

        struct sockaddr_in clientAddr;
        socklen_t addrLen;
        int maxfd = listenfd;
        fd_set rset;
        fd_set allset;
        FD_ZERO(&rset);
        FD_ZERO(&allset);
        FD_SET(listenfd, &allset);

        //用于保存已连接的客户端套接字
        int client[FD_SETSIZE];
        for (int i = 0; i < FD_SETSIZE; ++i)
            client[i] = -1;
        int maxi = 0;   //用于保存最大的不空闲的位置, 用于select返回之后遍历数组

        int count = 0;
        while (true)
        {
            rset = allset;
            int nReady = select(maxfd+1, &rset, NULL, NULL, NULL);
            if (nReady == -1)
            {
                if (errno == EINTR)
                    continue;
                err_exit("select error");
            }

            if (FD_ISSET(listenfd, &rset))
            {
                addrLen = sizeof(clientAddr);
                int connfd = accept(listenfd, (struct sockaddr *)&clientAddr, &addrLen);
                if (connfd == -1)
                    err_exit("accept error");

                int i;
                for (i = 0; i < FD_SETSIZE; ++i)
                {
                    if (client[i] < 0)
                    {
                        client[i] = connfd;
                        if (i > maxi)
                            maxi = i;
                        break;
                    }
                }
                if (i == FD_SETSIZE)
                {
                    cerr << "too many clients" << endl;
                    exit(EXIT_FAILURE);
                }
                //打印客户IP地址与端口号
                cout << "Client information: " << inet_ntoa(clientAddr.sin_addr)
                     << ", " << ntohs(clientAddr.sin_port) << endl;
                cout << "count = " << ++count << endl;
                //将连接套接口放入allset, 并更新maxfd
                FD_SET(connfd, &allset);
                if (connfd > maxfd)
                    maxfd = connfd;

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

            /**如果是已连接套接口发生了可读事件**/
            for (int i = 0; i <= maxi; ++i)
                if ((client[i] != -1) && FD_ISSET(client[i], &rset))
                {
                    char buf[512] = {0};
                    int readBytes = readline(client[i], buf, sizeof(buf));
                    if (readBytes == -1)
                        err_exit("readline error");
                    else if (readBytes == 0)
                    {
                        cerr << "client connect closed..." << endl;
                        FD_CLR(client[i], &allset);
                        close(client[i]);
                        client[i] = -1;
                    }
                    cout << buf;
                    if (writen(client[i], buf, readBytes) == -1)
                        err_exit("writen error");

                    if (--nReady <= 0)
                        break;
                }
        }
    }
    catch (const SocketException &e)
    {
        cerr << e.what() << endl;
        err_exit("TCPServer error");
    }
}

/**高并发测试端代码: contest完整源代码如下**/
int main()
{
    //最好不要修改: 不然会产生段溢出(stack-overflow)
//    struct rlimit rlim;
//    rlim.rlim_cur = 2048;
//    rlim.rlim_max = 2048;
//    if (setrlimit(RLIMIT_NOFILE, &rlim) == -1)
//        err_exit("setrlimit error");

    int count = 0;
    while (true)
    {
        int sockfd = socket(AF_INET, SOCK_STREAM, 0);
        if (sockfd == -1)
        {
            sleep(5);
            err_exit("socket error");
        }

        struct sockaddr_in serverAddr;
        serverAddr.sin_family = AF_INET;
        serverAddr.sin_port = htons(8001);
        serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
        int ret = connect_timeout(sockfd, &serverAddr, 5);
        if (ret == -1 && errno == ETIMEDOUT)
        {
            cerr << "timeout..." << endl;
            err_exit("connect_timeout error");
        }
        else if (ret == -1)
            err_exit("connect_timeout error");

        //获取并打印对端信息
        struct sockaddr_in peerAddr;
        socklen_t peerLen = sizeof(peerAddr);
        if (getpeername(sockfd, (struct sockaddr *)&peerAddr, &peerLen) == -1)
            err_exit("getpeername");
        cout << "Server information: " << inet_ntoa(peerAddr.sin_addr)
             << ", " << ntohs(peerAddr.sin_port) << endl;
        cout << "count = " << ++count << endl;
    }
}

Server端运行截图如图所示:


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

 

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

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

 

poll调用

poll没有select第二个限制, 即FD_SETSIZE的限制, 但是第一个限制暂时还是无法避免的;

#include <poll.h>
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，表示永不超时。

//pollfd结构体
struct pollfd
{
    int   fd;         /* file descriptor */
    short events;     /* requested events: 请求的事件 */
    short revents;    /* returned events :  返回的事件*/
};

events与revents取值(前3个最常用):


返回值:

   成功: 返回一个正整数(this is the number of  structures  which  have nonzero  revents  

fields  (in  other  words,  those  descriptors  with  events  or errors reported).  

   超时:  返回0(A value of 0 indicates that the call timed out and no file  descriptors  

were ready)  

   失败: 返回-1(On error, -1 is returned, and errno is set appropriately.)

/**poll-Server示例(将前面的select-server改造如下, 其没有了FD_SETSIZE的限制, 关于第一个限制可以使用前文中的方法更改)(client端与测试端代码如前)**/
const int SETSIZE = 2048;
int main()
{
    signal(SIGPIPE, sigHandlerForSigPipe);
    try
    {
        TCPServer server(8001);
        //用于保存已连接的客户端套接字
        struct pollfd client[SETSIZE];
        //将client置空
        for (int i = 0; i < SETSIZE; ++i)
            client[i].fd = -1;
        int maxi = 0;   //用于保存最大的已占用位置
        int count = 0;
        client[0].fd = server.getfd();
        client[0].events = POLLIN;
        while (true)
        {
            int nReady = poll(client, maxi+1, -1);
            if (nReady == -1)
            {
                if (errno == EINTR)
                    continue;
                err_exit("poll error");
            }

            //如果是监听套接口发生了可读事件
            if (client[0].revents & POLLIN)
            {
                int connfd = accept(server.getfd(), NULL, NULL);
                if (connfd == -1)
                    err_exit("accept error");

                bool flags = false;
                //略过client[0].fd(listenfd), 从1开始检测
                for (int i = 1; i < SETSIZE; ++i)
                {
                    if (client[i].fd == -1)
                    {
                        client[i].fd = connfd;
                        client[i].events = POLLIN;
                        flags = true;
                        if (i > maxi)
                            maxi = i;
                        break;
                    }
                }
                //未找到一个合适的位置
                if (!flags)
                {
                    cerr << "too many clients" << endl;
                    exit(EXIT_FAILURE);
                }
                cout << "count = " << ++count << endl;
                if (--nReady <= 0)
                    continue;
            }

            /**如果是已连接套接口发生了可读事件**/
            for (int i = 1; i <= maxi; ++i)
                if (client[i].revents & POLLIN)
                {
                    char buf[512] = {0};
                    int readBytes = readline(client[i].fd, buf, sizeof(buf));
                    if (readBytes == -1)
                        err_exit("readline error");
                    else if (readBytes == 0)
                    {
                        cerr << "client connect closed..." << endl;
                        close(client[i].fd);
                        client[i].fd = -1;
                    }
                    cout << buf;
                    if (writen(client[i].fd, buf, readBytes) == -1)
                        err_exit("writen error");
                    if (--nReady <= 0)
                        break;
                }
        }
    }
    catch (const SocketException &e)
    {
        cerr << e.what() << endl;
        err_exit("TCPServer error");
    }
}

附-getrlimit和setrlimit函数

每个进程都有一组资源限制，其中某一些可以用getrlimit和setrlimit函数查询和更改。

#include <sys/time.h>
#include <sys/resource.h>
int getrlimit(int resource, struct rlimit *rlim);
int setrlimit(int resource, const struct rlimit *rlim);
//rlimit结构体
struct rlimit
{
    rlim_t rlim_cur;  /* Soft limit */
    rlim_t rlim_max;  /* Hard limit (ceiling for rlim_cur) */
};

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

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

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.只有超级用户可以提高硬限制。

绯青
关注
专栏目录
（P17）socket编程（十二）：select限制，poll
喜欢打篮球的普通人
06-16 396
文章目录1.select限制2.poll：与select差不多 1.select限制 命令： ulimit -n 2048，进程打开的文件描述符的数量 编程： 头文件中定义的 而且需要重新编译内核 客户端没有sleep 服务端 客户端 客户端加了sleep 服务端： 客户端： 客户端 0 1 2已经被标准输入，标准输出，标准错误输出所占用 1021个连接 创建第1022个套接字的时候失败了，客户端sleep(4)，就不会发送FIN段给对方了 服务端 收到这1021个连接，会在已完成连接队列中维护
socket.select各操作系统限制实测
一线灵的博客
01-07 323
测试用例：预先创建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。
PHP查询结果限制条数
博客
05-05 1307
1 传统 LIMIT 初始位置,记录数 查询 SELECT * FROM user OREDER BY ID LIMIT 100,10 2 配合 WHERE 查询 SELECT * FROM user WHERE ID > 100 ORDER BY ID LIMIT 10 -- 这里ID为自增主键(int型)
errno错误码及含义(中文)
origin_lee的专栏
12-30 6349
/usr/include/asm/errno.h 0 为 success         #defineEPERM 1 /* Operation not permitted */操作不允许 　　#define ENOENT 2 /* Nosuch file or directory */文件/路径不存在 　　#define ESRCH 3 /* Nosuch process */进程不存在
C/C++ 学习代码实例 - socket编程代码（包括阻塞式、非阻塞式：select/epoll模式）
最新发布
06-05
本资料包“C/C++ 学习代码实例 - socket编程代码（包括阻塞式、非阻塞式：select/epoll模式）”提供了一些关键知识点，帮助开发者深入了解 socket 编程。 首先，我们来讨论 socket 编程。Socket 是网络通信的基本...
【Socket编程】--TCP异步通讯一服务器多客户端
11-21
- IO多路复用（如select、poll、epoll）：允许一个进程监控多个文件描述符，当它们就绪时执行相应的操作。 - 信号驱动I/O（SIGIO）：通过注册信号处理器，当套接字准备好读写时，操作系统发送信号通知程序。 - 非...
hp-socket-dev
03-17
"hp-socket-dev"是一个与HP（Hewlett-Packard）相关的网络库资源，主要涉及的是Socket编程。在IT行业中，Socket编程是网络通信的基础，它允许不同计算机间的进程通过网络进行通信。在这个资源包中，我们可以期待找到...
Socket-send-and-recv-.rar_c socket send recv_socket
09-21
异步I/O可以通过设置套接字选项（如SOCK_NONBLOCK）或使用select/poll/epoll等机制实现。 8. **错误处理**：在使用send和recv时，可能出现各种错误，如EINTR（被信号中断）、EAGAIN或EWOULDBLOCK（资源暂时不可用，...
socket网络编程--有详细的描述及源代码演示
12-27
在IT领域，网络编程是构建分布式系统和网络应用的基础，而Socket编程是网络通信的核心技术之一。本资源包提供了一套全面的教程，旨在帮助初学者深入理解和掌握Socket网络编程，包括理论基础和实践示例。 首先，...
TCP/IP异步通讯服务端实现方法
一个不甘寂寞的编程之路
08-18 3013
近期做了个TCP/IP异步通讯服务端实现方法，也是在网上胡乱搜索，然找了个自认为比较好的，然后封装一下，供后面自个使用，也供大家参考，如有不好的地方，欢迎指正，谢谢！ 下面说一下这个方法里面的几个知识点： 1、托管 这个东西真心好用，虽然不知道具体怎么弄的，托管可以实现一个对象中的方法交由其他对象实现，而且可以同时触发多个方法，组件的触发函数就是由托管实现的，具体实现如下： 先声明一个托管
判断Socket是否断开
ad13adsa的博客
01-17 488
/// <summary> /// 接收数据 /// </summary> private void OnReceive(object ob) { var key = ClientSocket.LocalEndPoint as IPEndPoint; ...
十、网络编程之 poll 详解.md
木牛的博客
08-30 836
poll 是 Linux 中的字符设备驱动中的一个函数。poll 和 select 的实现机制类似，本质上没有多大差别，也是管理多个套接字文件描述符，也是由内核进行轮询并根据描述符的状态进行处理，详细代码示例参考 GitHub 开源代码 “IO Multiplexin\poll"部分，，勉强算是select()函数的升级版。...
Socket.Poll()
qq_52719788的博客
02-25 1444
public bool Poll ( int microSeconds, SelectMode mode ) MSDN: Poll 方法将会检查 Socket 的状态。指定 selectMode 参数的 SelectMode.SelectRead，可确定 Socket 是否为可读。指定 SelectMode.SelectWrite，可确定 Socket 是否为可写。使用 SelectMode.SelectError 检测错误条件。Poll
Linux 设备驱动学习笔记 - 高级字符驱动操作篇 - Note.5[ poll 和 select \异步通知]
qq_39209508的博客
12-10 423
Linux 设备驱动学习笔记 - 高级字符驱动操作篇 - Note.5[ poll 和 select \异步通知]
poll和select的使用和差异
06-25 867
使用非阻塞I/O 的应用程序常常使用poll, select。poll和select本质上有相同的功能：每个允许一个进程来决定它是否可读或者写一个或多个文件而不阻塞。这些调用也可阻塞进程直到任何一个给定集合的文件描述符可用来读或写。因此，它们常常用在必须使用多输入输出流的应用程序，而不必粘连在它们任何一个上. 相同的功能常常由多个函数提供，因为2 个是由不同的团队在几乎相同时间完成的：select
阻塞socket上read/write出现errno为EAGAIN的原因解密
热门推荐
cleanfield的专栏
12-01 3万+
对EAGAIN的一次重新认识，blocking的socket读写也会有EAGAIN
linux poll操作read write操作使用
宁静致远的博客
12-28 2999
/* poll 阻塞的使用: poll就是对描述符进行监听,和select类似,但是poll没有最大描述符的限制,并且poll的描述符使用之后不会被清空,而select每次使用之后都要重新设置.不过他俩作用是一样的, 进行阻塞操作. 通过调用poll之后,内核可以告诉我们是否可以读写操作. pollfd结构体定义如下： struct pollfd {
TCP连接异常处理
Pobber的博客
10-04 5013
客户端正常终止 进程终止的部分工作是关闭所有打开的描述符,因此客户打开的描述符由内核关闭。这导致客户TCP发送一个FIN给服务器，服务器TCP则以ACK响应，这就是TCP连接终止序列的前半部分，至此，服务器套接字处于CLOSE_WAIT状态,客户套接字则处于FIN_WAIT_2状态 异常状态处理 accept被系统调用中断 我们用术语慢系统调用 (slow system call)描述过a...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值