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

最新推荐文章于 2024-08-25 12:05:17 发布
最新推荐文章于 2024-08-25 12:05:17 发布
阅读量85 收藏
点赞数
文章标签： 运维
原文链接：http://www.cnblogs.com/wangfengju/p/6172506.html
版权

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


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

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


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

#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;
}

服务器的代码serv.c：来自<<UNIX网络编程——使用select函数编写客户端和服务器>>最后的服务器程序。

#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>



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


int main(void)
{
    
    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;
    int client[FD_SETSIZE];
    int maxi = 0; // client数组中最大不空闲位置的下标
    for (i = 0; i < FD_SETSIZE; i++)
        client[i] = -1;

    int nready;
    int maxfd = listenfd;
    fd_set rset;
    fd_set allset;
    FD_ZERO(&rset);
    FD_ZERO(&allset);
    FD_SET(listenfd, &allset);

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

        if (nready == 0)
            continue;

        if (FD_ISSET(listenfd, &rset)) {
        
            conn = accept(listenfd, (struct sockaddr*)&peeraddr, &peerlen);  //accept不再阻塞
            if (conn == -1)
                ERR_EXIT("accept error");
            printf("count = %d\n", ++count);
            for (i = 0; i < FD_SETSIZE; i++) {
                if (client[i] < 0) {
                    client[i] = conn;
                    if (i > maxi)
                        maxi = i;
                    break;
                } 
            }
            
            if (i == FD_SETSIZE) {
                fprintf(stderr, "too many clients\n");
                exit(EXIT_FAILURE);
            }

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

            FD_SET(conn, &allset);
            if (conn > maxfd)
                maxfd = conn;

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

        for (i = 0; i <= maxi; i++) {
            conn = client[i];
            if (conn == -1)
                continue;

            if (FD_ISSET(conn, &rset)) {
                
                char recvbuf[1024] = {0};
                int ret = read(conn, recvbuf, 1024);
                if (ret == -1)
                    ERR_EXIT("read error");
                else if (ret  == 0) { //客户端关闭 
                    printf("client close \n");
                    FD_CLR(conn, &allset);
                    client[i] = -1;
                    close(conn);
                }
        
                fputs(recvbuf, stdout);
                write(conn, recvbuf, strlen(recvbuf));
                
                if (--nready <= 0)
                    break; 
            }
        }


    }
        
    return 0;
}

/* select所能承受的最大并发数受
 * 1.一个进程所能打开的最大文件描述符数，可以通过ulimit -n来调整
 *   但一个系统所能打开的最大数也是有限的，跟内存有关，可以通过cat /proc/sys/fs/file-max 查看
 * 2.FD_SETSIZE(fd_set)的限制，这个需要重新编译内核                                                                          
 */

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

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
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 返回，即测试不出服务器端真正的并发容量。

huangcheng@ubuntu:~$ ./serv
count = 1
recv connect ip=127.0.0.1 port=50413
count = 2
....................................
client close
client close
client close
client close
...................................
recv connect ip=127.0.0.1 port=51433
client close
count = 1021
recv connect ip=127.0.0.1 port=51364
client close
client close
      可以看到输出参杂着client close，且这次的count 达到了1021，原因就是服务器端前面已经有些套接字关闭了，所以accept 创建套接字不会出错，服务器进程也不会因为出错而退出，可以看到最后接收到的一个连接端口是51364，即不一定是客户端的最后一个连接。


二、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 函数的服务器端程序如下：

#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>

#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 = read(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);
                write(conn, recvbuf, strlen(recvbuf));

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


    }

    return 0;
}

/* poll 只受一个进程所能打开的最大文件描述符限制，这个可以使用ulimit -n调整 */
参照前面对 select 函数 的解释不难理解上面的程序，就不再赘述了。来看一下输出： 


root@ubuntu:/home/huangcheng# ulimit -n 2048
root@ubuntu:/home/huangcheng# su - huangcheng
huangcheng@ubuntu:~$ ulimit -n
2048
huangcheng@ubuntu:~$ ./serv
...........................
count = 2042
recv connect ip=127.0.0.1 port=54499
count = 2043
recv connect ip=127.0.0.1 port=54500
count = 2044
recv connect ip=127.0.0.1 port=54501
accept error: Too many open files
root@ubuntu:/home/huangcheng# ulimit -n 2048
root@ubuntu:/home/huangcheng# su - huangcheng
huangcheng@ubuntu:~$ ulimit -n
2048
huangcheng@ubuntu:~$./cli
..........................
ip=127.0.0.1 port=54499
count = 2043
ip=127.0.0.1 port=54500
count = 2044
ip=127.0.0.1 port=54501
count = 2045
socket: Too many open files
       可以看到现在最大的连接数已经是2045个了，虽然服务器端有某个连接没有accept 返回。即poll 比 select 能够承受更多的并发连接，只受一个进程所能打开的最大文件描述符个数限制。可以通过ulimit -n  修改，但一个系统所能打开的文件描述符个数也是有限的，这跟系统的内存大小有关系，所以说也不是可以无限地并 发，可以查看一下本机的容量： 

huangcheng@ubuntu:~$ cat /proc/sys/fs/file-max
101598
本机是虚拟机，内存2G，能够打开的文件描述符个数大约在10w个左右。

转载于:https://www.cnblogs.com/wangfengju/p/6172506.html

weixin_30919429
关注
Unix网络编程 第6章 I/O服用： select和poll函数 第6章.tar.gz 对本章的代码简易的练习
01-09
在进行"Unix网络编程 第6章 I/O复用：select和poll函数"的代码练习时，你可能会涉及到以下内容： 1. 创建并初始化`fd_set`或`pollfd`结构。 2. 使用`FD_SET()`或`pollfd`结构添加文件描述符。 3. 设置合适的超时时间...
linux下c++sleep函数
chent86的博客
07-30 8万+
sleep() 秒级usleep() 微秒级#include <iostream> using namespace std; #include <unistd.h> int main(){ while(1) { cout << "hello" << endl; //sleep(1); usleep(100000)
linux 下借助poll延时（毫秒）
weixin_33726318的博客
05-03 571
2019独角兽企业重金招聘Python工程师标准>>> ...
休眠与唤醒 POLL机制 异步通知
agentky的博客
08-27 1203
休眠与唤醒 当应用程序必须等待某个事件发生，比如必须等待按键被按下时，可以使用“休眠-唤醒”机制： ① APP 调用 read 等函数试图读取数据，比如读取按键； ② APP 进入内核态，也就是调用驱动中的对应函数，发现有数据则复制到用户空间并马上返回； ③ 如果 APP 在内核态，也就是在驱动程序中发现没有数据，则 APP 休眠； ④ 当有数据时，比如当按下按键时，驱动程序的中断服务程序被调用，它会记录数据、唤醒 APP； ⑤ APP 继续运行它的内核态代码，也就是驱动程序中的函数，复制数据到用户空间并马
可以睡眠的poll
Netfilter
02-17 1万+
Normal 0 7.8 磅 0 2 false false false MicrosoftInternetExplorer4 <object class
c++ sleep函数 linux,sleep()函数 | C/C++程序员之家
weixin_39791225的博客
05-08 4035
简介：函数名: sleep功 能: 执行挂起一段时间用 法: unsigned sleep(unsigned milliseconds);在VC中使用带上头文件#include 在gcc编译器中，使用的头文件因gcc版本的不同而不同#include 注意：在VC中Sleep中的第一个英文字符为大写的"S"在标准C中是sleep, 不要大写.. 下面使用大写的来说明,, 具体用什么看你用什么编译器....
UNIX网络编程卷1代码.rar
07-14
- `select()`、`poll()`和`epoll`是实现I/O复用的函数，可以在多个套接字上等待读写事件，提高服务器的并发性能。 7. 套接字选项： - `setsockopt()`和`getsockopt()`函数用于设置和获取套接字的选项，如超时、重...
linux网络编程中Select和poll服务程序
01-16
在Linux网络编程中，`select`和`poll`是两种常用的方法，用于处理多个套接字的并发I/O事件。这两个函数允许程序监控多个文件描述符（通常是套接字），以便在它们准备进行读写操作时及时响应。下面将详细探讨这两种...
unix环境高级编程-函数原型.pdf
03-25
UNIX环境高级编程是Linux和类Unix系统编程的核心，涵盖了操作系统级别编程的基础知识和技能。它不仅涉及到系统调用，还包括库函数的使用、进程间通信、信号处理、文件操作等多个方面。在UNIX编程中，函数原型是定义...
UNIX网络编程卷1(第三版)源代码
01-06
4. **多路复用I/O**：利用`select()`或`poll()`函数实现对多个套接字的并发监控，提高程序的效率和响应性。 5. **TCP状态机**：理解TCP连接的建立（三次握手）、数据传输和关闭（四次挥手）过程，以及可能出现的...
linux和windows下，C/C++的sleep函数
热门推荐
jiangxinyu的专栏
07-17 14万+
简介:　　函数名: sleep 　　功 能: 执行挂起一段时间 　　用 法: unsigned sleep(unsigned seconds); 　　在VC中使用带上头文件 　　#include 　　在gcc编译器中，使用的头文件因gcc版本的不同而不同 linux系统需要添加的头文件　　#include 注意 　　: 　　在VC中Sleep中的第
C++睡眠函数：Windows平台下的Sleep函数和Linux平台的usleep函数
simple的博客
12-31 2371
介绍了三个睡眠函数，分别在Windows、Linux和全平台可用。介绍了它们的时间单位和用法。
【Linux C/C++ 延时(延迟)函数比较】介绍Linux系统中常用的延时函数sleep、usleep、nanosleep、select和std::sleep_for()的区别和使用场景
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
07-11 1万+
延时函数，sleep、usleep、nanosleep、select比较
C++睡眠延时函数 Sleep() usleep()（windows.h、unistd.h）
Dontla的博客
09-15 3万+
c++ 标准库并不支持睡眠函数 (1).windows下支持,需要引入头文件windows.h,切记Sleep首字母大写 #include <iostream> #include <windows.h> using namespace std; void main() { //睡眠5秒再输出 Sleep(5000); std::cout << "Hi,Gril!" << std::endl; } (2).linux下支持,需要引入头文
关于select中fd限制问题
monzart的专栏
05-18 5821
select 是多路复用，或异步模型中经常用到的一个系统调用。  基本原型为：  int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);  该函数的一个缺点就是nfds不能太大。上限为1024.为什么会有这样的限制，今天就来一起看看se
【C/C++】Sleep()函数详解
最新发布
C/C++领域,数据结构,linux,MySQl学习者
08-25 3147
分别详细介绍了C/C++语言编程中常用的Sleep()函数,分为windows环境下和Linux环境下的Sleep()函数和sleep()函数。包括函数功能,函数参数,函数返回值,函数头文件,以及函数使用示例程序详解。
socket select()用法，哪些socket api会阻塞
wangzhong1979的专栏
04-02 2725
一、winsock中 #include  //#include 原型 int select( int nfds, fd_set* readfds, fd_set* writefds, fd_set* exceptfds, const struct timeval* timeout ); nfds：本参数忽略，仅起到兼容作用。    readfds：（可选）指针，指
第六章 select和poll函数
sunximei的博客
11-19 2500
一、I/O复用 前面提到，当客户阻塞于fgets时，服务器进程若被杀死，虽然会给客户端发送FIN，但客户端看不到这个EOF，直到从套接字读。这样的进程需要一种预先告知内核的能力，使内核一旦发现进程指定的一个或多个I/O条件就绪，就通知进程。这个能力称为I/O复用（multiplexing）。 I/O复用通常用于服务器设计： （1）处理多个连接，或者同时处理监听套接字和连接套接字 （2）同时处理TCP协议和UDP协议 （3）同时处理多个服务 二、I/O模型 2.1 阻塞I/O模型 默认情况下，所有套接字都是阻
UNIX核心编程：select函数详解
在 UNIX/Linux 操作系统的历史中，`select`函数是最早的多路复用I/O机制之一，虽然现在有了更现代的替代品，如`poll`和`epoll`，但在某些简单或低负载的场景下，`select`仍然是一个有效的选择。 UNIX操作系统起源于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值