【Linux网络编程】TCP并发服务器的实现（IO多路复用select）

已于 2022-08-20 12:12:13 修改
阅读量2.9k 收藏 77
点赞数 25
分类专栏： 网络编程 文章标签： 服务器 网络 linux tcp/ip c语言
于 2022-08-16 20:36:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65835264/article/details/126371385
版权

文章目录

一、服务器模型

1.1 服务器概念

服务器模型主要分为两种，循环服务器和并发服务器。

循环服务器：
在同一时间只能处理一个客户端的请求。
并发服务器：
在同一时间内能同时处理多个客户端的请求。

TCP的服务器默认的就是一个循环服务器，原因是有两个阻塞 accept函数 和recv函数 之间会相互影响。
UDP的服务器默认的就是一个并发服务器，因为只有一个阻塞的 recvfrom函数。

1.2 TCP并发服务器的意义

在有些应用场景下，我们既要保证数据可靠，又要支持并发
这就需要用到TCP并发服务器。

1.3 实现TCP并发服务器的方式

  1. 使用多路IO复用实现TCP并发服务器(常用)
  2. 使用多进程实现TCP并发服务器
  3. 使用多线程实现TCP并发服务器

本次我们学习第一个方式，使用多路IO复用(select函数)实现TCP并发服务器的实现，在后续博客中我们会依次讲解其他实现方式。
感兴趣可以收藏加关注哦。

二、使用IO多路复用实现TCP并发服务器优势

对于实际开发过程中：
如果使用多进程实现TCP并发服务器，并发量大的时候，对系统的资源占用量也会很大。

如果使用多线程，业务逻辑复杂的时候，又涉及到临近资源访问的问题
比较好的方式是使用多路IO复用实现TCP并发服务器。

三、select函数

功能：
	实现IO多路复用
头文件：
	 #include <sys/select.h>
函数原型：
	int select(int nfds, fd_set *readfds, fd_set *writefds,
               fd_set *exceptfds, struct timeval *timeout);
参数
	@nfds：监视的最大文件描述符+1
	@readfds：要监视的读文件描述符集合,如果不关心，可以传NULL
	@writefds：要监视的写文件描述符集合,如果不关心，可以传NULL
	@exceptfds：要监视的异常的文件描述符集合,如果不关心，可以传NULL
	(一般我们只关心readfds)
	@timeout：超时时间
		为0时非阻塞
		为NULL时永久阻塞
		为结构体时阻塞一定时间
返回值：
	成功  返回就绪文件描述符的个数
	失败  返回-1，置位错误码
	超时  返回0

	
void FD_CLR(int fd, fd_set *set);
功能：
	删除集合中的文件描述符
参数：
	@fd：文件描述符
	@set：构建要监视的文件描述符集合
	
int  FD_ISSET(int fd, fd_set *set);
功能：
	判断文件描述符是否在集合中
参数：
	@fd：文件描述符
	@set：构建要监视的文件描述符集合
返回值：
	为0时不在里面
	非0时在里面
	
void FD_SET(int fd, fd_set *set);
功能：
	将文件描述符添加到集合中
参数：
	@fd：文件描述符
	@set：构建要监视的文件描述符集合
	
void FD_ZERO(fd_set *set);
功能：
	清空集合
参数：
	@set：构建要监视的文件描述符集合

注意：

  1. select只能监视小于 FD_SETSIZE(1024) 的文件描述符。
  2. select函数在返回时会将没有就绪的文件描述符在表中擦除，
    所以，在循环中调用select时，每次需要重新填充集合。

四、TCP并发服务器的构建

4.1 创建套接字

使用socket函数创建IPV4、TCP套接字

	int sockfd;
    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    {
        ERRLOG("socket error");
    }

4.2 填写服务器网络信息结构体

	struct sockaddr_in serviceaddr;
    memset(&serviceaddr, 0, sizeof(serviceaddr));
    serviceaddr.sin_family = AF_INET;
    serviceaddr.sin_addr.s_addr = inet_addr(argv[1]);
    serviceaddr.sin_port = htons(atoi(argv[2]));
    socklen_t serviceaddr_len = sizeof(serviceaddr);

4.3 将服务器网络信息结构体与套接字绑定

	if (bind(sockfd, (struct sockaddr *)&serviceaddr, serviceaddr_len) == -1)
    {
        ERRLOG("bind error");
    }

4.4 将套接字设置为被动监听状态

	if (listen(sockfd, 5) == -1)
    {
        ERRLOG("listen error");
    }

4.5 创建文件描述符集合母本和子本并进行清空操作

	fd_set readfds;
    FD_ZERO(&readfds);
    fd_set readfds_msg;
    FD_ZERO(&readfds_msg);

4.6 将sockfd添加进入集合内，并更新最大文件描述符

	FD_SET(sockfd, &readfds);
    max_fd = max_fd > sockfd ? max_fd : sockfd;

4.7 循环实现内部功能伪代码

 	while(1){
        select();
        //遍历文件描述符集合
        for(){
            if(sockfd就绪了){
                //说明有新的客户端建立连接了
                acceptfd = accept();
                将acceptfd加入到readfds中
                更新最大文件描述符
            }else{
                //说明有客户端发来数据了
                recv();
                //如果recv返回0了 需要将当前的客户端的acceptfd在
                //readfds中删除，后续就不再监视它了
                strcat();
                send();
            }
        }
    }

五、客户端的构建

5.1步骤一和二和4.1，4.2一样

5.2 尝试与服务器建立连接

	if(-1 == connect(sockfd, (struct sockaddr *)&serveraddr, serveraddr_len)){
        ERRLOG("connect error");
    }

5.3 内部功能实现伪代码

	while(1){
        //从终端获取数据写入buff中
        fgets();
        buff[strlen(buff)-1] = '\0';//清理结尾的\n

        //发送数据
        if(-1 == send(sockfd, buff, sizeof(buff), 0)){
            ERRLOG("send error");
        }
        
        //接收服务器的应答信息
        if(-1 == (nbytes = recv(sockfd, buff, sizeof(buff), 0))){
            ERRLOG("recv error");
        }   
    }

六、测试结果

使用三个客户端连接一个TCP并发服务器。

测试TCP并发服务器功能实现
在这里插入图片描述
测试quit退出功能实现
在这里插入图片描述
测试ctrl+c终止程序断开来连接实现
在这里插入图片描述
测试退出文件，清除客户端的文件描述符，在新的客户端连接时，从最小的文件描述符开始实现。
在这里插入图片描述
成功实现IO多路复用TCP并发服务器和客户端。

七、TCP并发服务器源代码

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

#define ERRLOG(msg)                                        \
    do                                                     \
    {                                                      \
        printf("%s %s %d:", __FILE__, __func__, __LINE__); \
        perror(msg);                                       \
        exit(-1);                                          \
    } while (0)

#define N 128

int main(int argc, const char *argv[])
{
    //检查入参合理性
    if (argc != 3)
    {
        printf("Usage : %s <IP> <PORT>\n", argv[0]);
        return -1;
    }
    //创建套接字
    int sockfd;
    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    {
        ERRLOG("socket error");
    }
    //填写服务器网络信息结构体
    struct sockaddr_in serviceaddr;
    memset(&serviceaddr, 0, sizeof(serviceaddr));
    serviceaddr.sin_family = AF_INET;
    serviceaddr.sin_addr.s_addr = inet_addr(argv[1]);
    serviceaddr.sin_port = htons(atoi(argv[2]));
    socklen_t serviceaddr_len = sizeof(serviceaddr);
    //将服务器网络信息结构体与套接字绑定
    if (bind(sockfd, (struct sockaddr *)&serviceaddr, serviceaddr_len) == -1)
    {
        ERRLOG("bind error");
    }
    //将套接字设置为被动监听状态
    if (listen(sockfd, 5) == -1)
    {
        ERRLOG("listen error");
    }
    char buf[N] = {0};
    int max_fd;
    int i;
    int ret;
    int acceptfd;
    int nbytes;
    //创建文件描述符集合母本和子本并进行清空操作
    fd_set readfds;
    FD_ZERO(&readfds);
    fd_set readfds_msg;
    FD_ZERO(&readfds_msg);
    //将sockfd添加进入集合内，并跟新最大文件描述符
    FD_SET(sockfd, &readfds);
    max_fd = max_fd > sockfd ? max_fd : sockfd;

    while (1)
    {
        //在每次循环前将子本重新赋值，因为select会将没有就绪的文件描述符在集合内擦除
        readfds_msg = readfds;
        if ((ret = select(max_fd + 1, &readfds_msg, NULL, NULL, NULL)) == -1)
        {
            ERRLOG("select error");
        }
        else //说明有文件描述符就绪了
        {
            //遍历文件描述符
            for (i = 3; i < max_fd + 1 && ret != 0; i++)
            {
                //判断是哪个文件描述符就绪了
                if (FD_ISSET(i, &readfds_msg))
                {
                	ret--;
                    if (i == sockfd) //如果套接字就绪了则等待客户端连接
                    {
                        if ((acceptfd = accept(sockfd, NULL, NULL)) == -1)
                        {
                            ERRLOG("accept error");
                        }
                        printf("客户端[%d]连接到服务器..\n", acceptfd);
                        //如果有客户端连接将产生的新的文件描述符添加到集合中,并更新最大文件描述符
                        FD_SET(acceptfd, &readfds);
                        max_fd = max_fd > acceptfd ? max_fd : acceptfd;
                    }
                    else //否则就是客户端发来消息了
                    {
                        memset(buf, 0, N);
                        if ((nbytes = recv(i, buf, N, 0)) == -1)
                        {
                            ERRLOG("recv error");
                        }
                        else if (nbytes == 0)
                        {
                            printf("客户端[%d]已断开连接..\n", i);
                            close(i);            //关闭当前客户端的文件描述符
                            FD_CLR(i, &readfds); //将该客户端的文件描述符在集合中删除
                            continue;
                        }
                        if (strcmp(buf, "quit") == 0)
                        {
                            printf("客户端[%d]已退出服务器..\n", i);
                            close(i);
                            FD_CLR(i, &readfds);
                            continue;
                        }
                        printf("客户端[%d]发来消息[%s]..\n", i, buf);
                        strcat(buf, "--夜猫徐");      //组装应答
                        if (send(i, buf, N, 0) == -1) //发送给客户端
                        {
                            ERRLOG("send error");
                        }
                    }
                }
            }
        }
    }
    close(sockfd);
    return 0;
}

八、客户端源代码

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

#define ERRLOG(msg) do{\
        printf("%s %s %d:", __FILE__, __func__, __LINE__);\
        perror(msg);\
        exit(-1);\
}while(0)

#define N 128

int main(int argc, const char *argv[]){
    //入参合理性检查
    if(3 != argc){
        printf("Usage : %s <IP> <PORT>\n", argv[0]);
        return -1;
    }

    //1.创建套接字
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if(-1 == sockfd){
        ERRLOG("socket error");
    }

    //2.填充服务器网络信息结构体
    struct sockaddr_in serveraddr;
    memset(&serveraddr, 0, sizeof(serveraddr));
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_port = htons(atoi(argv[2]));
    serveraddr.sin_addr.s_addr = inet_addr(argv[1]);

    socklen_t serveraddr_len = sizeof(serveraddr);

    char buff[128] = {0};
    int nbytes = 0;

    //3.尝试与服务器建立连接
    if(-1 == connect(sockfd, (struct sockaddr *)&serveraddr, serveraddr_len)){
        ERRLOG("connect error");
    }
    printf("与服务器建立连接成功..\n");
    while(1){
        memset(buff, 0, sizeof(buff));
        fgets(buff, N, stdin);
        buff[strlen(buff)-1] = '\0';//清理结尾的\n

        //发送数据
        if(-1 == send(sockfd, buff, sizeof(buff), 0)){
            ERRLOG("send error");
        }
        //接收服务器的应答信息
        if(-1 == (nbytes = recv(sockfd, buff, sizeof(buff), 0))){
            ERRLOG("recv error");
        }
        if(0 == nbytes){
            break;
        }
        //输出应答信息
        printf("应答为:[%s]\n", buff);
    }
    //关闭套接字
    close(sockfd);

    return 0;
}
夜猫徐
关注
  • 25
    点赞
  • 踩
  • 77
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 35
    评论
专栏目录
linux使用TCP聊天室设计详解,基于linux的TCP网络聊天室设计与实现
weixin_28687331的博客
05-15 1329
利用Linux实现基于TCP模式的网络聊天程序主要完成的两大组成部分为：服务器和客户端。服务器程序主要负责监听客户端发来的消息。 客户端需要登录到服务器端才可以实现正常的聊天功能。该程序是利用进程以及共享内存来实现群发送消息的。以下简单分析一下服务器端和客户端两个方面所要完成的任务。服务器的主要功能如下：在特定的端口上进行监听，等待客户端的连接。 用户可以配置服务器端的监听端口。 向连接的客户端发...
TCP服务器IO模型之多路复用（一）POLL函数.zip
09-20
总的来说，TCP服务器的多路复用IO模型通过POLL函数，有效地解决了高并发场景下服务器性能的问题，提升了服务的响应速度和系统资源利用率。在实际开发中，理解并熟练掌握POLL函数的使用对于构建高效、稳定的网络服务...
IO多路复用之select全面总结(必看篇)
01-10
1、基本概念 IO多路复用是指内核一旦发现进程指定的一个或者多个IO条件准备读取，它就通知该进程。IO多路复用适用如下场合： （1）当客户处理多个描述字时（一般是交互式输入和网络套接口），必须使用I/O复用。 （2）当一个客户同时处理多个套接口时，而这种情况是可能的，但很少出现。 （3）如果一个TCP服务器既要处理监听套接口，又要处理已连接套接口，一般也要用到I/O复用。 （4）如果一个服务器即要处理TCP，又要处理UDP，一般要使用I/O复用。 （5）如果一个服务器要处理多个服务或多个协议，一般要使用I/O复用。 与多进程和多线程技术相比，I/O多路复用技术的最大优势是系统开销小，系统不必创
Linux的tcp服务器连接的几种方式（线程、select、poll、epoll）
qq_57177980的博客
04-15 759
一连接一线程：在实际场景里，一万个连接可能就几个连接在收发数据，而剩下的的线程就处于等待状态，系统开销大且浪费。select：将需要处理的io集合拷贝进系统内核里遍历，然后将需要处理的io分成不同的集合返回。poll：poll和select的处理方式类似，但是相比select的接口更少。epoll：每当有一个io连接时就将其打包进系统内核，而系统内核只需要将需要事件处理的io返回即可，无需每次都将所有io集合拷贝进内核。（注意当io连接断开时，一定要将该io从内核中清除避免产生未知错误）
2024年Linux下TCP IP编程--TCP实战(select)_select tcp 项目实战(1)，缓存架构技术
最新发布
2401_84973104的博客
05-15 281
* 监听socket: serverfd,数据传输socket: acceptfd */struct sockaddr_in their_addr;/* 客户地址信息 */struct sockaddr_in my_addr;/* 本机地址信息 */
Linux环境使用select实现IO多路复用
weixin_42282363的博客
12-26 171
Linux环境使用select实现IO多路复用
Linux - 多路复用I/O [select]
m0_60154918的博客
08-21 407
所以这里的读事件表表示的就是 4号 5号 6号文件描述符代表的客户端已连接上了 3号文件描述符代表的服务器，并且已加入读事件表，事件响应标志位的0代表的是该客户端并未就绪。第二行为读事件响应标志位，该文件描述符读事件就绪就为1，没就绪就为零，这里举个例子。在多路复用IO模型中，会有一个线程不断去轮询多个socket的状态，只有当socket真。致后续的事件迟迟得不到处理，并且会影响新的事件轮询，在很大程度上降低了事件探测的及时性。如果试图建立一个简单的事件驱动的服务器程序，这个模型有一定的参考价值。
Linux下使用Select函数实现TCP并发服务器
weixin_44775420的博客
09-22 2025
使用Select函数实现TCP并发服务器（C语言）本文实现功能介绍Select函数使用说明服务器端代码客户端代码 本文实现功能介绍 在Linux下，使用socket编程，通过I/O端口的复用（select函数）实现了基于TCP协议的并发服务器，所谓并发，即可以同时处理数个客户端的连接请求或已建立连接的数据收发服务。 Select函数使用说明 下文中对于select函数的用法已经非常详尽，笔者这里不再赘述。 链接: https://blog.csdn.net/lingfengtengfei/article/d
IO多路复用实现TCPecho
03-02
在IT领域，IO多路复用是一种高效...通过这个TCP echo服务器的实现，你可以深入了解IO多路复用在实际项目中的应用，并锻炼你的网络编程和并发处理能力。这不仅有助于提升服务器性能，也是构建高可用、高并发服务的基础。
多路复用IO以及TCP并发服务器的实现（练习）
07-20
在计算机网络编程中，"多路复用IO"和"TCP并发服务器"是两个关键概念，它们对于构建高效、可扩展的网络服务至关重要。这里，我们将深入探讨这两个主题，并通过提供的文件名，我们可以推断出这是一个实践项目，旨在...
多进程&多路复用并发的http服务器
05-23
这种技术通过系统调用如`select`、`poll`、`epoll`（在Linux系统中）等实现，使得服务器能够高效地管理大量并发连接。 **Nginx的事件驱动模型** Nginx采用的是基于事件驱动的异步非阻塞模型，它结合了多路复用技术...
IO复用select+多线程.rar
04-27
本示例中的"IO复用select+多线程.rar"文件可能包含了以下内容： 1. `server.c`：服务器端代码，实现IO复用和多线程处理。 2. `client.c`：客户端代码，用于发起连接并接收服务器的时间。 3. 可能还有编译脚本和...
linux下socket编程IO多路复用select模型
双湖之梦的专栏
08-03 2202
今天学习了yix
Linux多路复用--结合网络Socket编程
weixin_43271542的博客
07-28 367
Linux多路复用--结合网络Socket编程前言一、多路复用介绍1.1 多路复用简介1.2 多路复用理解1.3 API函数介绍二、多路复用API函数详解2.1 select2.2 poll2.3 epoll2.4 函数对比三、源码效果与展示3.1 select源码3.2 select源码效果展示3.3 poll源码3.4 poll源码效果展示3.5 epoll源码3.6 epoll源码效果展示四、总结与反思 注：本文系湛江市岭南师范学院物联网俱乐部原创部分训练计划，转载请保留声明。 前言 今天是闭关的第2
Linux下的io多路复用的三种实现之—select（）
asdasd121312dasd的博客
11-21 283
io 多路复用是一种同步io的模型，实现一个线程可以同时监听多个文件描述符；一旦有某个监听的文件句柄就绪，就能够通知应用程序进行相应的读写操作没有文件句柄就绪就会阻塞应用程序，交出cpu多路是指网络连接，复用指的是同一个线程为什么要有io多路复用机制？我们先来看一段代码{if(ret
实现TCP并发服务器---IO多路复用
l2020429的博客
09-10 1710
分别使用select ，poll 实现TCP并发服务器
Linux C TCP服务器端-select案例
C++ 开发者的博客
01-12 3776
linux C TCP编程-select编程案例 I/O多路复用-高并发
Linux 网络编程——并发服务器的三种实现模型
热门推荐
秋叶原 && Mike || 麦克
05-12 9万+
服务器设计技术有很多，按使用的协议来分有 TCP 服务器和 UDP 服务器，按处理方式来分有循环服务器和并发服务器。循环服务器与并发服务器模型在网络程序里面，一般来说都是许多客户对应一个服务器（多对一），为了处理客户的请求，对服务端的程序就提出了特殊的要求。目前最常用的服务器模型有：·循环服务器：服务器在同一时刻只能响应一个客户端的请求·并发服务器：服务器在同一时刻可以响应多个客户端的请求UDP ...
并发TCP服务器 IO多路复用之select
e我所欲也的博客
06-23 1220
文章目录前言初识selectselect函数原型理解select执行过程socket就绪条件select使用示例: 检测标准输入输出select优缺点基于select的并发TCP服务器通信 前言 记得我们之前写的TCP客户端服务端通信小demo中有个小问题：accept函数和read函数一旦阻塞在其中一个中的话，另一个就没法对相应的请求做出响应，即如果在accept中等待一个连接请求，我们就不能响应输入的命令（接收数据）。类似地，如果在read中等待一个输入命令，我们就不能响应任何连接请求。但是一个并发服务
linux c tcpserver 多客户端
07-03
### 回答1： 在Linux环境下使用C语言编写一个TCP服务器来处理多个客户端的连接是很常见的需求。以下是一个基本的实现示例： 首先，我们需要创建一个服务器套接字，监听指定的端口。然后，我们需要使用`select`函数来实现多客户端的处理。`select`函数会阻塞直到某个套接字上有可读或可写的数据时才返回，我们可以利用这一特性来处理多个客户端的连接。 为了支持多个客户端，我们需要维护一个客户端套接字的集合，用于存储当前连接的客户端。每当有新的客户端连接到服务器时，我们将其套接字添加到这个集合中。 然后，我们使用`select`函数来监视所有的套接字，包括服务器套接字和客户端套接字。当`select`函数返回时，我们可以通过检查文件描述符集合中的每个套接字来确定哪个套接字上有可读或可写的数据。如果是服务器套接字上有可读的数据，表示有新的客户端请求连接，我们接受这个连接并将其套接字添加到客户端集合中。如果是客户端套接字上有可读的数据，表示客户端发送了数据，我们可以处理这些数据。如果是客户端套接字上有可写的数据，表示服务器可以向客户端发送数据。 在处理数据时，我们可以使用`recv`函数来接收来自客户端的数据，然后根据实际需求进行处理，比如打印或保存数据。如果需要向客户端发送数据，可以使用`send`函数来发送数据。 以上就是基于Linux下C语言实现多客户端TCP服务器的基本思路。需要注意的是，在实际的代码实现中，还需要处理一些异常情况，例如客户端断开连接时的处理。此外，还可以使用多线程或多进程来处理多个客户端的同时连接，以提高服务器的性能和并发处理能力。 ### 回答2： 在Linux C中，可以使用TCP服务器来处理多个客户端连接。以下是一个简单的示例代码： 1. 首先，创建一个套接字(socket)来监听客户端连接请求： ```c int sockfd = socket(AF_INET, SOCK_STREAM, 0); if (sockfd == -1) { perror("socket"); exit(EXIT_FAILURE); } struct sockaddr_in server_addr; server_addr.sin_family = AF_INET; server_addr.sin_port = htons(PORT); // 设置端口号 server_addr.sin_addr.s_addr = htonl(INADDR_ANY); // 监听所有网络接口 if (bind(sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr)) == -1) { perror("bind"); exit(EXIT_FAILURE); } listen(sockfd, BACKLOG); // 启动监听 ``` 2. 使用循环等待客户端连接： ```c while(1) { struct sockaddr_in client_addr; socklen_t addr_len = sizeof(client_addr); int client_fd = accept(sockfd, (struct sockaddr*)&client_addr, &addr_len); if (client_fd == -1) { perror("accept"); exit(EXIT_FAILURE); } printf("Accept a connection from %s:%d\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port)); // 在接受到客户端连接后，可以fork()一个子进程来处理该客户端，或者使用线程、多路复用等方式来处理多个客户端 // ... } ``` 3. 在处理连接后，可以进行相应的数据交互，如接收和发送数据，以及关闭连接等操作。 ```c // 读取客户端发送的数据 char buffer[MAX_BUFFER_SIZE]; int num_bytes = recv(client_fd, buffer, sizeof(buffer), 0); if (num_bytes == -1) { perror("recv"); exit(EXIT_FAILURE); } // 处理数据 // ... // 发送响应给客户端 char response[] = "Hello, client!"; if (send(client_fd, response, sizeof(response), 0) == -1) { perror("send"); exit(EXIT_FAILURE); } // 关闭与客户端的连接 close(client_fd); ``` 这是一个简单的多客户端TCP服务器的实现代码。当然，在实际应用中，可能需要处理更多的异常情况，如错误处理、客户端连接超时、并发访问等。同时，还可以使用线程池、epoll等技术来提高服务器的性能和并发处理能力。 ### 回答3： 在Linux C编程中，可以通过创建一个TCP服务器来处理多个客户端的连接请求。 首先，我们需要创建一个套接字，使用`socket()`函数，指定使用TCP协议，得到一个用于监听的套接字描述符。 ```c int serverSocket = socket(AF_INET, SOCK_STREAM, 0); ``` 然后，我们需要给服务器绑定一个地址和端口号，使用`bind()`函数，将套接字与特定的IP地址和端口号绑定。 ```c struct sockaddr_in serverAddress; serverAddress.sin_family = AF_INET; serverAddress.sin_port = htons(PORT); serverAddress.sin_addr.s_addr = INADDR_ANY; bind(serverSocket, (struct sockaddr*)&serverAddress, sizeof(serverAddress)); ``` 接下来，我们需要设置服务器监听队列的最大长度，使用`listen()`函数。 ```c listen(serverSocket, BACKLOG); ``` 现在，我们正式进入了服务器的工作循环，接受客户端的连接请求。 ```c while(1) { int clientSocket = accept(serverSocket, NULL, NULL); // 这里可以创建子进程或线程来处理客户端的连接 // 或使用非阻塞IO或异步IO来实现并发处理多个客户端 // 读取客户端发送的数据 char buffer[BUFFER_SIZE]; int bytesRead = recv(clientSocket, buffer, sizeof(buffer), 0); // 处理接收到的数据 // 发送数据给客户端 char response[] = "Hello, client!"; send(clientSocket, response, strlen(response), 0); // 关闭与客户端的连接 close(clientSocket); } ``` 以上就是一个简单的Linux C TCP服务器多客户端的实现。在实际应用中，可能需要使用多线程、多进程、非阻塞IO或者异步IO等技术来提高服务器的并发处理能力。
评论 35
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

夜猫徐

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值