网站制作 广州_建筑公司网站案例_站长工具是干嘛的_新乡seo优化

        在 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    1024int 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    1024int 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    1024int 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个文件描述符（有上限）；

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

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

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