• 【高性能服务器】多线程并发模型

    🔥博客主页： 我要成为C++领域大神
    🎥系列专栏：【C++核心编程】 【计算机网络】 【Linux编程】 【操作系统】
    ❤️感谢大家点赞👍收藏⭐评论✍️

    本博客致力于知识分享，与更多的人进行学习交流

    ​​

    对于常见的C/S模型，一个服务端通常需要服务多个客户端。如果使用单行的处理模型，当新的客户端请求服务端的服务时，就必须等待比它先到的客户端的请求全部完成。

    因此引入多进程并发服务器模型。多进程并发服务器模型的简单流程图如下所示。父进程创建一个套接字，然后与自己的IP地址、端口号进行绑定。之后调用开始监听来自客户端的敲门，当有客户端来敲门时，accept()接收客户端的连接并创建一个新套接字用于与客户端通信。接下来调用fork()函数，当调用fork()函数时，操作系统会复制当前进程的一个副本，包括进程的代码、数据和状态等信息。如果其返回值为负数，表示创建子进程失败。否则他在父子进程中有不同的返回值：如果返回值为0，表示当前代码正在子进程中执行。如果返回值大于0，表示当前代码正在父进程中执行，返回的值是子进程的进程ID。因此可以使用if-else语句来编写子进程的处理代码。

    在子进程中，先关闭从父进程中复制下来监听套接字，这个套接字在子进程中没有用了，纯属浪费资源，之后再进行与客户端的通信。而在父进程中，同理关闭accept()创建的新套接字，然后继续监听客户端的连接请求。

    而同一进程的所有线程共享相同的内存空间，线程数据共享和通信更加方便，创建和管理线程的资源消耗较少，尤其是内存开销较小。由于线程间通信和进程间通信，多线程模型在处理大量任务时响应速度较快。

    在多进程+多线程代码的基础上，将进行accept的进程修改为创建的线程工作，socket通信的功能放在线程工作函数内。

    ​

    使用服务器测试业务：

    客户端向标准输入发送小写字符串，服务端响应回复对应大写字符，"abcAS"->"ABCAS"

    客户端向服务端发送关键字localtime，服务端响应回复系统时间、

    服务端： 

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #define _SERVER_IP "xxx.xxx.xxx.xxx"
    13. #define _PORT 8080
    14. #define _BACKLOG 128
    15. #define _SHUTDOWN 1
    16. #define _TRUE 1
    17. #define _FALSE 0
    18. #define _IPSIZE 16
    19. #define _RECVLEN 1500
    20.  
    21. struct client_info
    22. {
    23.     int client_fd;
    24.     struct sockaddr_in clientAddr;
    25. };
    26.  
    27. void sig_wait(int n)
    28. {
    29.     pid_t zpid;
    30.     while ((zpid = waitpid(-1, NULL, WNOHANG)) > 0)
    31.     {
    32.         printf("wait Thread Tid [0x%x] Wait Successfully,Zombie %d\n", (unsigned int)pthread_self(), zpid);
    33.     }
    34. }
    35.  
    36. void *thread_wait(void *arg)
    37. {
    38.     // 设定信号捕捉
    39.     pthread_detach(pthread_self());
    40.     struct sigaction act, oact;
    41.     act.sa_handler = sig_wait;
    42.     act.sa_flags = 0;
    43.     sigemptyset(&act.sa_mask);
    44.     sigaction(SIGCHLD, &act, &oact);
    45.     // 解除屏蔽
    46.     sigprocmask(SIG_SETMASK, &act.sa_mask, NULL);
    47.     printf("wait Thread [0x%x] is Waiting...\n", (unsigned int)pthread_self());
    48.     while (1)
    49.         sleep(1);
    50.     pthread_exit(NULL);
    51. }
    52. void *thread_recv(void *arg)
    53. {
    54.     int recvlen;
    55.     char Result[_RECVLEN];
    56.     char client_ip[_IPSIZE];
    57.     time_t tp;
    58.     char time_buf[100]; // 存放当前系统时间
    59.     int toupper_flag;
    60.  
    61.     struct client_info cinfo = *((struct client_info *)arg);
    62.     // Socket通信
    63.     bzero(Result, sizeof(Result));
    64.     bzero(client_ip, sizeof(client_ip));
    65.     inet_ntop(AF_INET, &cinfo.clientAddr.sin_addr.s_addr, client_ip, _IPSIZE);
    66.     printf("Connection From :IP[%s],PORT[%d]\n", client_ip, ntohs(cinfo.clientAddr.sin_port));
    67.     sprintf(Result, "Hi [%s] Welcome to my TCP test server!service version 1.1.0...", client_ip);
    68.     send(cinfo.client_fd, Result, strlen(Result), 0);
    69.     bzero(Result, sizeof(Result));
    70.  
    71.     // 读取用户数据，如果用户发的是普通小写字符字符串，转换为大写，如果发送的是local关键字，响应时间
    72.     // 持续响应，循环读写
    73.     while ((recvlen = recv(cinfo.client_fd, Result, sizeof(Result), 0)) > 0)
    74.     { // 处理客户端业务
    75.         printf("Client Say:%s\n", Result);
    76.         if (strcmp(Result, "localtime") == 0)
    77.         {
    78.             tp = time(NULL); // 获取时间种子
    79.             ctime_r(&tp, time_buf);
    80.             time_buf[strcspn(time_buf, "\n")] = '\0';
    81.             printf("[%s]Response SysTime Successfully!\n", client_ip);
    82.             send(cinfo.client_fd, time_buf, strlen(time_buf) + 1, 0);
    83.         }
    84.         else
    85.         {
    86.             toupper_flag = 0;
    87.             while (recvlen > toupper_flag)
    88.             {
    89.                 Result[toupper_flag] = toupper(Result[toupper_flag]);
    90.                 ++toupper_flag;
    91.             }
    92.             printf("[%s]Response Toupper Successfully!\n", client_ip);
    93.             send(cinfo.client_fd, Result, recvlen, 0);
    94.         }
    95.     }
    96.     if (recvlen == 0) // 客户端退出
    97.     {
    98.         close(cinfo.client_fd);
    99.         printf("[%s] is Exiting,Kill Child\n", client_ip);
    100.         exit(0);
    101.     }
    102.  
    103.     close(cinfo.client_fd);
    104. }
    105.  
    106. int main()
    107. {
    108.  
    109.     struct sockaddr_in serverAddr, clientAddr;
    110.     int server_fd;
    111.     int client_fd;
    112.  
    113.     // 主线程设置屏蔽
    114.     sigset_t set, oldset;
    115.     sigemptyset(&set);
    116.     sigaddset(&set, SIGCHLD);
    117.     sigprocmask(SIG_SETMASK, &set, &oldset);
    118.     pthread_t tid;
    119.     pthread_create(&tid, NULL, thread_wait, NULL); // 创建回收线程
    120.  
    121.     socklen_t Addrlen;
    122.     serverAddr.sin_family = AF_INET;
    123.     serverAddr.sin_port = htons(_PORT);
    124.     serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    125.     server_fd = socket(AF_INET, SOCK_STREAM, 0);
    126.     bind(server_fd, (struct sockaddr *)&serverAddr, sizeof(serverAddr));
    127.     listen(server_fd, _BACKLOG);
    128.     printf("Test TCP Server Version 1.1.0 is Running...\n");
    129.  
    130.     while (_SHUTDOWN)
    131.     {
    132.         Addrlen = sizeof(clientAddr);
    133.         if ((client_fd = accept(server_fd, (struct sockaddr *)&clientAddr, &Addrlen)) > 0)
    134.         {
    135.  
    136.             struct client_info cinfo;
    137.             cinfo.client_fd = client_fd;
    138.             cinfo.clientAddr = clientAddr;
    139.             pthread_create(&tid, NULL, thread_recv, &cinfo); // 创建工作线程
    140.         }
    141.         else
    142.         {
    143.             // accept失败，测试中断
    144.             close(server_fd);
    145.             if (errno == EINTR)
    146.             {
    147.                 printf("Accept ERROR Eintr...\n");
    148.                 exit(0);
    149.             }
    150.         }
    151.     }
    152.     close(server_fd);
    153.     return 0;
    154. }

    客户端：

    1. #ifndef _MYSOCK_H_
    2. #define _MYSOCK_H_
    3.  
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14. #include 
    15. #include 
    16.  
    17. int SOCKET(int domain, int type, int protocol);
    18. int BIND(int sockfd, struct sockaddr* addr, socklen_t addrlen);
    19. ssize_t RECV(int sockfd, void* buf, size_t len, int flags);
    20. ssize_t SEND(int sockfd, void* buf, size_t len, int flags);
    21. int CONNECT(int sockfd, struct sockaddr* addr, socklen_t addrlen);
    22. int ACCEPT(int sockfd, struct sockaddr* addr, socklen_t* addrlen);
    23. int LISTEN(int sockfd, int backlog);
    24. char* FGETS(char* s, int size, FILE* stream);
    25. int SELECT(int nfds, fd_set* readfds, fd_set* writefds, fd_set* exceptfds,
    26.            struct timeval* timeout);
    27. int socket_init();
    28. int return_response(int clientfd, const char* clientip);
    29. //void strDeal(int *client_fd);
    30.  
    31. // 全局变量声明
    32. char recv_buf[1024];
    33. char time_buf[64];
    34. int serverFd, clientFd;
    35. struct sockaddr_in clientAddr;
    36. fd_set set, oset;
    37. int client_array[1020];
    38. int maxfd, ready;
    39. socklen_t addrlen;
    40. char clientip[16];
    41. time_t tp;
    42. ssize_t recvlen;
    43. int toupper_flag;
    44. #define SHUTDOWN 1
    45. #endif
    1. #include "MySock.h"
    2.  
    3.  
    4. //客户端源码编写，连接服务器成功，服务器反馈信息
    5.  
    6. #define _IP "xxx.xxx.xxx.xxx"
    7. #define _PORT 8080
    8. int main()
    9. {
    10.     struct sockaddr_in ServerAddr;
    11.     bzero(&ServerAddr,sizeof(ServerAddr));
    12.     ServerAddr.sin_family=AF_INET;
    13. 	ServerAddr.sin_port=htons(_PORT);
    14.     inet_pton(AF_INET,_IP,&ServerAddr.sin_addr.s_addr);
    15.     
    16.     int Myfd=SOCKET(AF_INET,SOCK_STREAM,0);
    17.     //看需求决定是否要绑定
    18.     char Response[1024];//存放服务端反馈信息
    19.     ssize_t recvlen;
    20.     bzero(Response,sizeof(Response));
    21.     char sendbuf[1024];
    22.     
    23.     if((CONNECT(Myfd,(struct sockaddr *)&ServerAddr,sizeof(ServerAddr)))==0)
    24.     {
    25.     while(1)
    26.     {    
    27.      if((recvlen=RECV(Myfd,Response,sizeof(Response),0))>0)
    28.      {
    29.          printf("%s\n",Response);
    30.      }
    31.     
    32.     printf("Please Type Some text:");//读取标准输入发送给服务端
    33.     FGETS(sendbuf,sizeof(sendbuf),stdin);    
    34.     sendbuf[strcspn(sendbuf,"\n")]='\0';
    35.     SEND(Myfd,sendbuf,sizeof(sendbuf),0);
    36.     }
    37.     }
    38.     close(Myfd);
    39.     printf("Client is Over\n");
    40.     return 0;
    41. }

  • 相关阅读:
    MSDC 4.3 接口规范（23）
    uniapp中videojs、renderjs的使用
    vue3速查笔记
    如何深入理解JSX和React组件？
    编程题练习@9-7
    css实现鼠标悬停时元素的显示与隐藏
    javaweb 通过JDBC连接Mysql 数据库
    Rome链分析
    docker离线安装并导入镜像
    基于SpringBoot+Vue的MOBA类游戏攻略分享平台
  • 原文地址：https://blog.csdn.net/Coldreams/article/details/140119520