杀死所有子进程的 两种方法

isnowran

把你的程序简单修改了一下

1. 
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. #include <sys/types.h>
   
5. #include <signal.h>
   
6. #include <unistd.h>
   
7. 
   
8. 
   
9. void fun_kill( int sig )
   
10. {
    
11.         kill ( 0, SIGKILL );
    
12. }
    
13. 
    
14. int main( void )
    
15. {
    
16.     for( int i = 0; i < 3; i++ )
    
17.     {
    
18.         if( 0 == fork() )
    
19.         {
    
20.             break;
    
21.         }
    
22.     }
    
23. 
    
24.     if( getpid() == getpgid( 0 ) )
    
25.     {
    
26.         signal ( SIGTERM, SIG_IGN );
    
27.         sleep( 3 );
    
28.         kill( 0, SIGTERM );
    
29.     }
    
30.     else
    
31.     {
    
32.         while ( 1 )
    
33.         {
    
34.             printf ( "pid:%d ppid:%d\n", getpid(), getppid() );
    
35.             sleep ( 1 );
    
36.         }
    
37.     }
    
38. 
    
39.     printf( "game over\n" );
    
40.     return 0;
    
41. }
    

复制代码

isnowran

原帖由 net_robber 于 2007-3-9 15:15 发表
但是为什么另外一个拥有同样PID的后台进程不被干掉

为什么拥有同样进程的BASH进程没有被干掉？？？？？

这和Man里面解释的不一样啊

不太明白你说的"同样pid的后台进程"是什么意思，也不明白"拥有同样进程的BASH进程"是什么意思，请解释一下：）

l新的进程在shell环境生成后，一般都有setsid的操作，这样它们就不在同一个会话期，当然也不在同一个进程组了，所以shell不会受到kill 0的影响

net_robber

原帖由 isnowran 于 2007-3-9 15:46 发表

不太明白你说的"同样pid的后台进程"是什么意思，也不明白"拥有同样进程的BASH进程"是什么意思，请解释一下：）

l新的进程在shell环境生成后，一般都有setsid的操作，这样它们就不在同一 ...

大概就是你说的原因

还没有研究这么深入。

net_robber

getpid(), getppid()以前没有用过，学习一下再来讨论

net_robber

最终提供两套代码：
一套通过gid控制；
另一讨使用SHELL工作。

net_robber

这是通过gid控制

1. 
   
2.        #include <stdio.h>
   
3.        #include <stdlib.h>
   
4.        #include <sys/types.h>
   
5.        #include <signal.h>
   
6.        #include <unistd.h>
   
7.        #include <string.h>
   
8.       
   
9.        void fun(int sig)
   
10.        {
    
11.               kill(0 , SIGKILL );
    
12.       }
    
13.      
    
14.       int main( void )
    
15.       {
    
16.               int pid = 0;
    
17.      
    
18.               if( pid = fork() )
    
19.               {
    
20.                       fflush( stdout );
    
21.                       sleep ( 5 );
    
22.                       printf ( "kill ( pid, SIG ); \n");
    
23.                       fflush( stdout );
    
24.                       kill ( pid, SIGUSR1 );
    
25.                       sleep ( 10 );
    
26.                       printf ( "the father is still alive!\n", pid );
    
27.                       fflush( stdout );
    
28.               }
    
29.               else
    
30.               {
    
31.                       setpgid(0,0);      //line 30
    
32.                       signal( SIGUSR1, fun );
    
33.                       if( pid = fork() )
    
34.                       {
    
35.                               int i = 10;
    
36.                               while ( i-- )
    
37.                               {
    
38.                                       fflush( stdout );
    
39.                                       sleep ( 1 );
    
40.                               }
    
41.                       }
    
42.                       else
    
43.                       {
    
44.                               int i = 10;
    
45.                               while ( i-- )
    
46.                               {
    
47.                                       printf ( "in grandsun , pid= %d\nin grandsun , ppid= %d\n", getpid(), getppid() );
    
48.                                       fflush( stdout );
    
49.                                       sleep ( 1 );
    
50.                               }
    
51.                       }
    
52.               }
    
53.      
    
54.               return 0;
    
55.       }
    
56. 
    
57. 
    

复制代码

[ 本帖最后由 net_robber 于 2007-3-13 10:04 编辑 ]

net_robber

这是通过SHELL工作

1. 
   
2.        #include <stdio.h>
   
3.        #include <stdlib.h>
   
4.        #include <sys/types.h>
   
5.        #include <signal.h>
   
6.        #include <unistd.h>
   
7.        #include <string.h>
   
8.       
   
9.        void fun_kill( int sig )
   
10.        {
    
11.               printf( "process with PID %d got a signal!\n", getpid() );
    
12.               fflush( stdout );
    
13.               char *pre = "ps awx -o \"\%p \%P\"|grep -w ";
    
14.               char *post = " | awk \'{ print $1  }\'|xargs kill -9";
    
15.      
    
16.               char *command = malloc( 1024*sizeof (char) );
    
17.               char *c_pid = malloc( 8*sizeof (char) );
    
18.               memset ( command, 0, 1024*sizeof(char) );
    
19.               memset ( c_pid, 0, 8*sizeof(char) );
    
20.               char *a,*b;
    
21.               char c;
    
22.      
    
23.               //get PID string * NOTE: here the string is in a wrong order
    
24.               int len = 0;
    
25.               int tmp = getpid();
    
26.               for ( len = 0; tmp; tmp /= 10   )
    
27.               {
    
28.                       *( c_pid + len ) = (tmp%10)+'0';
    
29.                       len++;
    
30.               }
    
31.               printf ( "%s has %d char\n", c_pid,len );
    
32.               fflush( stdout );
    
33.      
    
34.               // deal the order
    
35.               a = c_pid;
    
36.               b = c_pid+len-1;
    
37.               printf ("c_pid = %d\n",c_pid);
    
38.               printf ("a = %d\n",a);
    
39.               printf ("b = %d\n",b);
    
40.               fflush( stdout );
    
41.      
    
42.      
    
43.               while ( a < b )
    
44.               {
    
45.                       c = *a;
    
46.                       *a =*b;
    
47.                       *b = c;
    
48.                       a += sizeof(char);
    
49.                       b -= sizeof(char);
    
50.               }
    
51.       /*
    
52.               int i = 0;
    
53.               while ( i<len )
    
54.               {
    
55.                       printf ("%c", *(c_pid+i) );
    
56.               }
    
57.       */
    
58.      
    
59.               printf ( "command1:%s\n", command );
    
60.               fflush( stdout );
    
61.      
    
62.      
    
63.               strcat ( command, pre );
    
64.               strcat ( command, c_pid );
    
65.               strcat ( command, post );
    
66.               printf ( "command2:%s\n", command );
    
67.               fflush( stdout );
    
68.      
    
69.            system( command );
    
70.      
    
71.       }
    
72.      
    
73.      
    
74.      
    
75.       int main( void )
    
76.       {
    
77.               int pid = 0;
    
78.      
    
79.               if( pid = fork() )
    
80.               {
    
81.       //              printf ( "in father, pid= %d\nin father, child pid = %d\n", getpid(), pid );
    
82.                       fflush( stdout );
    
83.                       sleep ( 5 );
    
84.                       printf ( "kill ( pid, SIG ); \n");
    
85.                       fflush( stdout );
    
86.                       kill ( pid, SIGUSR1 );
    
87.                       sleep ( 10 );
    
88.                       printf ( "the father is still alive!\n", pid );
    
89.                       fflush( stdout );
    
90.               }
    
91.               else
    
92.               {
    
93.                       signal ( SIGUSR1, fun_kill );
    
94.                       if( pid = fork() )
    
95.                       {
    
96.                               int i = 10;
    
97.                               while ( i-- )
    
98.                               {
    
99.       //                              printf ( "in child, pid= %d\nin child, ppid= %d\n", getpid(), getppid() );
    
100.                                       fflush( stdout );
     
101.                                      sleep ( 1 );
     
102.                               }
     
103.                       }
     
104.                      else
     
105.                      {
     
106.                              int i = 10;
     
107.                              while ( i-- )
     
108.                              {
     
109.      //                              printf ( "in grandsun , pid= %d\nin grandsun , ppid= %d\n", getpid(), getppid() );
     
110.                                      fflush( stdout );
     
111.                                      sleep ( 1 );
     
112.                              }
     
113.                      }
     
114.              }
     
115.    
     
116.              return 0;
     
117.      }
     
118.    
     
119. 
     
120. 
     
121. 
     

复制代码

[ 本帖最后由 net_robber 于 2007-3-13 10:07 编辑 ]

net_robber

关于使用PGID的方法

请注意代码的第30行

这里需要说明：
setpgid函数后，本进程不再使用父进程的gid
其后，本进程产生的子进程使用本进程setpgid以后的gid


因此可以做到 SIGKILL后杀死本进程及本进程的所有子进程

isnowran

2个问题
1。生成进程后马上杀掉进程，这么做好像没什么意义，毕竟搂长的初衷是怎么杀掉所有子进程，此时应该父进程应该是已经生成一堆进程后并且没有保存子进程pid的情况

2。既然是指定pid单独发送信号，子进程再设置为组长好像没什么意义

net_robber

前几天，有个兄弟踢出了一个要杀掉所有子进程的问题

我当时作出了一些回答，但是并没有帮他完全解决问题。

所以，这里，我尝试把这个问题彻底解决

上面的代码只是一个DEMO。


谢谢关注，呵呵

只是不知道，当初提出这个问题的那位 兄弟（沙发），有没有看到这个帖子。

如果看到了，希望告知，我得方法能不能帮你解决问题