lighttpd1.4.16 主程序逻辑 （一）观察者和工作者

一、观察者和工作者

对进程进行管理。父进程作为观察者，负责启动和监听工作者进程

 

 

程序文件：server.c

行：970~996

源代码：

代码1

1.     /* start watcher and workers */
2.     num_childs = srv->srvconf.max_worker;
3.     if (num_childs > 0) {
4.         int child = 0;
5.         while (!child && !srv_shutdown) {
6.             if (num_childs > 0) {
7.                 switch (fork()) {
8.                 case -1:
9.                     return -1;
10.                 case 0:
11.                     child = 1;
12.                     break;
13.                 default:
14.                     num_childs--;
15.                     break;
16.                 }
17.             } else {
18.                 int status;
20.                 /* ignore EINTR */
21.                 if (-1 != wait(&status)) num_childs++;
22.             }
23.         }
24.         if (srv_shutdown) {
25.             kill(0, SIGTERM);
26.         }
27.         if (!child) return 0;
28.     }

 

抽取解析

以下代码1-1将代码1抽取出来

代码1-1

1. #include <stdlib.h>
2. #include <stdio.h>
3. #include <unistd.h>
4. #include <sys/types.h>
5. /**
6.  * 进程管理
7.  * 进程的开启和进程的维护，包括关闭
8.  *
9.  * */
10. int main(int argc,char** argv)
11. {
12.         //是否子进程的标志
13.         int is_child=0;
14.         //服务退出标志
15.         int is_server_close=0;
16.         int ppid=0;
17.         int cid=0;
18.         //最大进程数
19.         int max_child_count=5;
20.         //is_child=0用来判断是否父进程，只有父进程才能进入此循环
21.         while(0==is_child && 0==is_server_close)//父进程执行此代码
22.         {
23.                 //是否还有进程要创建
24.                 if(max_child_count>0)
25.                 {
26.                         cid=fork();
27.                         switch(cid)
28.                         {
29.                                 //错误
30.                                 case -1:
31.                                         {
32.                                                 printf("fork process=%d error/n",max_child_count);
33.                                                 return -1;
34.                                         }
35.                                 //子进程
36.                                 case 0:
37.                                         {
38.                                                 is_child=1;
39.                                                 break;
40.                                         }
41.                                 //父进程
42.                                 default:
43.                                         {
44.                                                 //创建子进程成功
45.                                                 //进程数减少
46.                                                 --max_child_count;
47.                                                 printf("sub process id =%d/n",cid);
48.                                                 printf("parent printf is_child value:%d/n",is_child);
49.                                                 break;
50.                                         }
51.                         }
52.                 //所有进程都创建完毕
53.                 }else
54.                 {
55.                         int status;
56.                         //开始阻塞等待子进程是否结束
57.                         if(-1!=wait(&status))
58.                         {
59.                                 //结束，将进程数累加1，使循环可以重新启动新的进程
60.                                 max_child_count++;
61.                         }
62.                 }
64.         }
65.         //父进程结束维护子进程后的处理
66.         if(is_child==0)
67.         {
68.                 printf("parent end/n");
69.                 return 0;
70.         //子进程业务处理
71.         }else{
72.                 sleep(5);
73.                 printf("child id=%d end/n",cid);
74.                 return 0;
75.         }
77. }