当前位置： 首页 > article >正文

Linux网络编程——TCP并行服务器

article 2025/3/9 11:47:46

        在 Linux 网络编程中，通过不同的技术来实现一个 TCP 并行服务器，能够有效地处理多个客户端连接。我们可以使用 多线程、多进程进程池 和 I/O 多路复用（如 select、poll 或 epoll）来提高服务器的性能。以下是分步实现的代码示例：

1. 使用多线程实现 TCP 并行服务器

多线程服务器：

        多线程服务器会为每个客户端请求创建一个新线程来处理它们。这样可以让服务器同时处理多个客户端，但线程过多会增加上下文切换的开销。

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

#define LISMAXNUM    1024

int init_udp_ser(const char *ip, unsigned short port)
{
	struct sockaddr_in seraddr;
	seraddr.sin_family = AF_INET;
	seraddr.sin_port = htons(port);
	seraddr.sin_addr.s_addr = inet_addr(ip);

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

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

	return sockfd;
}

void handler(int signo)
{
	wait(NULL);
}

void *thread(void *arg)
{
	int connfd = *(int *)arg;
	char buff[512] = {0};

	while (1)
	{
		memset(buff, 0, sizeof(buff));
		ssize_t size = recv(connfd, buff, sizeof(buff), 0);
		if (size < 0)
		{
			close(connfd);
			return NULL;
		}
		
		if (size == 0)
		{
			close(connfd);
			return NULL;
		}
		printf("%s\n", buff);

		size = send(connfd, buff, strlen(buff), 0);
		if (size < 0)
		{
			close(connfd);
			return NULL;
		}
	}
}

int main(int argc, const char *argv[])
{
	struct sockaddr_in cli;

	socklen_t clilen = sizeof(cli); 

	signal(SIGCHLD, handler);

	int sockfd = init_udp_ser("192.168.1.178", 50000);
	if (sockfd < 0)
	{
		return -1;
	}

	while (1)
	{
		int connfd = accept(sockfd, (struct sockaddr *)&cli, &clilen);
		if (connfd < 0)
		{
			perror("fail accept");
			return -1;
		}

		pthread_t tid;
		pthread_create(&tid, NULL, thread, &connfd);

		pthread_detach(tid);

	}

	close(sockfd);

	return 0;
}
主要流程：
  1. 创建套接字：服务器通过 socket() 创建 TCP 套接字。
  2. 绑定与监听：通过 bind() 和 listen() 绑定端口并等待客户端连接。
  3. 创建线程：每当有一个客户端连接时，通过 pthread_create() 创建一个新线程来处理客户端请求。
  4. 回显客户端消息：线程处理客户端的消息接收与发送。

2. 使用多进程进程池实现 TCP 并行服务器

多进程服务器：

多进程服务器通过 fork() 创建多个子进程，每个子进程处理一个客户端连接。

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

#define LISMAXNUM    1024

int init_udp_ser(const char *ip, unsigned short port)
{
	struct sockaddr_in seraddr;
	seraddr.sin_family = AF_INET;
	seraddr.sin_port = htons(port);
	seraddr.sin_addr.s_addr = inet_addr(ip);

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

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

	return sockfd;
}

void handler(int signo)
{
	wait(NULL);
}


int main(int argc, const char *argv[])
{
	struct sockaddr_in cli;

	socklen_t clilen = sizeof(cli); 

	signal(SIGCHLD, handler);

	int sockfd = init_udp_ser("192.168.1.178", 50000);
	if (sockfd < 0)
	{
		return -1;
	}

	while (1)
	{
		int connfd = accept(sockfd, (struct sockaddr *)&cli, &clilen);
		if (connfd < 0)
		{
			perror("fail accept");
			return -1;
		}

		pid_t pid = fork();
		if (pid < 0)
		{
			perror("fail fork");
			return -1;
		}

		if (0 == pid)
		{
			char buff[512] = {0};

			while (1)
			{
				memset(buff, 0, sizeof(buff));
				ssize_t size = recv(connfd, buff, sizeof(buff), 0);
				if (size < 0)
				{
					close(connfd);
					exit(1);
				}
				
				if (size == 0)
				{
					close(connfd);
					exit(1);
				}
				printf("%s\n", buff);

				size = send(connfd, buff, strlen(buff), 0);
				if (size < 0)
				{
					close(connfd);
					exit(1);
				}
			}
		}
		else if (pid > 0)
		{
			
		}
	}

	close(sockfd);

	return 0;
}
主要流程：
  1. 创建套接字：通过 socket() 创建 TCP 套接字。
  2. 绑定与监听：使用 bind() 和 listen() 绑定地址并开始监听。
  3. fork() 创建子进程：每当有客户端连接时，父进程通过 fork() 创建一个新的子进程来处理该客户端。
  4. 处理客户端：子进程使用 recv() 和 send() 与客户端进行交互，并回显客户端的消息。

3. 线程池

        提前预创建大量线程，避免任务执行过程中创建线程的耗时。

3. 使用 I/O 多路复用（select）实现 TCP 并行服务器

   select 是一种 I/O 多路复用技术，允许一个进程或线程监视多个文件描述符的状态变化。使用 select 使得服务器能够同时处理多个客户端的请求。

select 实现服务器代码：
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
#include <unistd.h> 
#include <sys/types.h> 
#include <sys/socket.h> 
#include <arpa/inet.h> 
#include <netinet/in.h> 
#include <sys/select.h>


#define LISMAXNUM    1024

int init_udp_ser(const char *ip, unsigned short port)
{
	struct sockaddr_in seraddr;
	seraddr.sin_family = AF_INET;
	seraddr.sin_port = htons(port);
	seraddr.sin_addr.s_addr = inet_addr(ip);

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

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

	return sockfd;
}


int main(int argc, const char *argv[])
{
	char buff[512] = {0};
	struct sockaddr_in cli;

	socklen_t clilen = sizeof(cli); 

	int sockfd = init_udp_ser("192.168.1.164", 50000);
	if (sockfd < 0)
	{
		return -1;
	}

	int maxfd = -1;
	fd_set rdfds;
	fd_set tmpfds;
	FD_ZERO(&rdfds);

	FD_SET(sockfd, &rdfds);
	maxfd = maxfd > sockfd ? maxfd : sockfd;

	while (1)
	{
		tmpfds = rdfds;
		int cnt = select(maxfd+1, &tmpfds, NULL, NULL, NULL);
		if (cnt < 0)
		{
			perror("fail select");
			return -1;
		}

		for (int i = 0; i < maxfd+1; i++)
		{
			if (FD_ISSET(i, &tmpfds))
			{
				if (i == sockfd)
				{
					int connfd = accept(sockfd, (struct sockaddr *)&cli, &clilen);
					if (connfd < 0)
					{
						perror("fail accept");
						continue;
					}

					FD_SET(connfd, &rdfds);
					maxfd = maxfd > connfd ? maxfd : connfd;
				}
				else
				{
					memset(buff, 0, sizeof(buff));
					ssize_t size = recv(i, buff, sizeof(buff), 0);
					if (size < 0)
					{
						perror("fail recv");
						FD_CLR(i, &rdfds);
						close(i);
						continue;
					}
					
					if (size == 0)
					{
						FD_CLR(i, &rdfds);
						close(i);
						continue;
					}
					printf("%s\n", buff);

					strcat(buff, "------>OK");
					size = send(i, buff, strlen(buff), 0);
					if (size < 0)
					{
						perror("fail send");
						FD_CLR(i, &rdfds);
						close(i);
						continue;
					}
				}
			}
		}
	}

	close(sockfd);

	return 0;
}
主要流程：
  1. 创建套接字：通过 socket() 创建 TCP 套接字。
  2. 绑定与监听：使用 bind() 和 listen() 绑定地址并开始监听。
  3. select：监听多个套接字的状态变化，通过非阻塞方式检测哪些客户端有数据可以处理
    1. 创建文件描述符集合
    2. 将关注的文件描述符加入到集合
    3.  等待IO事件到达
    4.  根据不同的IO事件处理不同的任务

总结

  • 多线程实现：每当有客户端连接时，服务器创建一个线程来处理该连接。适合连接数适中的情况，但线程数过多时可能会带来性能问题

  • 多进程实现：通过 fork() 创建子进程来处理每个客户端。

  • I/O 多路复用（select）实现：服务器通过 select 等待多个客户端的事件，适用于大量客户端连接，且无需为每个连接创建线程或进程。

    • select使用位图管理文件描述符，最多允许同时监测1024个文件描述符（有上限）；

    •  文件描述符集合在应用层创建，需要实现应用层和内核层的反复拷贝；

    •  需要应用层对集合表进行遍历，寻找到达的事件；

    •  只能工作在水平触发模式（低速模式），不能工作在边沿触发模式（高速模式） 。


http://www.kler.cn/a/574544.html

相关文章：

  • Swagger UI界面的使用
  • Ae 效果详解：VR 球面到平面
  • 【解决问题】conda 虚拟环境内，`pip list` 展示全局的包
  • 通往 AI 之路：Python 机器学习入门-机器学习基本概念
  • redis 过期键删除策略与回收策略
  • 2025中国AI大模型对比
  • Spring Boot API 项目中 HAProxy 与 Nginx 的选择与实践
  • 【Linux内核系列】：进入文件系统的世界
  • 激光雷达市场观察2-美国 PLI 发展脉络与核心技术解析2025.3.7
  • 安铂克科技 APPH 系列相位噪声分析仪：高性能测量的卓越之选
  • Sqlserver安全篇之_手工创建TLS用到的pfx证书文件
  • Halcon:HObject与opencv:Mat互转
  • 【目标检测】【CVPR 2025】DEIM：具有改进匹配机制的DETR以实现快速收敛
  • Scala：case class（通俗易懂版）
  • DeepSeek大模型深度解析：架构、技术与应用全景
  • Pandas实现Excel的vlookup并且在指定列后面输出
  • Hadoop项目中的问题（1）——NetworkManager 和 network 服务冲突
  • AutoGen学习笔记系列（七）Tutorial - Managing State
  • 亚信安全发布2024威胁年报和2025威胁预测
  • Ubuntu20.04本地配置IsaacLab 4.2.0的G1训练环境（二）：训练与推理