C/C++ Linux网络编程4 - 解决TCP服务器并发的方式

橘子真甜～2025-11-15 9:08

上篇文章：C/C++ Linux网络编程3 - Socket编程与TCP服务器客户端-CSDN博客

代码仓库：橘子真甜 (yzc-YZC) - Gitee.com

上篇文章中，我们实现了一个简单的 TCP server - client通信。最后**测试的时候发现如果有多个客户端同时连接服务器，不能并发发送数据。**如何解决这个问题？

一. 多进程并发服务器

1.1 创建子进程和孙子进程

最简单的方式当然是为每一个客户端创建一个进程每一个进程管理服务器与客户端之间的连接和通信。

使用多进程就需要如何创建新进程？通信结束后如何回收进程的资源？使用fork就能创建子进程。

但是，创建子进程必须要回收子进程，否则子进程会变为僵尸进程，占用系统资源。

所以，简单的使用waitpid等待子进程吗？waitpid等待子进程有阻塞方式和非阻塞方式。 使用阻塞方式，主进程不还是阻塞无法并发处理连接吗？ 使用非阻塞，无法调用waitpid等待子进程，子进程变为僵尸进程。

解决方法：

1 父进程阻塞等待子进程，子进程创建后创建孙子进程管理连接和数据收发， 然后子进程直接退出，父进程回收子进程资源。（这种方式，对于孙子进程来说，他没有被回收但是其父进程被关闭了。孙子进程直接被进程1收养为孤儿进程）。孙子进程的资源由进程1进行管理。

代码如下：socket/bind/listen等函数直接看上篇文章即可，这里没有修改，不过多赘述。

cpp 复制代码 
  void run()
        {
            while (true)
            {
                struct sockaddr_in clientaddr;
                memset(&clientaddr, 0, sizeof(clientaddr));
                socklen_t len = sizeof(clientaddr);

                int sockfd = accept(_listensock, (struct sockaddr *)&clientaddr, &len);
                if (sockfd < 0)
                {
                    std::cerr << "accept err" << std::endl;
                    exit(-1);
                }
                std::cout << "accept success" << std::endl;

                // 创建子进程和孙子进程
                pid_t id = fork();
                if (id == 0)
                {
                    // 子进程创建孙子进程，然后之间退出
                    if (fork() > 0)
                        exit(-1);

                    // 孙子进程执行相应任务
                    //  通过clientaddr获取对方的ip/port
                    std::string clientip = inet_ntoa(clientaddr.sin_addr);
                    uint16_t clientport = ntohs(clientaddr.sin_port);
                    printf("获取连接成功,对方的ip/port为[%s][%d]", clientip.c_str(), clientport);

                    // 执行响应的回调函数处理数据
                    _callback(sockfd);

                    // 关闭fd
                    close(sockfd);
                }

                // 父进程等待子进程资源
                pid_t ret = waitpid(id, nullptr, 0);
                if (ret > 0)
                {
                    printf("father wait success!\n");
                }
            }
        }

然后我们简单修改服务端的服务代码方便我们测试。

代码如下：无脑发送一个打印 hello world的http响应

cpp 复制代码 
  void serviceIO(int sockfd)
    {
        // 这里仅做简单的数据收发
        while (true)
        {
            char buffer[128] = {0};
            int count = recv(sockfd, buffer, sizeof(buffer) - 1, 0);
            if (count < 0)
            {
                std::cerr << "recv err" << std::endl;
                exit(-1);
            }
            if (count == 0)
            {
                // 对方关闭
                break;
            }
            printf("client --> server:%s\n", buffer);

            std::string outbuffer;
            std::string body = "<h1>hello world</h1>";
            outbuffer =
                "HTTP/1.1 200 OK\r\n"
                "Content-Type: text/html; charset=utf-8\r\n"
                "Content-Length: " +
                std::to_string(body.size()) + "\r\n"
                                              "Server: Apache/2.4.41\r\n"
                                              "Date: Mon, 18 Dec 2023 08:32:10 GMT\r\n"
                                              "X-Frame-Options: DENY\r\n"
                                              "X-Content-Type-Options: nosniff\r\n"
                                              "Referrer-Policy: strict-origin-when-cross-origin\r\n"
                                              "\r\n" // 空行分隔头部和正文
                + body;

            // 无脑向客户端发送一个简单http响应
            count = send(sockfd, outbuffer.c_str(), outbuffer.size(), 0);
            if (count < 0)
            {
                std::cerr << "send err" << std::endl;
                exit(-1);
            }
        }
        close(sockfd);
    }

测试结果如下：这里借用网络调试工具进行测试：工具地址如下 软件下载-野人家园-物联网技术专家平台 (cmsoft.cn)

可以发现，能够支持两个客户端发送数据。再测试一下浏览器能否解析响应发现浏览器也是能够获取我们的响应的。

全部代码如下：

复制代码 
#include <iostream>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <cstring>

#include <functional>

namespace YZC
{
    // 设置默认端口和最大backlog
    const int defaultPort = 8080;
    const int maxBacklog = 128;

    // 设置回调函数
    using func_t = std::function<void(int)>;
    // typedef void (*func_t)(int);

    class tcpServer
    {
    public:
        tcpServer(func_t func, int port = defaultPort)
            : _port(port), _callback(func) {}

        void init()
        {
            // 1.创建socket
            _listensock = socket(AF_INET, SOCK_STREAM, 0);
            if (_listensock < 0)
            {
                std::cerr << "sockte err" << std::endl;
                exit(-1);
            }
            std::cout << "socket success" << std::endl;

            // 2 bind绑定fd和端口
            struct sockaddr_in serveraddr;
            memset(&serveraddr, 0, sizeof(serveraddr));
            // 设置地址的信息（协议，ip，端口）
            serveraddr.sin_family = AF_INET;
            serveraddr.sin_addr.s_addr = htonl(INADDR_ANY); // 绑定任意网卡ip，通常我们访问某一个IP地址是这个服务器的公网网卡IP地址
            serveraddr.sin_port = htons(_port);             // 注意端口16位，2字节需要使用htons。不可
            socklen_t len = sizeof(serveraddr);
            if (bind(_listensock, (struct sockaddr *)&serveraddr, len) < 0)
            {
                std::cerr << "bind err" << std::endl;
                exit(-1);
            }
            std::cout << "bind success" << std::endl;

            // 3 设置sockfd为监听fd
            if (listen(_listensock, maxBacklog) < 0)
            {
                std::cerr << "listen err" << std::endl;
                exit(-1);
            }
            std::cout << "listen success" << std::endl;
        }

        void run()
        {
            while (true)
            {
                struct sockaddr_in clientaddr;
                memset(&clientaddr, 0, sizeof(clientaddr));
                socklen_t len = sizeof(clientaddr);

                int sockfd = accept(_listensock, (struct sockaddr *)&clientaddr, &len);
                if (sockfd < 0)
                {
                    std::cerr << "accept err" << std::endl;
                    exit(-1);
                }
                std::cout << "accept success" << std::endl;

                // 创建子进程和孙子进程
                pid_t id = fork();
                if (id == 0)
                {
                    // 子进程创建孙子进程，然后之间退出
                    if (fork() > 0)
                        exit(-1);

                    // 孙子进程执行相应任务
                    //  通过clientaddr获取对方的ip/port
                    std::string clientip = inet_ntoa(clientaddr.sin_addr);
                    uint16_t clientport = ntohs(clientaddr.sin_port);
                    printf("获取连接成功,对方的ip/port为[%s][%d]", clientip.c_str(), clientport);

                    // 执行响应的回调函数处理数据
                    _callback(sockfd);

                    // 关闭fd
                    close(sockfd);
                }

                // 父进程等待子进程资源
                pid_t ret = waitpid(id, nullptr, 0);
                if (ret > 0)
                {
                    printf("father wait success!\n");
                }
            }
        }

    private:
        int _listensock;
        int _port;
        func_t _callback;
    };

    void serviceIO(int sockfd)
    {
        // 这里仅做简单的数据收发
        while (true)
        {
            char buffer[128] = {0};
            int count = recv(sockfd, buffer, sizeof(buffer) - 1, 0);
            if (count < 0)
            {
                std::cerr << "recv err" << std::endl;
                exit(-1);
            }
            if (count == 0)
            {
                // 对方关闭
                break;
            }
            printf("client --> server:%s\n", buffer);

            std::string outbuffer;
            std::string body = "<h1>hello world</h1>";
            outbuffer =
                "HTTP/1.1 200 OK\r\n"
                "Content-Type: text/html; charset=utf-8\r\n"
                "Content-Length: " +
                std::to_string(body.size()) + "\r\n"
                                              "Server: Apache/2.4.41\r\n"
                                              "Date: Mon, 18 Dec 2023 08:32:10 GMT\r\n"
                                              "X-Frame-Options: DENY\r\n"
                                              "X-Content-Type-Options: nosniff\r\n"
                                              "Referrer-Policy: strict-origin-when-cross-origin\r\n"
                                              "\r\n" // 空行分隔头部和正文
                + body;

            // 无脑向客户端发送一个简单http响应
            count = send(sockfd, outbuffer.c_str(), outbuffer.size(), 0);
            if (count < 0)
            {
                std::cerr << "send err" << std::endl;
                exit(-1);
            }
        }
        close(sockfd);
    }
}

1.2 设置信号SIG_IGN

我们知道，子进程退出后会向父进程发送信号SIGCHLD 来通知父进程关闭子进程并且回收子进程资源**。** 只要使用signal将SIGCHLD设置为SIGIGN让父进程不去关心子进程状态，让其自动回收回收子进程资源。

代码如下：使用signal需要包含头文件 <signal.h>

cpp 复制代码 
        void run()
        {
            signal(SIGCHLD, SIG_IGN);
            while (true)
            {
                struct sockaddr_in clientaddr;
                memset(&clientaddr, 0, sizeof(clientaddr));
                socklen_t len = sizeof(clientaddr);

                int sockfd = accept(_listensock, (struct sockaddr *)&clientaddr, &len);
                if (sockfd < 0)
                {
                    std::cerr << "accept err" << std::endl;
                    exit(-1);
                }
                std::cout << "accept success" << std::endl;


                pid_t id = fork();
                if (id == 0)
                {

                    std::string clientip = inet_ntoa(clientaddr.sin_addr);
                    uint16_t clientport = ntohs(clientaddr.sin_port);
                    printf("获取连接成功,对方的ip/port为[%s][%d]", clientip.c_str(), clientport);
                    // 执行响应的回调函数处理数据
                    _callback(sockfd);
                    // 关闭fd
                    close(sockfd);
                    exit(0);
                }
            }
        }

测试如下：

这样也能保证多客户端的并发连接和通信。可运行代码如下：

cpp 复制代码 
#include <iostream>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <signal.h>
#include <cstring>

#include <functional>

namespace YZC
{
    // 设置默认端口和最大backlog
    const int defaultPort = 8080;
    const int maxBacklog = 128;

    // 设置回调函数
    using func_t = std::function<void(int)>;
    // typedef void (*func_t)(int);

    class tcpServer
    {
    public:
        tcpServer(func_t func, int port = defaultPort)
            : _port(port), _callback(func) {}

        void init()
        {
            // 1.创建socket
            _listensock = socket(AF_INET, SOCK_STREAM, 0);
            if (_listensock < 0)
            {
                std::cerr << "sockte err" << std::endl;
                exit(-1);
            }
            std::cout << "socket success" << std::endl;

            // 2 bind绑定fd和端口
            struct sockaddr_in serveraddr;
            memset(&serveraddr, 0, sizeof(serveraddr));
            // 设置地址的信息（协议，ip，端口）
            serveraddr.sin_family = AF_INET;
            serveraddr.sin_addr.s_addr = htonl(INADDR_ANY); // 绑定任意网卡ip，通常我们访问某一个IP地址是这个服务器的公网网卡IP地址
            serveraddr.sin_port = htons(_port);             // 注意端口16位，2字节需要使用htons。不可
            socklen_t len = sizeof(serveraddr);
            if (bind(_listensock, (struct sockaddr *)&serveraddr, len) < 0)
            {
                std::cerr << "bind err" << std::endl;
                exit(-1);
            }
            std::cout << "bind success" << std::endl;

            // 3 设置sockfd为监听fd
            if (listen(_listensock, maxBacklog) < 0)
            {
                std::cerr << "listen err" << std::endl;
                exit(-1);
            }
            std::cout << "listen success" << std::endl;
        }

        void run()
        {
            signal(SIGCHLD, SIG_IGN);
            while (true)
            {
                struct sockaddr_in clientaddr;
                memset(&clientaddr, 0, sizeof(clientaddr));
                socklen_t len = sizeof(clientaddr);

                int sockfd = accept(_listensock, (struct sockaddr *)&clientaddr, &len);
                if (sockfd < 0)
                {
                    std::cerr << "accept err" << std::endl;
                    exit(-1);
                }
                std::cout << "accept success" << std::endl;

                // // 创建子进程和孙子进程
                // pid_t id = fork();
                // if (id == 0)
                // {
                //     // 子进程创建孙子进程，然后之间退出
                //     if (fork() > 0)
                //         exit(-1);

                //     // 孙子进程执行相应任务
                //     //  通过clientaddr获取对方的ip/port
                //     std::string clientip = inet_ntoa(clientaddr.sin_addr);
                //     uint16_t clientport = ntohs(clientaddr.sin_port);
                //     printf("获取连接成功,对方的ip/port为[%s][%d]", clientip.c_str(), clientport);

                //     // 执行响应的回调函数处理数据
                //     _callback(sockfd);

                //     // 关闭fd
                //     close(sockfd);
                // }

                // // 父进程等待子进程资源
                // pid_t ret = waitpid(id, nullptr, 0);
                // if (ret > 0)
                // {
                //     printf("father wait success!\n");
                // }
                pid_t id = fork();
                if (id == 0)
                {

                    std::string clientip = inet_ntoa(clientaddr.sin_addr);
                    uint16_t clientport = ntohs(clientaddr.sin_port);
                    printf("获取连接成功,对方的ip/port为[%s][%d]", clientip.c_str(), clientport);
                    // 执行响应的回调函数处理数据
                    _callback(sockfd);
                    // 关闭fd
                    close(sockfd);
                    exit(0);
                }
            }
        }

    private:
        int _listensock;
        int _port;
        func_t _callback;
    };

    void serviceIO(int sockfd)
    {
        // 这里仅做简单的数据收发
        while (true)
        {
            char buffer[128] = {0};
            int count = recv(sockfd, buffer, sizeof(buffer) - 1, 0);
            if (count < 0)
            {
                std::cerr << "recv err" << std::endl;
                exit(-1);
            }
            if (count == 0)
            {
                // 对方关闭
                break;
            }
            printf("client --> server:%s\n", buffer);

            std::string outbuffer;
            std::string body = "<h1>hello world</h1>";
            outbuffer =
                "HTTP/1.1 200 OK\r\n"
                "Content-Type: text/html; charset=utf-8\r\n"
                "Content-Length: " +
                std::to_string(body.size()) + "\r\n"
                                              "Server: Apache/2.4.41\r\n"
                                              "Date: Mon, 18 Dec 2023 08:32:10 GMT\r\n"
                                              "X-Frame-Options: DENY\r\n"
                                              "X-Content-Type-Options: nosniff\r\n"
                                              "Referrer-Policy: strict-origin-when-cross-origin\r\n"
                                              "\r\n" // 空行分隔头部和正文
                + body;

            // 无脑向客户端发送一个简单http响应
            count = send(sockfd, outbuffer.c_str(), outbuffer.size(), 0);
            if (count < 0)
            {
                std::cerr << "send err" << std::endl;
                exit(-1);
            }
        }
        close(sockfd);
    }
}

二. 多线程并发服务器

为每一个连接都分配一个进程对于资源消耗的太大了，**并且进程之间的切换需要消耗的资源也是非常大的（需要更换虚拟内存，页表和其映射关系，切换进程的上下文，也会导致catch更新导致命中率下降等）**有没有更好的方式呢？

线程是一个更好的方式， 先的开辟和切换所消耗的资源远小于进程。再linux中可以使用pthread.h原生线程库来实现线程，本文使用c++11提供的thread来创造线程，更为方便。

代码如下：

cpp 复制代码 
 void run()
        {
            while (true)
            {
                struct sockaddr_in clientaddr;
                memset(&clientaddr, 0, sizeof(clientaddr));
                socklen_t len = sizeof(clientaddr);

                int sockfd = accept(_listensock, (struct sockaddr *)&clientaddr, &len);
                if (sockfd < 0)
                {
                    std::cerr << "accept err" << std::endl;
                    exit(-1);
                }
                std::cout << "accept success" << std::endl;

                std::thread t1(_callback, sockfd);
                t1.detach();
            }
        }

可以看到，通过创建进程也能实现服务器的并发处理。

cpp 复制代码 
#include <iostream>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <cstring>

#include <functional>
#include <thread>

namespace YZC
{
    // 设置默认端口和最大backlog
    const int defaultPort = 8080;
    const int maxBacklog = 128;

    // 设置回调函数
    using func_t = std::function<void(int)>;
    // typedef void (*func_t)(int);

    class tcpServer
    {
    public:
        tcpServer(func_t func, int port = defaultPort)
            : _port(port), _callback(func) {}

        void init()
        {
            // 1.创建socket
            _listensock = socket(AF_INET, SOCK_STREAM, 0);
            if (_listensock < 0)
            {
                std::cerr << "sockte err" << std::endl;
                exit(-1);
            }
            std::cout << "socket success" << std::endl;

            // 2 bind绑定fd和端口
            struct sockaddr_in serveraddr;
            memset(&serveraddr, 0, sizeof(serveraddr));
            // 设置地址的信息（协议，ip，端口）
            serveraddr.sin_family = AF_INET;
            serveraddr.sin_addr.s_addr = htonl(INADDR_ANY); // 绑定任意网卡ip，通常我们访问某一个IP地址是这个服务器的公网网卡IP地址
            serveraddr.sin_port = htons(_port);             // 注意端口16位，2字节需要使用htons。不可
            socklen_t len = sizeof(serveraddr);
            if (bind(_listensock, (struct sockaddr *)&serveraddr, len) < 0)
            {
                std::cerr << "bind err" << std::endl;
                exit(-1);
            }
            std::cout << "bind success" << std::endl;

            // 3 设置sockfd为监听fd
            if (listen(_listensock, maxBacklog) < 0)
            {
                std::cerr << "listen err" << std::endl;
                exit(-1);
            }
            std::cout << "listen success" << std::endl;
        }

        void run()
        {
            while (true)
            {
                struct sockaddr_in clientaddr;
                memset(&clientaddr, 0, sizeof(clientaddr));
                socklen_t len = sizeof(clientaddr);

                int sockfd = accept(_listensock, (struct sockaddr *)&clientaddr, &len);
                if (sockfd < 0)
                {
                    std::cerr << "accept err" << std::endl;
                    exit(-1);
                }
                std::cout << "accept success" << std::endl;

                std::thread t1(_callback, sockfd);
                t1.detach();
            }
        }

    private:
        int _listensock;
        int _port;
        func_t _callback;
    };

    void serviceIO(int sockfd)
    {
        // 这里仅做简单的数据收发
        while (true)
        {
            char buffer[128] = {0};
            int count = recv(sockfd, buffer, sizeof(buffer) - 1, 0);
            if (count < 0)
            {
                std::cerr << "recv err" << std::endl;
                exit(-1);
            }
            if (count == 0)
            {
                // 对方关闭
                break;
            }
            printf("client --> server:%s\n", buffer);

            std::string outbuffer;
            std::string body = "<h1>hello world</h1>";
            outbuffer =
                "HTTP/1.1 200 OK\r\n"
                "Content-Type: text/html; charset=utf-8\r\n"
                "Content-Length: " +
                std::to_string(body.size()) + "\r\n"
                                              "Server: Apache/2.4.41\r\n"
                                              "Date: Mon, 18 Dec 2023 08:32:10 GMT\r\n"
                                              "X-Frame-Options: DENY\r\n"
                                              "X-Content-Type-Options: nosniff\r\n"
                                              "Referrer-Policy: strict-origin-when-cross-origin\r\n"
                                              "\r\n" // 空行分隔头部和正文
                + body;

            // 无脑向客户端发送一个简单http响应
            count = send(sockfd, outbuffer.c_str(), outbuffer.size(), 0);
            if (count < 0)
            {
                std::cerr << "send err" << std::endl;
                exit(-1);
            }
        }
        close(sockfd);
    }

}

对于多进程来说，还可以使用线程池的方式来提高效率和稳定性。

三. 效率测试和总结

使用wrk这个工具来测试多进程/多线程服务器的效率如何。最后获取的数据如下。

服务器配置为 2G/2核cpu

并发数 架构 QPS 总请求数 平均延迟 吞吐量 错误数 错误类型 测试状态
1,000 多进程 7,281 73,625 100ms 1.84MB/s 482 482超时 ✅ 正常
1,000 多线程 8,650 87,421 126ms 2.19MB/s 73 73超时 ✅ 最佳
10,000 多进程 5,522 55,745 102ms 1.40MB/s 433 123读+310超时 ✅ 正常
10,000 多线程 7,375 74,453 194ms 1.86MB/s 353 107读+246超时 ✅ 最佳
25,000 多进程 1,042 35,604 420ms 270KB/s 10,972 77读+8932写+1963超时 ⚠️ 高压稳定
25,000 多线程 313 24,298 205ms 81KB/s 953 691读+262超时 ⚠️ 性能衰减
55,555 多进程 0 0 0us 0B/s 37,170 37170写错误 ❌ 崩溃
55,555 多线程 N/A N/A N/A N/A N/A 测试被终止 ❌ 崩溃

可见无论是多进程还是多线程在连接大量增多的情况下都无法有效解决并发连接问题。为了解决这个问题，可以使用更有效的IO多路复用（select poll epoll）

相关推荐
last demo35 分钟前
Linux 逻辑卷管理
linux·运维·服务器
羑悻的小杀马特1 小时前
SSH级知识管理：通过CPolar暴露Obsidian vault构建你的知识API服务，实现跨设备无缝同步
运维·ssh·cpolar·obsidian
ll_god1 小时前
ubuntu:beyond compare 4 This license key has been revoked 解决办法
linux·运维·ubuntu
初听于你1 小时前
深入解析IP, ICMP, OSPF, BGP四大核心网络协议
服务器·网络·网络协议·计算机网络·信息与通信·信号处理
The_Second_Coming1 小时前
Python 学习笔记：基础篇
运维·笔记·python·学习
草莓熊Lotso1 小时前
C++ 二叉搜索树（BST）完全指南：从概念原理、核心操作到底层实现
java·运维·开发语言·c++·人工智能·经验分享·c++进阶
网硕互联的小客服1 小时前
如何解决 Linux 文件系统挂载失败的问题?
linux·服务器·前端·网络·chrome
贝锐1 小时前
多设备可视化管理，向日葵屏幕墙如何塑造IT设备管理范式
运维·远程工作
门思科技2 小时前
主流 LoRaWAN 网络服务器深度对比：ThinkLink、TTS、ChirpStack、Loriot 与 Actility 选型指南
运维·服务器·网络
热门推荐
01GitHub 镜像站点02UV安装并设置国内源03安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）04Linux下V2Ray安装配置指南05综合整理：pdf预览显示：你尝试预览的文件可能对你的计算机有害。如果你信任此文件以及其来源，请打开此文件以看其内容，如何解决以正常预览文件06BongoCat - 跨平台键盘猫动画工具07Labelme从安装到标注：零基础完整指南08jdk21下载、安装（Windows、Linux、macOS）09全面评测 | Photoshop 2026 新特性深度解析与实测体验10NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南