【网络编程】高性能并发服务器源码剖析

 

  hello ！大家好呀！ 接待大家来到我的网络编程系列之洪水网络攻击，在这篇文章中，你将会学习到在网络编程中怎样搭建一个高性能的并发服务器，而且我会给出源码进行剖析，以及手绘UML图来帮助大家来明白，盼望能让大家更能了解网络编程技能！！！
  盼望这篇文章能对你有所帮助

，大家要是觉得我写的不错的话，那就点点免费的小爱心吧！

  

               
  目录
一.网络服务器 
 1.1 平凡循环网络服务器

2.2 简单并发网络服务器
2.2.1简单的并发服务器模型
2.2.2使用历程的并发服务器
2.2.3使用线程的并发服务器
2.2.4其他并发服务器模型
二.使用互斥锁实现单线程处理单个客户
2.1 具体步骤
2.2服务器代码模板
三.源码剖析

---

一.网络服务器 

 1.1 平凡循环网络服务器

对于平凡的循环网络服务器，着实就是服务器使用循环的方法逐个对客户的毗连进行处理，处理完一个毗连后再处理下一个毗连，其过程如下：

最简单的代码模型我还是给大家：

1. #include<t_stdio.h>
2. #include<sys/types.h>         
3. #include <sys/socket.h>
4. #include<arpa/inet.h>
5. #include <sys/socket.h>
6. #include<ctype.h>
7. #include<unistd.h>
8. int main(void){
9.     struct sockaddr_in serv,cli;
10.     socklen_t cli_len;
11.     char buf[128];
12.     char IP[32];
13.     //创建一个通讯端点，返回该端点的文件描述符
14.     //创建一个ipv4的tcp连接端口
15.     int s_fd=socket( AF_INET ,SOCK_STREAM ,0);
17.     //需要对server变量成员初始化
18.     serv.sin_family=AF_INET;
19.     serv.sin_port=htons(5556);
20.     serv.sin_addr.s_addr=htonl(INADDR_ANY);
21.     //将s_fd和本地地址，端口号绑定
22.     int b=bind(s_fd,(struct sockaddr *)&serv,sizeof(serv));
24.     if(b==-1)E_MSG("bind",-1);
25.     if(s_fd==-1)E_MSG("socket",-1);
26.     //将s_fd设置为被动连接，监听客户端连接的到来
27.     //将客户端到来的连接放入未决连接队列中
28.     //指定未决连接队列的长度
29.     listen(s_fd,5);
30.     while(1){
31.         //从s_fd设备的未连接队列中提取一个进程进行处理
32.         //返回一个连接描述符，使用这个连接描述符与客户端进行通讯
33.         int c_fd=accept(s_fd,(struct sockaddr *)&cli,&cli_len);
34.         if(c_fd==-1)E_MSG("accept",-1);
35.         //binary--->text
36.         inet_ntop(AF_INET,&cli.sin_addr,IP,32);
37.         printf("client ip: %s\n",IP);
38.         //代码执行到这里，三次握手以及完成，可以进行数据传输了
39.         //从c_fd中读取客户端发送过来的请求信息
40.         int r = read(c_fd,buf,128);
41.         //处理客户端的请求信息
42.         int i;
43.          for(i=0;i<r;i++){
44.             buf[i]=toupper(buf[i]);
45.          }
46.          //将处理结果回送客户端
47.          write(c_fd,buf,r);
48.         //关闭本次连接
49.         close(c_fd);
50.     }
52.     return 0;
53. }

复制代码

这是最简单的循环服务器代码，功能是将客户传过来的字符串全部转换为大写，这个最简单代码盼望大家能全部弄懂，关于内里还有不懂的，可以去看我我前面的博客：[C++/Linux] socket套接字函数-CSDN博客


2.2 简单并发网络服务器

并发网络服务器是指可以大概同时处理多个客户端哀求的网络服务器。这种服务器的筹划允许它在任何时候处理多个客户端的毗连和哀求，而不会因为某个哀求的处理而阻塞其他哀求。并发服务器可以提高资源的利用率，增强服务器的响应本领，是现代网络应用的底子。下面我将先容几种常见的并发网络服务器模型：
2.2.1简单的并发服务器模型

• 迭代服务器（Iterative Server）： 这种服务器一次处理一个哀求。它吸收一个哀求，处理完该哀求，然后才吸收下一个哀求。这种模型简单，但服从低下，因为它在处理一个哀求时不能处理其他哀求。
  
• 并发服务器（Concurrent Server）： 并发服务器可以同时处理多个哀求。这通常通过多历程或多线程来实现。服务器的主历程或线程监听端口，继承新的毗连，然后为每个毗连创建一个新的历程或线程来处理哀求。
  

2.2.2使用历程的并发服务器

• 多历程服务器（Multiprocess Server）： 在这个模型中，服务器的主历程监听端口，继承新的毗连。每当有一个新的毗连时，主历程就fork一个子历程来处理这个毗连。每个子历程都可以独立地与客户端通信，处理哀求。这种模型的优点是代码简单，缺点是历程创建和销毁的开销较大。
  
• 预派生子历程服务器（Pre-forking Server）： 这种服务器在启动时就预先创建一定数量的子历程，每个子历程都阻塞在accept调用上等待新的毗连。当一个毗连到达时，其中一个子历程继承毗连并处理哀求。这种模型减少了历程创建的开销，但需要预先分配资源。
  

这里我手绘一个UML图来帮助大家明白怎样利用历程池：

2.2.3使用线程的并发服务器

• 多线程服务器（Multithreaded Server）： 在这个模型中，服务器的主线程监听端口，继承新的毗连。每当有一个新的毗连时，主线程就创建一个新的线程来处理这个毗连。由于线程共享内存空间，因此它们之间可以更容易地共享数据，但这也带来了同步问题。
  
• 线程池服务器（Thread Pool Server）： 线程池服务器预先创建一定数量的工作线程，这些线程都阻塞在等待任务队列上。当一个新的毗连到达时，主线程将毗连放入任务队列，工作线程从队列中取出毗连并处理哀求。这种模型可以限制线程的数量，减少线程创建和销毁的开销。
  

这里我手绘一个UML图来帮助大家明白怎样利用线程池：

对于历程和线程大家有不了解的，可以看我前面博客：[C++/Linux] Linux线程详解-CSDN博客

2.2.4其他并发服务器模型

• 事件驱动服务器（Event-Driven Server）： 事件驱动服务器使用非阻塞IO和事件循环来处理多个客户端毗连。服务器注册感兴趣的事件（如可读、可写事件），然后在一个循环中等待这些事件的发生。当事件发生时，服务器处理相应的事件。这种模型可以非常高效地处理大量毗连。
  
• 异步IO服务器（Asynchronous I/O Server）： 异步IO服务器使用操纵系统提供的异步IO接口来处理哀求。服务器发起IO操纵，然后继续处理其他任务。当IO操纵完成时，操纵系统通知服务器。这种模型可以充分利用CPU资源，因为它不需要为每个哀求都创建一个线程或历程。
  

二.使用互斥锁实现单线程处理单个客户

这里我们使用互斥锁来对每个进行上锁，实现单客户单历程处理，
2.1 具体步骤

• 初始化互斥锁：在服务器启动时，初始化一个互斥锁。
  
• 继承毗连：服务器的主线程循环继承客户端毗连。
  
• 创建服务线程：每当继承一个新毗连时，服务器创建一个新的服务线程来处理该毗连。
  
• 加锁处理：在每个服务线程中，当开始处理客户哀求之前，首先尝试获取互斥锁。如果互斥锁已被其他线程持有，线程将阻塞直到互斥锁被开释。
  
• 处理哀求：线程获取互斥锁后，开始处理客户哀求。
  
• 开释锁：处理完哀求后，线程开释互斥锁，以便其他线程可以获取该锁并处理下一个哀求。
  
• 线程退出：处理完成后，线程退出或返回到池中等待下一个哀求
  

2.2服务器代码模板

1. #include <pthread.h>
3. pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
5. void *handle_client(void *client_socket) {
6.     int socket = *(int *)client_socket;
8.     // 加锁
9.     pthread_mutex_lock(&lock);
11.     // 处理客户请求
12.     // ...
14.     // 释放锁
15.     pthread_mutex_unlock(&lock);
17.     // 关闭客户端套接字
18.     close(socket);
19.     return NULL;
20. }
22. int main() {
23.     // 创建监听套接字
24.     // ...
26.     while (1) {
27.         int client_socket = accept(listen_socket, NULL, NULL);
29.         // 创建线程来处理客户端
30.         pthread_t thread;
31.         pthread_create(&thread, NULL, handle_client, &client_socket);
32.         pthread_detach(thread); // 使线程独立运行
33.     }
35.     // 关闭监听套接字
36.     // ...
38.     return 0;
39. }

复制代码

三.源码剖析

1. #include<t_stdio.h>
2. #include<t_file.h>
3. #include<stdlib.h>
4. #include <sys/types.h>
5. #include <sys/socket.h>
6. #include <string.h>
7. #include <arpa/inet.h>
8. #include<unistd.h>
9. #include<time.h>
10. #include<pthread.h>
11. #include <string.h>
13. #define bufferlen 1024 //发送/接收数据缓冲区大小
14. #define server_port 8888 //端口
15. #define backlog 5 //监听队列
16. #define max_pthread 3 //最大线程数
18. //线程处理业务函数
19. pthread_mutex_t ALOCK = PTHREAD_MUTEX_INITIALIZER ;//创建互斥量
21. static void * handle_request(void * argv){
22.     int s_s = *((int *) argv);
23.     int s_c;
24.     struct sockaddr_in from ;
25.     socklen_t len = sizeof(from);
26.     for(;;){
27.         time_t now;
28.         char buf [bufferlen];
29.         int n=0;
31.         pthread_mutex_lock(&ALOCK); //进入互斥区
32.         s_c = accept(s_s , (struct sockaddr *)&from , &len);//接收请求
33.         pthread_mutex_unlock(&ALOCK); //离开互斥区
34.         memset(buf , 0 ,bufferlen);
35.         n = recv(s_c , buf , bufferlen , 0);//接收数据
36.         
37.         if(n > 0 && !strncmp(buf , "TIME" , 4))//判断是否为合法接收数据
38.         {
39.             memset(buf ,0 ,bufferlen);
40.             now = time(NULL);
41.             sprintf(buf , "%24s\r\n",ctime(&now));//时间写入buf
42.             send(s_c , buf , strlen(buf) , 0);//发送给客户端
44.         }
45.         close(s_c);
46.     }
47.     return ;
49. }
51. //线程创建函数
52. static void handle_connect(int s){
53.     int s_s =s;
54.     pthread_t thread_do[max_pthread];//创建线程数组
55.     int i=0;
56.     //创建线程，每一次创建调用线程处理函数
57.     for(i = 0; i<max_pthread;i++){
58.         pthread_create(&thread_do[i] , NULL, handle_request , (void *)&s_s);
59.     }
60.     //等待线程结束
61.     for(i = 0; i<max_pthread;i++){
62.         pthread_join(thread_do[i] , NULL);
64.     }
66. }
68. int main(int argc ,char * argvp[]){
69.     int s_s;
70.     struct sockaddr_in local ;//本地地址
71.     s_s = socket(AF_INET , SOCK_STREAM , 0);
72.     memset(&local , 0 , sizeof(local));
73.     local.sin_family = AF_INET;
74.     local.sin_addr.s_addr = htonl(INADDR_ANY);
75.     local.sin_port = htons(server_port);
77.     bind(s_s , (struct sockaddr *)&local ,sizeof(local));//连接本地地址
78.     listen(s_s , backlog);//创建监听队列
79.     handle_connect(s_s);
80.     close(s_s);
82.     return 0;
83. }

复制代码

这段代码是一个简单的网络服务器示例，它使用了 POSIX 线程（pthread）来处理客户端哀求。下面我将逐行表明代码的功能：

1. #include <t_stdio.h>
2. #include <t_file.h>
3. #include <stdlib.h>
4. #include <sys/types.h>
5. #include <sys/socket.h>
6. #include <string.h>
7. #include <arpa/inet.h>
8. #include <unistd.h>
9. #include <time.h>
10. #include <pthread.h>
11. #include <string.h>

复制代码

这里包含了须要的头文件，包括标准输入输出、文件操纵、网络编程、字符串操纵、IP地址转换、非阻塞I/O等。

1. #define bufferlen 1024 //发送/接收数据缓冲区大小
2. #define server_port 8888 //端口
3. #define backlog 5 //监听队列
4. #define max_pthread 3 //最大线程数

复制代码

界说了一些宏，用于设置缓冲区大小、服务器端口、监听队列大小和最大线程数。

1. //线程处理业务函数
2. pthread_mutex_t ALOCK = PTHREAD_MUTEX_INITIALIZER ;//创建互斥量

复制代码

界说了一个互斥量 ALOCK，用于线程间的同步。

1. static void * handle_request(void * argv){
2.     int s_s = *((int *) argv);
3.     int s_c;
4.     struct sockaddr_in from ;
5.     socklen_t len = sizeof(from);
6.     for(;;){
7.         time_t now;
8.         char buf [bufferlen];
9.         int n=0;
11.         pthread_mutex_lock(&ALOCK); //进入互斥区
12.         s_c = accept(s_s , (struct sockaddr *)&from , &len);//接收请求
13.         pthread_mutex_unlock(&ALOCK); //离开互斥区
14.         memset(buf , 0 ,bufferlen);
15.         n = recv(s_c , buf , bufferlen , 0);//接收数据
16.         
17.         if(n > 0 && !strncmp(buf , "TIME" , 4))//判断是否为合法接收数据
18.         {
19.             memset(buf ,0 ,bufferlen);
20.             now = time(NULL);
21.             sprintf(buf , "%24s\r\n",ctime(&now));//时间写入buf
22.             send(s_c , buf , strlen(buf) , 0);//发送给客户端
24.         }
25.         close(s_c);
26.     }
27.     return ;
28. }

复制代码

handle_request 函数是线程处理业务的核心。它继承一个整数参数 s_s，这是服务器套接字。函数进入一个无穷循环，吸收客户端的毗连（accept 调用），吸收数据（recv 调用），处理数据（如果数据是以 “TIME” 开头的，则返回当前时间），然后关闭客户端套接字。

     好啦！到这里这篇文章就竣事啦，关于实例代码中我写了很多表明，如果大家还有不懂得，可以评论区或者私信我都可以哦

！！ 感谢大家的阅读，我还会连续创造网络编程相干内容的，记得点点小爱心和关注哟！

 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。