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

Socket编程实践(10) --select的限制与poll的使用的更多相关文章

  1. Socket编程实践(6) --TCP服务端注意事项

    僵尸进程处理 1)通过忽略SIGCHLD信号,避免僵尸进程 在server端代码中添加 signal(SIGCHLD, SIG_IGN); 2)通过wait/waitpid方法,解决僵尸进程 sign ...

  2. Socket编程实践(6) --TCPNotes服务器

    僵尸进程过程 1)通过忽略SIGCHLD信号,避免僵尸进程 在server端代码中加入 signal(SIGCHLD, SIG_IGN); 2)通过wait/waitpid方法.解决僵尸进程 sign ...

  3. C# socket编程实践

    C# socket编程实践——支持广播的简单socket服务器   在上篇博客简单理解socket写完之后我就希望写出一个websocket的服务器了,但是一路困难重重,还是从基础开始吧,先搞定C# ...

  4. C# socket编程实践——支持广播的简单socket服务器

    在上篇博客简单理解socket写完之后我就希望写出一个websocket的服务器了,但是一路困难重重,还是从基础开始吧,先搞定C# socket编程基本知识,写一个支持广播的简单server/clie ...

  5. Socket编程实践(2) Socket API 与 简单例程

    在本篇文章中,先介绍一下Socket编程的一些API,然后利用这些API实现一个客户端-服务器模型的一个简单通信例程.该例子中,服务器接收到客户端的信息后,将信息重新发送给客户端. socket()函 ...

  6. Socket编程实践(1) 基本概念

    1. 什么是socket socket可以看成是用户进程与内核网络协议栈的编程接口.TCP/IP协议的底层部分已经被内核实现了,而应用层是用户需要实现的,这部分程序工作在用户空间.用户空间的程序需要通 ...

  7. Socket编程实践(12) --UDP编程基础

    UDP特点 无连接,面向数据报(基于消息,不会粘包)的传输数据服务; 不可靠(可能会丢包, 乱序, 反复), 但因此普通情况下UDP更加高效; UDP客户/服务器模型 UDP-API使用 #inclu ...

  8. Socket编程实践(11) --epoll原理与封装

    常用模型的特点 Linux 下设计并发网络程序,有典型的Apache模型(Process Per Connection,PPC), TPC(Thread Per Connection)模型,以及 se ...

  9. Socket编程实践(2) --Socket编程导引

    什么是Socket? Socket可以看成是用户进程与内核网络协议栈的接口(编程接口, 如下图所示), 其不仅可以用于本机进程间通信,可以用于网络上不同主机的进程间通信, 甚至还可以用于异构系统之间的 ...

随机推荐

  1. npm下载包很慢和node-sass编译错误的解决办法

    最近研究一个ionic cordova angular2的前端项目 发现npm install下载包非常慢的问题 最近整理了一些解决这些问题的方法. 1.通过config命令修改https为http ...

  2. 54. Spiral Matrix(中等)

    Given a matrix of m x n elements (m rows, n columns), return all elements of the matrix in spiral or ...

  3. Python的一个解释凯撒密码的程序

    #!/usr/bin/env python # -*- coding: utf-8 -*- ''' { Title:CaserCode Author:naiquan Type:crypto Detai ...

  4. [转]关于OpenGL的绘制上下文

    [转]关于OpenGL的绘制上下文 本文转自(http://www.cnblogs.com/Liuwq/p/5444641.html) 什么是绘制上下文(Rendering Context) 初学Op ...

  5. Dockerfile的指令

    指令的一般格式为 INSTRUCTION arguments,指令包括 FROM.MAINTAINER.RUN 等. FROM 格式为 FROM <image>或FROM <imag ...

  6. Python3 XML解析

    什么是XML? XML 指可扩展标记语言(eXtensible Markup Language),标准通用标记语言的子集,是一种用于标记电子文件使其具有结构性的标记语言. 你可以通过本站学习XML教程 ...

  7. popupwindow中EditText获取焦点后自动弹出软键盘

    关于popupwindow中EditText获取焦点后自动弹出软键盘的问题,玩过手机qq或空间的童鞋应该知道,再点击评论时会弹出一个编辑框,并且伴随软键盘一起弹出是不是很方便啊,下面我们就来讲一下实现 ...

  8. YCSB性能测试工具使用

    在网上查In-Memory NoSQL性能测试的资料时,偶然间发现了这个性能测试工具YCSB,全称为"Yahoo! Cloud Serving Benchmark".它内置了对常见 ...

  9. Hibernate之实体关系映射

    延迟加载与即时加载 例如Person类和Email类是一对多关系,如果设为即时加载,当加载Person时,会自动加载Email,如果设置为延迟加载,当第一次调用person.getEmails()时才 ...

  10. Linux 高性能服务器编程——高性能服务器程序框架

    问题聚焦:     核心章节.     服务器一般分为如下三个主要模块:I/O处理单元(四种I/O模型,两种高效事件处理模块),逻辑单元(两种高效并发模式,有效状态机)和存储单元(不讨论). 服务器模 ...