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

        在 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;
}

主要流程：

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;
}

主要流程：

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;
}

主要流程：

总结

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

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

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

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

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

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

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