！！多进程并发框架问题向各位大侠请教(急)！！

flyhu

好久没有写程序了，最近公司的项目比较急，接到一个批处理多进程并发的任务。
我的主要设计是这样的：
1、以守护进程的方式运行主程序。
2、主程序根据配置文件，和要做的作业，交给多个（如5个），去运行。
   没接到一个任务，就产生一个进行，直到最大个数如5，为止，则等待。
3、如果一个子进程结束了，就再为其分配一个任务。
4、也就是总是保持5个进程同时运行，结束一个，主程序就再分配任务，产生一个新进程。

我想了半天，也没想好整个程序框架该是什么样的，改如何来保持5个进程运行，主进程还能监控并等待。

各位大侠，能在如下框架的基础上，帮我出一个满足我上面需要的框架吗？十分感谢，我把我所有的金币都给你们了。

#include <sys/types.h>
#include <sys/wait.h>
main()
{
        pid_t pc, pr;
        int status;
       
        pc=fork();
       
        if(pc<0)
                printf("Error occured on forking.\n");
        else if(pc==0){
                /* 子进程的工作 */
                exit(0);
        }else{
                /* 父进程的工作 */
                pr=wait(&status);
                /* 利用子进程的结果 */
        }
}

scutan

原帖由 flyhu 于 2007-8-12 20:43 发表
好久没有写程序了，最近公司的项目比较急，接到一个批处理多进程并发的任务。
我的主要设计是这样的：
1、以守护进程的方式运行主程序。
2、主程序根据配置文件，和要做的作业，交给多个（如5个），去运行。 ...

简单写了一个,不知道可不可以满足你的要求.

1. 
   
2. #include<stdio.h>
   
3. #include<stdlib.h>
   
4. #include<unistd.h>
   
5. #include<sys/types.h>
   
6. #include<sys/wait.h>
   
7. #include<signal.h>
   
8. #include<sys/resource.h>
   
9. #include<fcntl.h>
   
10. #include<sys/time.h>
    
11. #include<sys/stat.h>
    
12. void fun(int i)
    
13. {
    
14.         while(1)
    
15.         {
    
16.                 printf("i=%d\n", i);
    
17.                 sleep(1);
    
18.         }
    
19. }
    
20. 
    
21. int daemon_init(void)
    
22. {
    
23.         pid_t pid;
    
24.         struct sigaction sa;
    
25.         struct rlimit r1;
    
26.         int i;
    
27.         if ((pid = fork()) < 0)
    
28.                 return -1;
    
29.         else if (pid != 0)
    
30.                 exit(0);
    
31.         if (setsid() < 0)
    
32.                 exit(1);
    
33. 
    
34.         sa.sa_handler = SIG_IGN;
    
35.         sigemptyset(&sa.sa_mask);
    
36.         sa.sa_flags = 0;
    
37.         if (sigaction(SIGHUP, &sa, NULL) < 0)
    
38.         {
    
39.                 printf("sigaction error\n");
    
40.                 exit(1);
    
41.         }
    
42.         if ((pid = fork()) < 0)
    
43.                 return -1;
    
44.         else if (pid != 0)
    
45.                 exit(0);
    
46. 
    
47.         if (chdir("/") < 0)
    
48.                 return -1;
    
49.         umask(0);
    
50.         if (getrlimit(RLIMIT_NOFILE, &r1) < 0)
    
51.         {
    
52.                  printf("get file limit error\n");
    
53.                  exit(1);
    
54.         }
    
55.         if (r1.rlim_max == RLIM_INFINITY)
    
56.                  r1.rlim_max = 1024;
    
57.         for(i = 0; i < r1.rlim_max; i++)
    
58.                  close(i);
    
59.         return 0;
    
60. }
    
61. 
    
62. int main()
    
63. {
    
64.         pid_t pid;
    
65.         int i = 5;
    
66.         int n;
    
67.         int j = 0;
    
68.         n = daemon_init();
    
69.         if (n != 0)
    
70.         {
    
71.                 printf("daemon error\n");
    
72.                 exit(1);
    
73.         }
    
74.         while (i--)
    
75.         {
    
76.                 if ((pid = fork()) < 0)
    
77.                 {
    
78.                         printf("fork %d error\n", 5-i);
    
79.                         exit(1);
    
80.                 }
    
81.                 if (pid == 0)
    
82.                 {
    
83.                         fun(5-i-1);
    
84.                         exit(0);
    
85.                 }
    
86.         }
    
87.         j = 5;
    
88.         while (wait(NULL) > 0)
    
89.         {
    
90.                 if ((pid = fork()) < 0)
    
91.                 {
    
92.                         printf("fork %d error\n", j);
    
93.                         exit(1);
    
94.                 }
    
95.                 if (pid == 0)
    
96.                 {
    
97.                         fun(j);
    
98.                         exit(0);
    
99.                 }
    
100.                 j++;
     
101.         }
     
102.         return 0;
     
103. }
     
104. 
     
105. 
     

复制代码

[ 本帖最后由 scutan 于 2007-8-13 09:30 编辑 ]

flyhu

拜求高人指点。。

flyhu

楼山的大侠十分感谢啊，我试一下。
另外，大侠，能对程序做一下简要的说明。
我以前还没写过这样的程序，所有有些地方不是很明白：
1、daemon_init，会长期驻留吗？它是如何识别子进程结束，并产生新的子进程的？
2、 while (i--)， while (wait(NULL) > 0)
     两个循环，为什么要产生两边子进程呢？做用在什么地方？
3、while (wait(NULL)
     是等待所有的子进程都结束？还是结束一个，就再产生一个，始终保持5个进程的存在？

十分感谢。。

scutan

原帖由 flyhu 于 2007-8-13 08:25 发表
楼山的大侠十分感谢啊，我试一下。
另外，大侠，能对程序做一下简要的说明。
我以前还没写过这样的程序，所有有些地方不是很明白：
1、daemon_init，会长期驻留吗？它是如何识别子进程结束，并产生新的子进程 ...

1.daemon_init()是初始化你的进程,使你的这个进程是一个守护进程.具体可以看<UNIX环境高级编程>2 第13章.有对初始化成守护进程的详细讲解.
2.前面一个while (i--), 因为i初始值为5,所以此时就可以产生五个子进程,而每个子进程都在做那个无限循环.while (wait(NULL)>0)是在检查是否有子进程退出.如果有子进程退出,则会马上产生一个新的子进程.
3.while(wait(NULL)>0)是等待一个子进程结束,只要有一个子进程结束,则会产生一个新的子进程出来.

你可以将这个程序保存为test.c然后运行. ps -A,可以看到有六个test在运行,其中一个是父进程,另外五个是子进程.然后你kill一个子进程后,又会马上产生一个新的子进程!

sunceenjoy

看明白了，多谢。

flyhu

隔一层的大侠，十分感谢，今天忙了一天的数据清理（手工），没来的及看。
刚刚看到，十分感谢，我也基本明白了，我明天试一下，看看能否在你的基础上改造一下。

我的实际需求是这样的，我这里要做并发的数据清理。
主进程连接数据库，从数据库配置表中取出要清理的表，取出一个，就交给一个子进程去清理，取满5个的时候就等待，有一个进程完成了，就再取一个表交一个子进程清理，直到所有的表都清理完。

看了大侠的指点，我心里有底多了。
1、我只需要把fun改成数据清理的子进程，运行完就结束退出，之后主进程会再产生新的是吧。
2、我想在请教，我在主进程和子进程间，如何共享数据库链接的句柄呢？？

能再进一步指点一下吗？我实在是时间紧，没有时间自己去一点点摸索，所以就请教了，希望别笑我烦。

十分感谢。我会尽快，给分的。

scutan

1. 是的, 将fun()改成你的子进程就可以了. 后面那个while()就是不断产生新进程的一个循环.
2. 对于父子进程. 在父进程中打开了一个文件, 然后再fork一个子进程, 随后父进程再关闭这个相应的描述符就可以了.然后由子进程对相应的描述符进程操作就可以了. 即如下方式 :

1. 
   
2.         int fd;
   
3.         pid_t pid;
   
4.         if ((fd = open("test", O_RDWR|O_CREAT, 0644)) < 0)
   
5.         {
   
6.                 printf("open error\n");
   
7.                 exit(1);
   
8.         }
   
9. 
   
10.         if ((pid = fork()) < 0)
    
11.         {
    
12.                 printf("fork error\n");
    
13.                 exit(1);
    
14.         }
    
15. 
    
16.         if (pid == 0)
    
17.         {
    
18.          /* child */
    
19.                 write(fd, "hello", 6);
    
20.                 exit(0);
    
21.         }
    
22.          /* parent */
    
23.         close(fd);
    
24. 
    

复制代码

ftInternet

原帖由 flyhu 于 2007-8-12 20:43 发表
好久没有写程序了，最近公司的项目比较急，接到一个批处理多进程并发的任务。
我的主要设计是这样的：
1、以守护进程的方式运行主程序。
2、主程序根据配置文件，和要做的作业，交给多个（如5个），去运行。 ...

对于多进程、线程守护程序这种模式，建议参考apache的结构及组织方式。