select的限制以及poll的使用

最新推荐文章于 2020-12-09 19:22:39 发布
最新推荐文章于 2020-12-09 19:22:39 发布
阅读量102 收藏
点赞数
文章标签： 操作系统 网络
原文链接：https://yq.aliyun.com/articles/647062
版权

1.先说select在多路IO中的限制：
1）linux中每个程序能够打开的最多文件描述符是有限制的。默认是1024.
可以通过ulimit -n进行查看和修改：

xcy@xcy-virtual-machine:~/test/sock10_poll$ ulimit -n
1024
xcy@xcy-virtual-machine:~/test/sock10_poll$ ulimit -n 2048  // n 这里进行修改
xcy@xcy-virtual-machine:~/test/sock10_poll$ ulimit -n
2048
xcy@xcy-virtual-machine:~/test/sock10_poll$

这就意味着我们的服务器进程最多能打开1024个文件描述符。（而且0 1 2 还已经被占用了）。
而且一般服务器还有一个监听套接字，所以当第1021个连接发起时就会失败（假定前面没有关闭）。
2）我们知道select的第2-4个参数是这个类型的fd_set。这里东西可以把它看成是数组。这个数组也是有边界的。
边界就是 FD_SETSIZE。
man select的部分截取：

NOTES
       An fd_set is a fixed size buffer.  Executing FD_CLR() or FD_SET()  with
       a value of fd that is negative or is equal to or larger than FD_SETSIZE
       will result in undefined behavior.  Moreover, POSIX requires fd to be a
       valid file descriptor.

这个数组最大就是FD_SETSIZE。超过这个数以后就会越界。
FD_SETSIZE定义在系统的头文件中（具体哪个文件我没找到），可以修改那个头文件，再重新编译内核。这样比较麻烦。
想要突破这个限制，就需要poll函数了。


2.poll函数
先看man手册（截取部分）：

SYNOPSIS
       #include <poll.h>
       int poll(struct pollfd *fds, nfds_t nfds, int timeout);
DESCRIPTION
       poll()  performs a similar task to select(2): it waits for one of a set
       of file descriptors to become ready to perform I/O.

也可以用来监测多个IO。但是不会被FD_SETSIZE限制。
参数：
fds：一般是一个struct pollfd类型的数组，
nfds：要监视的描述符的数目。
timeout：超时时间，-1表示不会超时。0表示立即返回，不阻塞进程。 >0表示等待数目的毫秒数。
返回值：
-1：出错了，错误代码在errno中
0：设置了超时时间，这里表示超时了
>0：数组中fds准备好读、写、或异常的那些描述符的总数量
下面来看看struct pollfd这个结构体：

       struct pollfd {
               int   fd;         /* file descriptor */
               short events;     /* requested events  请求的事件，具体哪些值见下面 */
               short revents;    /* returned events  返回的事件，有点像传出参数。哪个事件发生了就存储在这里*/
           };
       //  events和revents的值可以是下面：
       The  bits that may be set/returned in events and revents are defined in
       <poll.h>:
              POLLIN There is data to read.  //可读
              POLLPRI  
                     There is urgent data to read (e.g., out-of-band  data  on
                     TCP socket; pseudoterminal master in packet mode has seen
                     state change in slave).
              POLLOUT  // 可写
                     Writing now will not block.
              POLLRDHUP (since Linux 2.6.17)
                     Stream socket peer closed connection, or shut down  writ‐
                     ing  half  of  connection.   The _GNU_SOURCE feature test
                     macro must be defined (before including any header files)
                     in order to obtain this definition.
              POLLERR  // 出错
                     Error condition (output only).
              POLLHUP
                     Hang up (output only).
              POLLNVAL
                     Invalid request: fd not open (output only).

 

 

3.实例：
先看server端：

#include<sys/types.h>
#include<sys/socket.h>
#include<sys/select.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<poll.h>
#include<stdlib.h>
#include<stdio.h>
#include<string.h>
#include<errno.h>

//#define CLIENTCOUNT FD_SETSIZE
#define CLIENTCOUNT 2048

int main(int argc, char **argv)
{
    int listenfd = socket(AF_INET, SOCK_STREAM, 0);
    if(listenfd < 0)
    {
        perror("socket");
        return -1;
    }
    
    unsigned short sport = 8080;
    if(argc == 2)
    {
        sport = atoi(argv[1]);
    }
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    printf("port = %d\n", sport);
    addr.sin_port = htons(sport);
    addr.sin_addr.s_addr = inet_addr("127.0.0.1");
    
    if(bind(listenfd, (struct sockaddr*)&addr, sizeof(addr)) < 0)
    {
        perror("bind");
        return -2;
    }

    if(listen(listenfd, 20) < 0)
    {
        perror("listen");
        return -3;
    }
    struct sockaddr_in connaddr;
    int len = sizeof(connaddr);
    
    int i = 0, ret = 0;
    struct pollfd client[CLIENTCOUNT];
    for(i = 0; i<CLIENTCOUNT; i++)
        client[i].fd = -1;

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

    int count = 0;
    int nready = 0;
    char buf[1024] = {0};
    while(1)
    {
        nready = poll(client, maxi+1, -1);
        if(nready == -1)
        {
            perror("select");
                        return -3;

        }
        if(nready == 0)
        {
            continue;
        }

        if(client[0].revents & POLLIN)
        {
            int conn = accept(listenfd, (struct sockaddr*)&connaddr, &len);
            if(conn < 0)
            {
                perror("accept");
                return -4;
            }
        
            char strip[64] = {0};
            char *ip = inet_ntoa(connaddr.sin_addr);
            strcpy(strip, ip);
            printf("client connect, conn:%d,ip:%s, port:%d, count:%d\n", conn, strip,ntohs(connaddr.sin_port), ++count);

            int i = 0;
            for(i = 0; i<CLIENTCOUNT; i++)
            {
                if(client[i].fd == -1)
                {
                    client[i].fd = conn;
                    client[i].events = POLLIN;
                    if(i > maxi)
                        maxi = i;
                    break;
                }
            }
            if(i == CLIENTCOUNT)
            {
                printf("to many client connect\n");
                exit(0);
            }      
            if(--nready <= 0)
                continue;
        }
        
        for(i = 0; i < CLIENTCOUNT; i++)
        {
            if(client[i].fd == -1)
                continue;
            if(client[i].revents & POLLIN)
            {
                ret = read(client[i].fd, buf, sizeof(buf));
                if(ret == -1)
                {
                    perror("read");
                    return -4;
                }
                else if(ret == 0)
                {
                    printf("client close remove:%d, count:%d\n", client[i], --count);
                    close(client[i].fd);
                    client[i].fd = -1;  // 要在这里移除
                }
                
                //printf("client%d:%s\n", client[i], buf);
                write(client[i], buf, sizeof(buf));
                memset(buf, 0, sizeof(buf));
                if(--nready <= 0)
                    continue;
            }
        }        
    }

    close(listenfd);
    return 0;
}

所有的client都存放在数组struct pollfd client[CLIENTCOUNT]中。每连接一个就加入到数组中。

关于这个server 的理解，可以参考这个的例子（这两个例子其实很像）：http://www.cnblogs.com/xcywt/p/8087677.html  

 

下面是client端：

#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<sys/select.h>
#include<stdlib.h>
#include<stdio.h>
#include<string.h>

/*
这里是暴力测试最多能连接几个。由于进程能打开的fd的限制最多的1024.
所以这里最多是1024 - 3. 也就是连接1022个的时候就出错了
（0  1  2 已经被占用了）

设置成2048就是另外一个结果了
*/
int main(int argc, char **argv)
{
    unsigned short sport = 8080;
    if(argc == 2)
    {
        sport = atoi(argv[1]);
    }
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    printf("port = %d\n", sport);
    addr.sin_port = htons(sport);
    addr.sin_addr.s_addr = inet_addr("127.0.0.1");
    
    int count = 0;
    while(1)
    {
        int sockfd = socket(AF_INET, SOCK_STREAM, 0);
        if(sockfd < 0)
        {
            perror("socket");
            sleep(5); // 这个是为了保证连接完成
            return -1;
        }
        if(connect(sockfd, (struct sockaddr*)&addr, sizeof(addr)) < 0)
        {
            perror("connect");
            return -2;
        }

        struct sockaddr_in addr2;
        socklen_t len = sizeof(addr2);
        if(getpeername(sockfd, (struct sockaddr*)&addr2, &len) < 0)
        {
            perror("getsockname");
            return -3;
        }

        printf("Server: port:%d, ip:%s, count:%d\n", ntohs(addr2.sin_port), inet_ntoa(addr2.sin_addr), ++count);
    }
    return 0;
}

client就是暴力连接，测试能连接的最大的数目：运行：
注意运行的终端需要将能打开的最大描述符设成2048，如果不改的话看不出效果。
结果（截取部分）：
server:（最多只能有2048 - 4个能连接上来，0 1 2 已经被占用，还有一个监听套接字）

......
client connect, conn:2040,ip:127.0.0.1, port:38220, count:2037
client connect, conn:2041,ip:127.0.0.1, port:38222, count:2038
client connect, conn:2042,ip:127.0.0.1, port:38224, count:2039
client connect, conn:2043,ip:127.0.0.1, port:38226, count:2040
client connect, conn:2044,ip:127.0.0.1, port:38228, count:2041
client connect, conn:2045,ip:127.0.0.1, port:38230, count:2042
client connect, conn:2046,ip:127.0.0.1, port:38232, count:2043
client connect, conn:2047,ip:127.0.0.1, port:38234, count:2044
accept: Too many open files
xcy@xcy-virtual-machine:~/test/sock10_poll$

client的（截取）：

......
Server: port:8080, ip:127.0.0.1, count:2036
Server: port:8080, ip:127.0.0.1, count:2037
Server: port:8080, ip:127.0.0.1, count:2038
Server: port:8080, ip:127.0.0.1, count:2039
Server: port:8080, ip:127.0.0.1, count:2040
Server: port:8080, ip:127.0.0.1, count:2041
Server: port:8080, ip:127.0.0.1, count:2042
Server: port:8080, ip:127.0.0.1, count:2043
Server: port:8080, ip:127.0.0.1, count:2044
Server: port:8080, ip:127.0.0.1, count:2045
socket: Too many open files
xcy@xcy-virtual-machine:~/test/sock10_poll$

可以看到已经超过了1024个了。

poll可以突破FD_SETSIZE的限制，但是还是无法突破进程能打开最大文件描述符的限制。

下面命令可以查看进程能打开的最大文件描述符限制（ulimit不能设置无限大），和计算机的内存有关：

cat /proc/sys/fs/file-max

 

5.关于上面client的sleep(5)的作用：

如果没有sleep(5)：那么client这边连接第2045的时候，进程会立即退出。就会关闭进程打开的套接字。TCP协议就会给server发送FIN段。从而server这边就会检测到有的client已经关闭了。所以server这边的count就可能会不准确了。因为有的已经关闭了，就可以再次打开。

如果加上sleep(5)：就可以保证前面2044个连接都发送过去了，只是第2045个连接会失败。但是server也只能接收2044个连接。保证在关闭之前没有client的fd被关闭。 

 

weixin_34185512
关注
使用poll()代替select()处理多客户连接的TCP服务器实例
whowin
03-04 252
在网络编程中，使用select()处理多客户端的连接是非常常用的方法，select()是一个非常古老的方法，在大量连接下会显得效率不高，而且其对描述符的数值还有一些限制，Linux内核从2.1.13版以后提供了poll()替代select()，本文介绍poll()在网络编程中的使用方法，并着重介绍poll()在编程行与select()的区别，旨在帮助熟悉select()编程的程序员可以很容易地使用poll()编程，本文提供了一个具体的实例，并附有完整的源代码，本文实例在 ubuntu20.04下编译测试通过
AttributeError: module 'select' has no attribute 'error'解决方法
肥宅Sean
02-12 1万+
gevent 实现多协程的时候，出现了上面的错误 错误的代码如下： import requests from gevent import monkey monkey.patch_all() import gevent def f(url): print('GET: %s' % url) data = requests.get(url).text print('%d by...
【网络】（十）select的限制与解决方法poll
CMbug的专栏
09-15 1136
在前面的《第七篇》和《第八篇》文章中已经使用select函数对服务器和客户端进行了重写，但这有个问题存在，如果有非常多的客户端需要连接到服务器，那很可能连接到1020个客户端时，服务端就会报错了，原因在于用select实现的并发服务器能够达到的并发数，受两方面限制 一个进程能打开的最大文件描述符限制，这可通过调整内核参数修改！ select中的fd_set集合容量的限制（FD_SETSIZE）,它不
select 和 poll基本用法
qiaoyifan的博客
08-21 1122
select函数和poll函数
关于 AttributeError: module ‘select‘ has no attribute ‘epoll‘
易编橙 · 终身成长社群，相遇已是上上签！
04-26 9142
关于 AttributeError: module ‘select’ has no attribute 'epoll’ 关于该报错的情景先说一下，我是在Win环境下，导入的 ‘select’ 包 import select 然后在 主函数 中创建的 epoll 对象 epl = select.epoll() 在运行的时候 报错 内容如下： AttributeError: module ...
socket网络编程python_python学习笔记——socket网络编程（1）
weixin_39836876的博客
12-09 158
假设我们已经有了客户/服务器，套接字和网络方面的基础，我们把这些概念带到python中来，我们用python中的socket模块来实现网络通信。一，socket()模块函数我们用socket()函数来创建套接字。Socket(socket_family, socket_type,protocol=0)套接字家族可以使AF_UNIX或者AF_INET，套接字类型可以根据是面向连接的还是非连接分为SO...
select详解及其限制
pearlsum的专栏
04-17 3057
前言：笔者前几天参加面试，被问到select函数的限制，然后感觉一头雾水，回来之后赶紧查找了资料弥补知识短板，也意识到以后使用一些系统调用应该多想些为什么，结合现实去思考实际中会遇到的问题。 下面是对selecth函数的一些总结： select是网络IO模型中的IO复用(在之前笔者还以为select属于异步io)，了解select之前大家可以先了解下IO模型，下面两篇文章讲的很不错： 网络I
select poll epoll
07-30
在IT行业中，网络编程是至关重要的一环，尤其是在服务器开发领域。...提供的压缩包文件中的`select`、`poll`及`epoll`示例代码可以帮助你更深入地理解和掌握这些技术，通过实践来学习它们的使用方法和性能差异。
Select和POLL使用方法(高级字符设备驱动)[参考].pdf
10-12
此外，`poll`没有`select`的文件描述符限制，适用于大量文件描述符的场景。但相比`select`，`poll`的调用开销稍大，因为每次调用都需要遍历整个`poll_table`。 总结来说，`select`和`poll`都是用于实现I/O多路复用...
多路并发情况下的CS模型实例 select poll epoll
最新发布
05-24
为了高效地管理这些并发连接，程序员经常使用I/O复用技术，其中"select"、"poll"和"epoll"是三种常见的机制。本文将深入探讨这三种方法，并通过实例分析它们的工作原理及其优缺点。 首先，`select`函数是最早被引入...
理解select，poll，epoll实现分析
aodaidi6752的博客
06-15 145
mark 引用:http://janfan.cn/chinese/2015/01/05/select-poll-impl-inside-the-kernel.html文章 select()/poll() 的内核实现 05 Jan 2015 同时对多个文件设备进行I/O事件监听的时候（I/O multiplexing），我们经常会用到系统调用函数select()poll...
select在并发中的两点限制与poll函数的使用
一直在路上
05-13 1247
用select实现的并发服务器，能达到的并发数，受两方面限制 一个进程能打开的最大文件描述符限制。这可以通过调整内核参数。 select中的fd_set集合容量的限制（FD_SETSIZE） ，这需要重新编译内核。
select、poll、epoll使用小结
kkxgx的专栏
07-05 1万+
Linux上可以使用不同的I/O模型，我们可以通过下图了解常用的I/O模型：同步和异步模型，以及阻塞和非阻塞模型，本文主要分析其中的异步阻塞模型。 一、select使用 这个模型中配置的是非阻塞I/O,然后使用阻塞select系统调用来确定一个I/O描述符何时有操作。使用select调用可以为多个描述符提供通知，对于每个提示符，我们可以请求描述符的可写，可读以及是否发生错误。异步阻塞I
Python异常处理：NameError: name ' ' is not defined，名称错误，名称“ ”未定义
热门推荐
qq_40916793的博客
08-09 13万+
代码段一： """ Author: yeahthon Date : 2019-08-09 12:28:47 E-mail: yeahthon@163.com """ class AnonymousSurvey(): """收集匿名调查问卷的答案""" def __init__(self, question): """储存一个问题，并为储存答案做准备"...
I/O多路转接之poll
weixin_34199335的博客
05-28 62
不同与select使用三个位图来表示三个fdset的方式，poll使用一个 pollfd的指针实现。pollfd结构包含了要监视的event和发生的event，不再使用select“参数-值”传递的方式。同时，pollfd并没有最大数量限制（但是数量过大后性能也是会下降）。 和select函数一样，poll返回后，需要轮询pollfd来获取就绪的描述符。从上面看，selec...
Linux IO复用：select、poll与epoll全面对比分析
- poll解决了select的文件描述符数量限制，但仍有遍历检查的开销。 - epoll是最高效的机制，适合大规模并发，采用“事件驱动”模式，减少了不必要的系统调用。 在选择I/O多路复用机制时，应考虑系统的具体需求和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值