Linux 软件编程(十二)网络编程：TCP 并发服务器构建与 IO 多路复用

于 2025-08-27 20:07:04 发布
阅读量662 收藏 16
点赞数 16
CC 4.0 BY-SA版权
文章标签： 网络 服务器 linux c语言 tcp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_80202237/article/details/150934196

在网络编程中，服务器需要应对多个客户端的连接与请求，单循环服务器因同一时刻仅能处理一个客户端任务，无法满足高并发场景。而 TCP 并发服务器可实现多客户端同时处理 。

一、TCP 并发服务器

（一）单循环与并发服务器区别

  • 单循环服务器：同一时刻仅能处理一个客户端任务，处理完当前客户端才能响应下一个，效率低。
  • 并发服务器：可同时处理多个客户端任务，提升服务端资源利用率与响应能力。

（二）TCP 连接特性

TCP 基于 “三次握手” 建立 一对一连接 ，可靠传输数据，但需高效并发模型支撑多客户端交互。

二、TCP 服务端并发模型

（一）多进程模型

  1. 原理：服务端通过 fork() 创建子进程，父进程负责监听新连接，子进程处理客户端交互。
  2. 特点：
    • 资源开销大：进程有独立地址空间，创建、切换成本高。
    • 安全性高：进程间资源隔离，一个进程异常一般不影响其他进程。
  3. 代码示例：
#include <stdio.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
 #include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */
#include <unistd.h>
#include <arpa/inet.h>
#include <string.h>
#include <pthread.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <signal.h>

#define SER_PORT 50000
#define SER_IP "192.168.0.149"

struct sockaddr_in seraddr;

void hander(int handnum)
{
    wait(NULL);
}

int init_tcp_recv()
{
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if(sockfd < 0)
    {
        perror("sockfd error");
        return -1;
    }
    seraddr.sin_family = AF_INET;
    seraddr.sin_port = htons(SER_PORT);
    seraddr.sin_addr.s_addr = inet_addr(SER_IP);

    int ret = bind(sockfd, (struct sockaddr *)&seraddr, sizeof(seraddr));
    if(ret < 0)
    {
        perror("bind error");
        return -1;
    }

    ret =listen(sockfd, 10);
    if(ret < 0)
    {
        perror("listen error");
        return -1;
    }
    return sockfd;
}


int main(int argc, char const *argv[])
{
    signal(SIGCHLD, hander);
    int sockfd = init_tcp_recv();

    struct sockaddr_in cliaddr;
    socklen_t lenaddr = sizeof(cliaddr);

    while(1)
    {
        int connfd = accept(sockfd, (struct sockaddr *)&cliaddr, &lenaddr);
        if(connfd < 0)
        {
            perror("accept error");
            return -1;
        }
        pid_t pid = fork();
        if(pid > 0)
        {

        }
        else if(pid == 0)
        {
            char buff[1024] = {0};
            while(1)
            {
                memset(buff, 0, sizeof(buff));
                int ret = recv(connfd, buff, sizeof(buff), 0);
                if(ret < 0)
                {
                    perror("error recv");
                    break;
                }
                else if(0 == ret)
                {
                    printf("[%s:%d]: client off\n", inet_ntoa(cliaddr.sin_addr), ntohs(cliaddr.sin_port));
                    close(connfd);
                    break;
                }
                printf("[%s:%d]:%s\n", inet_ntoa(cliaddr.sin_addr), ntohs(cliaddr.sin_port), buff);
                strcat(buff, "---->ok");
                int cnt = send(connfd, buff, strlen(buff), 0);
                if(cnt < 0)
                {
                    perror("send error");
                    close(connfd);
                    break;
                }
                
            }
            
        }
    }
    close(sockfd);

    return 0;

}

（二）多线程模型

  1. 原理：借助 pthread_create() 创建线程，主线程负责 accept 新连接，子线程处理客户端数据收发。
  2. 特点：
    • 资源开销小：线程共享进程地址空间，创建、切换成本低于进程，相同资源环境下并发量更高。
    • 需注意同步：线程共享资源，如需客户端地址信息等，需用锁机制（如互斥锁）避免竞争，否则易引发数据混乱，或者创建结构体将客户端信息和通信套接字放在里面，然后线程传参时第四个参数传入结构体的地址，然后进行访问内容。
  3. 伪代码示例：
#include <stdio.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
 #include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */
#include <unistd.h>
#include <arpa/inet.h>
#include <string.h>
#include <pthread.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include<pthread.h>

#define SER_PORT 50000
#define SER_IP "192.168.0.149"

struct sockaddr_in seraddr;

int init_tcp_recv()
{
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if(sockfd < 0)
    {
        perror("sockfd error");
        return -1;
    } 
    //允许绑定处于TIME_WAIT状态的地址，避免端口占用问题：
	int optval = 1;
	setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval));
    seraddr.sin_family = AF_INET;
    seraddr.sin_port = htons(SER_PORT);
    seraddr.sin_addr.s_addr = inet_addr(SER_IP);

    int ret = bind(sockfd, (struct sockaddr *)&seraddr, sizeof(seraddr));
    if(ret < 0)
    {
        perror("bind error");
        return -1;
    }

    ret =listen(sockfd, 10);
    if(ret < 0)
    {
        perror("listen error");
        return -1;
    }
    return sockfd;
}

// struct sockaddr_in cliaddr;
// socklen_t lenaddr = sizeof(cliaddr);

void *recv_senf(void *arg)
{
    int connfd = *((int *)arg);
    char buff[1024] = {0};
    while(1)
    {
        memset(buff, 0, sizeof(buff));
        int ret = recv(connfd, buff, sizeof(buff), 0);
        if(ret < 0)
        {
            perror("error recv");
            break;
        }
        else if(0 == ret)
        {
            printf("client off\n");
            close(connfd);
            break;
        }
        printf("%s\n", buff);
        strcat(buff, "---->ok");
        int cnt = send(connfd, buff, strlen(buff), 0);
        if(cnt < 0)
        {
            perror("send error");
            close(connfd);
            break;
        } 
    }
    return NULL;
}

int main(int argc, char const *argv[])
{
    int sockfd = init_tcp_recv();
    if(sockfd < 0)
    {
        return -1;
    }
    pthread_t tid;
    while(1)
    {
        int connfd = accept(sockfd, NULL, NULL);
        if(connfd < 0)
        {
            perror("accept error");
            return -1;
        }
        pthread_create(&tid, NULL, recv_senf, &connfd);
        pthread_detach(tid);
    }

    close(sockfd);

    return 0;

}

（三）线程池模型

  1. 背景：多线程 / 多进程模型中，频繁创建、销毁线程 / 进程会产生大量时间消耗。线程池基于 生产者 - 消费者模型 与 任务队列 ，预先创建一定数量线程，复用线程处理任务，减少资源开销。
  2. 原理：
    • 生产者（主线程）：负责 accept 客户端连接，将任务（如处理客户端请求）放入任务队列。
    • 消费者（线程池中的次线程）：从任务队列取出任务并执行，执行完可继续获取新任务，无需频繁创建销毁。
  3. 模型示意图：
    主线程作为生产者生产任务（如客户端连接处理任务），放入任务队列；多个次线程作为消费者，从队列取任务执行，实现任务高效复用与并发处理。

（四）IO 多路复用模型

  1. 核心思想：让一个进程 / 线程 复用多个文件描述符（fd）的读写操作 ，不创建新进程 / 线程，通过一个进程监测、处理多个文件（如 socket 连接）的读写事件。
  2. 应用场景：需同时监听多个 fd （如 stdin、connfd 等），避免阻塞 IO 导致程序 “卡主”，典型函数有 select、poll、epoll 。
（1）select 函数
  • 函数与操作步骤：
    • 创建文件描述符集合：用 fd_set 类型，通过 FD_ZERO 清空集合，FD_SET 添加关注的 fd 。
    • 传递集合给内核监测：调用 select 函数，内核监测集合中 fd 的事件（读、写、异常等），监测期间进程阻塞。
    • 处理事件：内核监测到事件后，select 解除阻塞，通过 FD_ISSET 判断具体 fd 事件，执行对应读写操作。
  • 关键函数与 select 原型：

  • void FD_CLR(int fd, fd_set *set); 
    int  FD_ISSET(int fd, fd_set *set); 
    void FD_SET(int fd, fd_set *set); 
    void FD_ZERO(fd_set *set); 

    int select(int nfds, fd_set *readfds, fd_set *writefds,
               fd_set *exceptfds, struct timeval *timeout);
    功能：传递文件描述符结合表给内核并等待获取事件结果
           参数：
                   nfds ： 关注的最大文件描述符+1
                   readfds：读事件的文件描述符集合
                  writefds：写事件的文件描述符集合
                  exceptfds：其他事件的文件描述符集合
                  timeout：设置select监测时的超时时间
                                   NULL ： 不设置超时时间（select一直阻塞等待）

            返回值：
                成功：返回内核监测的到达事件的个数
                失败：-1
                0 ： 超时时间到达，但没有事件发生，则返回

  • 伪代码示例（结合 TCP 服务端）：



#include <sys/select.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/time.h>
#include<string.h>
#include <stdio.h>
#include <sys/types.h>          /* See NOTES */
 #include <sys/socket.h>
#include <netinet/ip.h> /* superset of previous */
#include <unistd.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include<pthread.h>

#define SER_PORT 50000
#define SER_IP "192.168.0.149"

struct sockaddr_in seraddr;

int init_tcp_recv()
{
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if(sockfd < 0)
    {
        perror("sockfd error");
        return -1;
    } 
    //允许绑定处于TIME_WAIT状态的地址，避免端口占用问题：
	int optval = 1;
	setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval));
    seraddr.sin_family = AF_INET;
    seraddr.sin_port = htons(SER_PORT);
    seraddr.sin_addr.s_addr = inet_addr(SER_IP);

    int ret = bind(sockfd, (struct sockaddr *)&seraddr, sizeof(seraddr));
    if(ret < 0)
    {
        perror("bind error");
        return -1;
    }

    ret =listen(sockfd, 10);
    if(ret < 0)
    {
        perror("listen error");
        return -1;
    }
    return sockfd;
}

int main(int argc, char const *argv[])
{
    int sockfd = init_tcp_recv();
    if(sockfd < 0)
    {
        return -1;
    }

    fd_set rdfds;
    fd_set rdfdstem;

    FD_ZERO(&rdfds);
    FD_ZERO(&rdfdstem);

    FD_SET(sockfd, &rdfds);
    int maxfd = sockfd; 
    char buff[1024] = {0};
    while(1)
    {
        rdfdstem = rdfds;
        int ret = select(maxfd + 1, &rdfds, NULL, NULL, NULL);
        if(ret < 0)
        {
            perror("select error");
            return -1;
        }
  
        if(FD_ISSET(sockfd, &rdfdstem))
        {
            int connfd = accept(sockfd, NULL, NULL);
            if(connfd < 0)
            {
                perror("accept error");
                return -1;
            }
            FD_SET(connfd, &rdfds);
            maxfd = maxfd > connfd ? maxfd : connfd;
        }

        for(int i = sockfd + 1;i < maxfd + 1;++i)
        {
            if(FD_ISSET(i, &rdfdstem))
            {
                memset(buff, 0, sizeof(buff));
                ssize_t cnt  = recv(i, buff, sizeof(buff), 0);
                if(cnt < 0)
                {
                    perror("recv error");
                    FD_CLR(i, &rdfds);
                    close(i);
                    continue;
                }
                else if(cnt == 0)
                {
                    FD_CLR(i, &rdfds);
                    close(i);
                    continue;
                }
                printf("%s\n", buff);
                strcat(buff, "---->ok");
                cnt = send(i, buff, strlen(buff), 0);
                if(cnt < 0)
                {
                    perror("send error");
                    FD_CLR(i, &rdfds);
                    close(i);
                    continue;
                }
            }
        }         
    }
    close(sockfd);
    return 0;
}

  • 特点：
    • 需维护 fd 集合，每次 select 后需重新添加 fd（因内核会修改集合）。
    • fd 数量受限（受系统默认限制，如 1024 ），高并发场景可能不够用。
（2）poll/epoll 
  • poll：与 select 类似，通过 struct pollfd 数组传递监测的 fd 及事件，解决 select 中 fd 数量受限问题，但本质仍需遍历 fd 判断事件，高并发下效率一般。
  • epoll：Linux 下高效的 IO 多路复用机制，通过 红黑树 维护监测的 fd，回调机制 通知事件，无需遍历所有 fd ，高并发场景（如大量客户端连接）效率远高于 select/poll 。

三、总结

TCP 并发服务器构建有多种模式：

  • 多进程模型资源开销大但安全；
  • 多线程模型轻量但需注意同步；
  • 线程池模型优化线程资源管理，适配高频任务场景；
  • IO 多路复用（select/poll/epoll ）让单进程实现多 fd 监测，高效处理并发连接。
Aczone28
关注
Linux I/O编程：I/O多路复用与异步 I/O对比
Where there is life, there is hope.
11-11 1140
本文将简要介绍 Linux 中的多路复用 I/O 和异步 I/O 模型，并编写示例代码简述。对于网络 I/O，特别是 UDP 和 TCP，多路复用 I/O（如 `select`、`epoll()`）通常是更好的选择。而异步 I/O（如 `libaio`）只建议用在文件和块设备的 I/O 操作。
C++网络编程之IO多路复用（三）
hope_wisdom的技术博客
11-11 1795
在前两篇文章中，我们介绍了如何使用select和poll进行IO多路复用。select通常有一个固定的文件描述符数量上限（通常是1024），poll虽然没有严格的文件描述符数量限制，但在实际使用中也可能受到系统资源的限制。相比之下，epoll支持非常大的文件描述符数量（理论上可以达到系统文件描述符的最大值），因此更适合高并发场景。在本篇中，我们将重点介绍epoll。
C++网络编程：select IO多路复用及TCP服务器开发
Lion_Long的博客
11-24 2352
在高并发网络编程中，高效处理大量连接至关重要。传统的阻塞式I/O模型已无法满足需求，而IO多路复用技术则提供了优雅的解决方案。本文将深入探讨C++网络编程中常用的IO多路复用技术——select，剖析其原理和使用方法，并通过一个完整的TCP服务器示例，演示如何利用select构建高性能的网络应用。
【Linux网络编程】TCP并发服务器的实现（IO多路复用select）
m0_65835264的博客
08-16 3312
TCP的服务器默认的就是一个循环服务器，原因是有两个阻塞 accept函数 和 recv函数之间会相互影响。本文是TCP并发服务器、客户端的实现以及实例的详细解释。使用了IO多路复用select函数进行TCP并发服务器的构建。希望博客对您有所帮助。 .........
Linux C/C++ 开发（学习笔记十二 ）：TCP服务器（并发网络编程io多路复用epoll）
菊头蝙蝠的博客
03-15 1556
Linux C/C++ 开发（学习笔记十二 ）：TCP服务器（并发网络编程io多路复用epoll）一、了解epoll二、完整代码三、补充： 一、了解epoll 可以通过epoll实现io多路复用 深入了解epoll epoll使用详解 二、完整代码 epoll水平触发（LT）和边沿触发（ET）概念较为重要 开发过程中，一定要注意sockfd要在epoll这个集合里面 使用epoll肯定会有一个 事件的主循环。 #include<sys/socket.h> #include<arpa/in
实现TCP并发服务器---IO多路复用
l2020429的博客
09-10 2030
分别使用select ，poll 实现TCP并发服务器
C++网络编程之IO多路复用（一）
hope_wisdom的技术博客
11-06 1438
在C++网络编程中，处理并发连接是一个非常关键的核心问题。为了有效管理来自多个客户端的请求，服务器需要能够同时监听多个套接字上的事件，这通常通过IO多路复用来实现。IO多路复用是一种工作机制，它可以让程序监视多个文件描述符（通常是套接字），等待其中一个或多个文件描述符变为就绪状态。一旦某个文件描述符就绪，即该文件描述符上可以进行无阻塞读写操作，操作系统就会通知应用程序。然后，应用程序就可以对该文件描述符进行相应的读写操作。使用IO多路复用后，不需要为每个连接创建一个独立的线程，节省了资源。
linux：IO多路复用
T66656的博客
09-02 1501
定义：单线程或单进程同时监测若干个文件描述符是否可以执行IO操作的能力应用程序通常需要处理来自多条事件流中的事件，比如我现在用的电脑，需要同时处理键盘鼠标的输入、中断信号等等事件，再比如web服务器如nginx，需要同时处理来来自N个客户端的事件。
C++网络编程（五）：IO多路复用实现并发服务器
weixin_44164489的博客
10-05 2451
目录前置知识五种IO模型阻塞i/o非阻塞I/O模型I/O复用模型信号驱动I/O模型异步I/O模型五种I/O模型比较selectselect引入seclect应用实例POLLepoll总结select poll epoll区别参考资料 前置知识 1.Unix五种IO模型 [1] blocking IO - 阻塞IO [2] nonblocking IO - 非阻塞IO [3] IO multiplexing - IO多路复用 [4] signal driven IO - 信号驱动IO [5] asynchro
高并发服务器--多路IO转接（多路IO复用）
qq_53137764的博客
02-17 1672
多路IO转接三种方式：select（windows, 跨平台）、poll（少用）、epoll（linux）。多路IO转接服务器也叫做多任务IO服务器。该类服务器实现的主旨思想时，不再由应用程序自己监视客户端连接，取而代之由内核替应用程序监视文件。
电子词典查询业务，c语言数据库，tcp服务器以及epoll IO多路复用的网络编程项目
03-27
这个项目的核心在于理解和应用TCP服务器、数据库管理和IO多路复用技术，特别是epoll模型，来提高系统的效率和并发处理能力。 首先，让我们深入理解TCP服务器。TCP（Transmission Control Protocol）是一种面向连接...
CC编程语言_多线程并发编程_网络通信与高性能服务器开发_基于Linux系统调用的Socket编程实现HTTP服务器与客户端通信案例_包含线程池设计模式与IO多路复用技术实践.zip
04-30
CC编程语言，虽然在名称上可能有些误导，实际上应该指的是C或C++语言，是构建高性能服务器的常用编程语言，因其性能优势和对底层操作的控制能力，特别适合用于网络通信和多线程并发编程。 多线程并发编程是实现高...
Linux网络编程高级课程课件：并发与IO复用
Linux网络编程是指在Linux操作系统上进行的计算机网络通信编程。Linux作为一个类Unix系统，拥有强大的网络编程能力，支持多种网络编程接口和方法。以下是对标题、描述和标签中提到的知识点的详细解释： 1. Linux...
Linux 网络数据收发全栈工具书：从 nc、socat 到 iperf3 的 Buildroot 路径与跨平台实战
最新发布
leichaohahah的博客
08-26 575
Packet Sender ✅ 跨平台 GUI GitHub Releases 下载 exe，支持 TCP/UDP/SSL 一键发包。Linux 网络数据收发全栈工具书：从 nc、socat 到 iperf3 的 Buildroot 路径与跨平台实战。nc/socat/tcpdump ✅ 通过 WSL 或 Cygwin Windows Store 装 WSL →。标签：Linux、Buildroot、网络调试、iperf3、netcat、Windows、tcpdump。四、Windows 也能用吗？
C# .NET Framework 4.0 网络编程完全指南
weixin_45690427的博客
08-26 318
FTP是用于在网络上进行文件传输的标准协议，工作在TCP/IP协议族的应用层，使用21端口进行控制连接，20端口进行数据传输。SFTP是基于SSH协议的安全文件传输协议，提供加密的文件传输功能。.NET Framework 4.0原生不支持SFTP，需要使用第三方库如SSH.NET。SCP是基于SSH协议的文件传输协议，用于在网络主机间安全地传输文件。同样需要使用SSH.NET库。// 上传文件try。
Modbus Tcp 协议介绍
luck_lsj的博客
08-26 760
Modbus TCP协议是基于TCP/IP网络的Modbus协议变种，支持多从站同时访问主站并通过事务标识符区分并发请求。其报文结构包含7字节MBAP头（含事务标识、协议标识等）和功能码+数据域。主要功能码包括03(读保持寄存器)、06(写单个寄存器)和10(写多个寄存器)。文中详细解析了各功能码的请求/响应报文格式，并通过具体案例展示了十六进制报文的结构和字节含义。该协议支持1-247从站地址，采用大端字节序传输数据，适用于工业自动化领域的设备通信。
深度学习篇---常用主干网络
道阻且长，行则将至。
08-26 1059
本文系统梳理了深度学习中的CNN网络架构，按核心功能分为四类：1）基础特征提取网络（LeNet-5、AlexNet、VGGNet）；2）轻量化网络（MobileNet、ShuffleNet）；3）特征融合网络（DenseNet、InceptionNet）；4）细粒度识别网络（SENet）。每类网络针对不同应用场景设计了独特结构，如MobileNet采用深度可分离卷积实现移动端部署，DenseNet通过密集连接提升特征复用率。文章通过对比各网络的核心设计、优势及适用场景，为不同计算需求和任务特点提供了选型参考
Vmware虚拟机 处理器配置选项配置介绍
m0_57249200的博客
08-23 1112
vmware 虚拟机 处理器 和网络功能配置介绍
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值