您的位置: 首页  >  文章  >  Linux网络编程-自己动手写进程池

Linux网络编程-自己动手写进程池

分类: 文章 • 2025-04-21 11:15:04
并发服务器的实现中，可以通过动态的创建子进程（或子线程）来实现。这样有几个缺点：

1、动态创建进程（或线程）比较耗时间，将导致客户响应较慢

2、动态创建的子进程或子线程通常只用来为一个客户服务，这导致系统中产生了很多进程或线程，使进程或线程之间的切换消耗很多CPU时间

3、动态创建子进程是当前进程的完整映像，当前进程需要谨慎管理其分配的文件描述符，否则子进程可能复制这些资源，导致系统可用资源急剧下降，进而影响服务器性能

        以上的几个缺点可以通过进程池来规避，进程池是由服务器预先创建一组子进程，一般数目在3-10之间，进程池中的所有子进程运行着相同的代码，应具有相同的属性，比如优先级、PGID等。当有新任务来时，主进程选择进程池中的一个子进程来为之服务，相比于动态创建子进程，选择一个已经存在子进程显然来得跟快。


        以下是我自己参考网络资料写的一个简单的进程池示例，进程间通信使用的是管道。

        该程序说明：主进程先创建两个管道，一个用于向子进程写数据，另一个用于子进程向主进程写数据。然后主进程再创建4个子进程，让4个子进程来进程处理客户的连接请求，然后给主进程发送信息，同时主进程也给子进程发送应答信息。

运行程序后的输出结果(比如端口设为60000)：

Linux网络编程-自己动手写进程池

在浏览器中输入http://192.168.1.2:60000（192.168.1.2运行该程序的主机）后就可以看到

Linux网络编程-自己动手写进程池


源代码：

[cpp] view plain copy
  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include <sys/types.h>  
  4. #include <sys/socket.h>  
  5. #include <sys/stat.h>  
  6. #include <netinet/in.h>  
  7. #include <string.h>  
  8. #include <strings.h>  
  9. #include <unistd.h>  
  10. #include <signal.h>  
  11. #include <fcntl.h>  
  12.   
  13. #define err_sys(msg) \  
  14.     do { perror(msg); exit(-1); } while(0)  
  15. #define err_exit(msg) \  
  16.     do { fprintf(stderr, msg); exit(-1); } while(0)  
  17. #define head200 "HTTP/1.1 200 OK \r\n"  
  18. #define head404 "HTTP/1.1 404 Not Found\r\n"  
  19. #define head503 "HTTP/1.1 503 Service unabailiable\r\n"  
  20. #define MAXCHILD 4  
  21. #define BUFFSIZE 1024  
  22.   
  23. typedef struct  
  24. {  
  25.     pid_t pid;  
  26.     char status;  
  27. }sReport;  
  28.   
  29. int len200, len404, len503;  
  30. int pipe_fd1[2], pipe_fd2[2];  
  31.   
  32. void process_child(int listenfd, char* filename)  
  33. {  
  34.     int connfd;  
  35.     int cnt, len;  
  36.     struct sockaddr_in cliaddr;  
  37.     socklen_t clilen = sizeof(cliaddr);  
  38.     sReport req;  
  39.     char comm = '\0';  
  40.     int running = 1;  
  41.     char head_buf[1024];  
  42.   
  43.     req.pid = getpid();  
  44.     while(running)  
  45.     {  
  46.         connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &clilen);  
  47.         if(connfd < 0)  
  48.             err_sys("accept");  
  49.         req.status = 'n';  
  50.   
  51.         /* send message to parent process that got a new accept */  
  52.         if(write(pipe_fd1[1], &req, sizeof(req)) < 0)  
  53.             err_sys("write");  
  54.   
  55.         int fd;  
  56.         struct stat file_stat;  
  57.         if((fd = open(filename, O_RDONLY)) < 0)  
  58.             err_sys("open");  
  59.         if(stat(filename, &file_stat) < 0)  
  60.             err_sys("stat");  
  61.   
  62.         bzero(head_buf, sizeof(head_buf));  
  63.         len = 0;  
  64.         cnt = snprintf(head_buf, BUFFSIZE - 1, head200);  
  65.         len += cnt;  
  66.         cnt = snprintf(head_buf + len, BUFFSIZE - 1 - len, "Coontent-Length: %lu\r\n", file_stat.st_size);  
  67.         len += cnt;  
  68.         cnt = snprintf(head_buf + len, BUFFSIZE - 1 - len, "\r\n");  
  69.   
  70.         char *file_buf;  
  71.         struct iovec iv[2];  
  72.   
  73.         if((file_buf = (char *)malloc(file_stat.st_size)) == NULL)  
  74.             err_sys("malloc");  
  75.         bzero(file_buf, file_stat.st_size);  
  76.         if(read(fd, file_buf, file_stat.st_size) < 0)  
  77.             err_sys("read");  
  78.         iv[0].iov_base = head_buf;  
  79.         iv[0].iov_len = strlen(head_buf);  
  80.         iv[1].iov_base = file_buf;  
  81.         iv[1].iov_len = strlen(file_buf);  
  82.         writev(connfd, iv, 2); /* send the file to client host */  
  83.         free(file_buf);  
  84.   
  85.         close(fd);  
  86.         close(connfd);  
  87.   
  88.         req.status = 'f';  
  89.         /* tell parent process that finish the request */  
  90.         if(write(pipe_fd1[1], &req, sizeof(req)) < 0)  
  91.             err_sys("write");  
  92.         /* wait for commond from parent process */  
  93.         if(read(pipe_fd2[0], &comm, 1) < 1)  
  94.             err_sys("read");  
  95.   
  96.         if('e' == comm)  
  97.         {  
  98.             printf("[%d] exit\n", req.pid);  
  99.             running = 0;  
  100.         }  
  101.         else if('c' == comm)  
  102.             printf("[%d] continue\n", req.pid);  
  103.         else  
  104.             printf("[%d]: comm: %c illeagle\n", req.pid, comm);  
  105.     }  
  106. }  
  107.   
  108. void handle_sigchld(int sig)  
  109. {  
  110.     printf("the child process exit.\n");  
  111. }  
  112.   
  113. int main(int argc, char *argv[])  
  114. {  
  115.     int listenfd;  
  116.     struct sockaddr_in servaddr;  
  117.     pid_t pid;  
  118.   
  119.     if(argc != 2)  
  120.         err_exit("Usage: http-server port\n");  
  121.   
  122.     int port = atoi(argv[1]);  
  123.     len200 = strlen(head200);  
  124.     len404 = strlen(head404);  
  125.     len503 = strlen(head503);  
  126.   
  127.     if(signal(SIGCHLD, handle_sigchld) < 0)  
  128.         err_sys("signal");  
  129.     if(pipe(pipe_fd1) < 0)  
  130.         err_sys("pipe pipe_fd1");  
  131.     if(pipe(pipe_fd2) < 0)  
  132.         err_sys("pipe piep_fd2");  
  133.   
  134.     bzero(&servaddr, sizeof(servaddr));  
  135.     servaddr.sin_family = AF_INET;  
  136.     servaddr.sin_port = htons(port);  
  137.     servaddr.sin_addr.s_addr = htonl(INADDR_ANY);  
  138.   
  139.     if((listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)  
  140.         err_sys("socket");  
  141.     if(bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)  
  142.         err_sys("bind");  
  143.     if(listen(listenfd, 10) < 0)  
  144.         err_sys("listen");  
  145.     int i;  
  146.     for(i = 0; i < MAXCHILD; i++)  
  147.     {  
  148.         if((pid = fork()) < 0)  
  149.             err_sys("fork");  
  150.         else if(0 == pid)  
  151.         {  
  152.             process_child(listenfd, "test.txt"); //test.txt为测试文件，内容为 Hello World!!!  
  153.         }  
  154.         else  
  155.         {  
  156.             printf("have create child %d\n", pid);  
  157.         }  
  158.     }  
  159.   
  160.     close(pipe_fd1[1]);  
  161.     close(pipe_fd2[0]);  
  162.     close(listenfd);  
  163.     char c = 'c';  
  164.     int req_num = 0;  
  165.     sReport req;  
  166.   
  167.     while(1)  
  168.     {  
  169.         if(read(pipe_fd1[0], &req, sizeof(req)) < 0)  
  170.             err_sys("read pipe_fd1");  
  171.         /* a new request come */  
  172.         if(req.status == 'n') //子进程收到一个连接请求  
  173.         {  
  174.             req_num++;  
  175.             printf("parent: %d have receive new request\n", req.pid);  
  176.         }  
  177.         else if(req.status == 'f') /* just finish a accept */  
  178.         {  
  179.             req_num--;  
  180.             if(write(pipe_fd2[1], &c, sizeof(c)) < sizeof(c))  
  181.                 err_sys("write");  
  182.         }  
  183.     }  
  184.     printf("Done\n");  
  185.   
  186.     return 0;  
  187. } 

相关推荐