盘算机网络编程 | 并发服务器代码实现（多进程/多线程） ...

   接待关注博主 Mindtechnist 或到场【Linux C/C++/Python社区】一起学习和分享Linux、C、C++、Python、Matlab，呆板人运动控制、多呆板人协作，智能优化算法，滤波估计、多传感器信息融合，呆板学习，人工智能等相关领域的知识和技术。
  

---

  
   
  

---

  专栏：《网络编程》
  

---

什么是并发服务器

当涉及到构建高性能的服务器应用步伐时，我们通常会考虑利用并发服务器来处置惩罚多个客户端哀求。在并发服务器中，多进程和多线程是两种常见的并发模型，它们都有各自的优点和实用场景。本文将介绍多进程和多线程并发服务器的基础知识。
多进程并发服务器
多进程并发服务器通过创建多个子进程来处置惩罚客户端哀求。每个子进程是操纵系统中独立运行的单位，拥有自己的内存空间和资源。当有新的客户端连接哀求到达时，服务器创建一个新的子进程来处置惩罚该哀求。子进程负责与客户端通讯并提供所需的服务。
多进程并发服务器的优点是稳定性高。由于每个子进程都是相互独立的，一个子进程的瓦解或错误不会影响其他子进程的实验。这种独立性使得多进程并发服务器能够有效地隔离错误，提高服务器的可靠性。
然而，多进程并发服务器也有一些缺点。创建和管理多个进程必要消耗更多的系统资源，包罗内存和CPU时间。进程间的通讯也必要特殊的机制，例如管道或共享内存，以便在差别进程之间传递数据。别的，由于每个进程都有自己的内存空间，进程间的数据共享和同步可能会变得复杂。
多线程并发服务器
多线程并发服务器通过创建多个线程来处置惩罚客户端哀求。线程是在进程内部运行的独立实验流，共享同一个进程的内存空间和资源。与多进程差别，多线程服务器不必要创建新的进程来处置惩罚哀求，而是在同一个进程中创建多个线程。
多线程并发服务器的优点是资源消耗较少。与进程相比，线程的创建和切换开销更小，因为它们共享进程的资源。这使得多线程并发服务器更加轻量级，能够更高效地利用系统资源。
然而，多线程并发服务器也存在一些问题。起首，线程共享进程的内存空间，因此在多线程环境中访问共享数据必要特殊的同步机制，以克制竞态条件和数据不一致。其次，由于线程共享相同的地点空间，一个线程的错误可能会影响整个进程，导致服务器瓦解或不稳定。
选择适合的并发模型
在选择多进程还是多线程并发服务器时，必要根据具体的应用需求和性能要求举行权衡。以下是一些发起：

• 假如稳定性和容错性是首要考虑因素，多进程并发服务器可能是更好的选择。每个子进程的独立性可以有效地隔离错误，提高服务器的可靠性。
  
• 假如服务器必要处置惩罚大量的并发连接并必要更高的性能和资源利用率，多线程并发服务器可能更适合。线程的创建和切换开销相对较小，可以更高效地处置惩罚并发哀求。
  
• 假如同时必要稳定性和性能，可以考虑利用混淆模型，即在每个进程中创建多个线程，以实现更好的负载平衡和资源利用率。
  

无论选择多进程还是多线程并发服务器，都必要留意正确处置惩罚并发访问共享数据的问题，利用适当的同步机制（如锁、信号量）来保证数据的一致性和正确性。
总结起来，多进程和多线程并发服务器是实现高性能服务器的常见方式。它们各有优劣，选择符合的并发模型必要考虑应用需求和性能要求，并留意处置惩罚并发访问共享数据的问题。
多进程并发服务器代码实现

利用多进程并发服务器时要考虑以下几点：

• 父进程最大文件描述个数(父进程中必要close关闭accept返回的新文件描述符)；
  
• 系统内创建进程个数(与内存巨细相关)；
  
• 进程创建过多是否低沉整体服务性能(进程调度)；
  

server

1. /* server.c */
2. #include <stdio.h>
3. #include <string.h>
4. #include <netinet/in.h>
5. #include <arpa/inet.h>
6. #include <signal.h>
7. #include <sys/wait.h>
8. #include <sys/types.h>
9. #include "wrap.h"
11. #define MAXLINE 80
12. #define SERV_PORT 800
14. void do_sigchild(int num)
15. {
16.         while (waitpid(0, NULL, WNOHANG) > 0)
17.                 ;
18. }
19. int main(void)
20. {
21.         struct sockaddr_in servaddr, cliaddr;
22.         socklen_t cliaddr_len;
23.         int listenfd, connfd;
24.         char buf[MAXLINE];
25.         char str[INET_ADDRSTRLEN];
26.         int i, n;
27.         pid_t pid;
29.         struct sigaction newact;
30.         newact.sa_handler = do_sigchild;
31.         sigemptyset(&newact.sa_mask);
32.         newact.sa_flags = 0;
33.         sigaction(SIGCHLD, &newact, NULL);
35.         listenfd = Socket(AF_INET, SOCK_STREAM, 0);
37.         bzero(&servaddr, sizeof(servaddr));
38.         servaddr.sin_family = AF_INET;
39.         servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
40.         servaddr.sin_port = htons(SERV_PORT);
42.         Bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
44.         Listen(listenfd, 20);
46.         printf("Accepting connections ...\n");
47.         while (1) {
48.                 cliaddr_len = sizeof(cliaddr);
49.                 connfd = Accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);
51.                 pid = fork();
52.                 if (pid == 0) {
53.                         Close(listenfd);
54.                         while (1) {
55.                                 n = Read(connfd, buf, MAXLINE);
56.                                 if (n == 0) {
57.                                         printf("the other side has been closed.\n");
58.                                         break;
59.                                 }
60.                                 printf("received from %s at PORT %d\n",
61.                                                 inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)),
62.                                                 ntohs(cliaddr.sin_port));
63.                                 for (i = 0; i < n; i++)
64.                                         buf[i] = toupper(buf[i]);
65.                                 Write(connfd, buf, n);
66.                         }
67.                         Close(connfd);
68.                         return 0;
69.                 } else if (pid > 0) {
70.                         Close(connfd);
71.                 } else
72.                         perr_exit("fork");
73.         }
74.         Close(listenfd);
75.         return 0;
76. }

复制代码

client

1. /* client.c */
2. #include <stdio.h>
3. #include <string.h>
4. #include <unistd.h>
5. #include <netinet/in.h>
6. #include "wrap.h"
8. #define MAXLINE 80
9. #define SERV_PORT 6666
11. int main(int argc, char *argv[])
12. {
13.         struct sockaddr_in servaddr;
14.         char buf[MAXLINE];
15.         int sockfd, n;
17.         sockfd = Socket(AF_INET, SOCK_STREAM, 0);
19.         bzero(&servaddr, sizeof(servaddr));
20.         servaddr.sin_family = AF_INET;
21.         inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);
22.         servaddr.sin_port = htons(SERV_PORT);
24.         Connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
26.         while (fgets(buf, MAXLINE, stdin) != NULL) {
27.                 Write(sockfd, buf, strlen(buf));
28.                 n = Read(sockfd, buf, MAXLINE);
29.                 if (n == 0) {
30.                         printf("the other side has been closed.\n");
31.                         break;
32.                 } else
33.                         Write(STDOUT_FILENO, buf, n);
34.         }
35.         Close(sockfd);
36.         return 0;
37. }

复制代码

多线程并发服务器代码实现

在利用线程模型开发服务器时需考虑以下问题：

• 调解进程内最大文件描述符上限；
  
• 线程如有共享数据，考虑线程同步；
  
• 服务于客户端线程退出时，退出处置惩罚（退出值，分离态）；
  
• 系统负载，随着链接客户端增长，导致其它线程不能实时得到CPU；
  

server

1. /* server.c */
2. #include <stdio.h>
3. #include <string.h>
4. #include <netinet/in.h>
5. #include <arpa/inet.h>
6. #include <pthread.h>
8. #include "wrap.h"
9. #define MAXLINE 80
10. #define SERV_PORT 6666
12. struct s_info {
13.         struct sockaddr_in cliaddr;
14.         int connfd;
15. };
16. void *do_work(void *arg)
17. {
18.         int n,i;
19.         struct s_info *ts = (struct s_info*)arg;
20.         char buf[MAXLINE];
21.         char str[INET_ADDRSTRLEN];
22.         /* 可以在创建线程前设置线程创建属性,设为分离态,哪种效率高内？ */
23.         pthread_detach(pthread_self());
24.         while (1) {
25.                 n = Read(ts->connfd, buf, MAXLINE);
26.                 if (n == 0) {
27.                         printf("the other side has been closed.\n");
28.                         break;
29.                 }
30.                 printf("received from %s at PORT %d\n",
31.                                 inet_ntop(AF_INET, &(*ts).cliaddr.sin_addr, str, sizeof(str)),
32.                                 ntohs((*ts).cliaddr.sin_port));
33.                 for (i = 0; i < n; i++)
34.                         buf[i] = toupper(buf[i]);
35.                 Write(ts->connfd, buf, n);
36.         }
37.         Close(ts->connfd);
38. }
40. int main(void)
41. {
42.         struct sockaddr_in servaddr, cliaddr;
43.         socklen_t cliaddr_len;
44.         int listenfd, connfd;
45.         int i = 0;
46.         pthread_t tid;
47.         struct s_info ts[256];
49.         listenfd = Socket(AF_INET, SOCK_STREAM, 0);
51.         bzero(&servaddr, sizeof(servaddr));
52.         servaddr.sin_family = AF_INET;
53.         servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
54.         servaddr.sin_port = htons(SERV_PORT);
56.         Bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
57.         Listen(listenfd, 20);
59.         printf("Accepting connections ...\n");
60.         while (1) {
61.                 cliaddr_len = sizeof(cliaddr);
62.                 connfd = Accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);
63.                 ts[i].cliaddr = cliaddr;
64.                 ts[i].connfd = connfd;
65.                 /* 达到线程最大数时，pthread_create出错处理, 增加服务器稳定性 */
66.                 pthread_create(&tid, NULL, do_work, (void*)&ts[i]);
67.                 i++;
68.         }
69.         return 0;
70. }

复制代码

client

1. /* client.c */
2. #include <stdio.h>
3. #include <string.h>
4. #include <unistd.h>
5. #include <netinet/in.h>
6. #include "wrap.h"
7. #define MAXLINE 80
8. #define SERV_PORT 6666
9. int main(int argc, char *argv[])
10. {
11.         struct sockaddr_in servaddr;
12.         char buf[MAXLINE];
13.         int sockfd, n;
15.         sockfd = Socket(AF_INET, SOCK_STREAM, 0);
17.         bzero(&servaddr, sizeof(servaddr));
18.         servaddr.sin_family = AF_INET;
19.         inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);
20.         servaddr.sin_port = htons(SERV_PORT);
22.         Connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
24.         while (fgets(buf, MAXLINE, stdin) != NULL) {
25.                 Write(sockfd, buf, strlen(buf));
26.                 n = Read(sockfd, buf, MAXLINE);
27.                 if (n == 0)
28.                         printf("the other side has been closed.\n");
29.                 else
30.                         Write(STDOUT_FILENO, buf, n);
31.         }
32.         Close(sockfd);
33.         return 0;
34. }

复制代码

618图书保举

   书籍是知识的海洋，盘算机好书保举