1. 程式人生 > >[apue] 等待子程序的那些事兒

[apue] 等待子程序的那些事兒

談到等待子程序,首先想到的就是SIGCHLD訊號與wait函式族,本文試圖釐清二者的方方面面,以及組合使用時可能不小心掉進去的坑。

1. 首先談單獨使用SIGCHLD的場景。下面是一段典型的程式碼片段:

 1 #include "../apue.h" 
 2 #include <sys/wait.h> 
 3 
 4 #define CLD_NUM 2
 5 static void sig_cld (int signo)
 6 {
 7     pid_t pid = 0; 
 8     int status = 0; 
 9     printf ("SIGCHLD received\n"); 
10     if (signal (SIGCHLD, sig_cld) == SIG_ERR)
11         perror ("signal error"); 
12     if ((pid = wait (&status)) < 0)
13         perror ("wait(in signal) error"); 
14     printf ("pid (wait in signal) = %d\n", pid); 
15 }
16 
17 int main ()
18 {
19     pid_t pid = 0; 
20     __sighandler_t ret = signal (SIGCHLD, sig_cld);
21     if (ret == SIG_ERR)
22         perror ("signal error"); 
23     else 
24         printf ("old handler %x\n", ret); 
25 
26     for (int i=0; i<CLD_NUM; ++ i)
27     {
28         if ((pid = fork ()) < 0)
29             perror ("fork error"); 
30         else if (pid == 0) 
31         {
32             sleep (3); 
33             printf ("child %u exit\n", getpid ()); 
34             _exit (0); 
35         }
36 
37         sleep (1); 
38     }
39 
40     for (int i=0; i<CLD_NUM; ++ i)
41     {
42         pause (); 
43         printf ("wake up by signal %d\n", i); 
44     }
45 
46     printf ("parent exit\n"); 
47     return 0; 
48 }

 

父程序啟動了兩個子程序,在SIGCHLD訊號處理器中呼叫wait等待已結束的子程序,回收程序資訊,防止產生殭屍程序(zombie)。上面的程式碼會有如下的輸出:

old handler 0
child 28542 exit
SIGCLD received
pid (wait in signal) = 28542
wake up by signal 0
child 28543 exit
SIGCLD received
pid (wait in signal) = 28543
wake up by signal 1
parent exit

 

當然捕獲SIGCHLD,也可以使用sigaction介面:

 1 #include "../apue.h" 
 2 #include <sys/wait.h> 
 3 
 4 #define CLD_NUM 2
 5 static void sig_cld (int signo, siginfo_t *info, void* param)
 6 {
 7     int status = 0; 
 8     if (signo == SIGCHLD)
 9     {
10         if (info->si_code == CLD_EXITED ||
11                 info->si_code == CLD_KILLED || 
12                 info->si_code == CLD_DUMPED)
13         {
14             //printf ("child %d die\n", info->si_pid); 
15             if (waitpid (info->si_pid, &status, 0) < 0)
16                 perror ("wait(in signal) error"); 
17             printf ("pid (wait in signal) = %d\n", info->si_pid); 
18         }
19         else 
20         {
21             printf ("unknown signal code %d\n", info->si_code); 
22         }
23     }
24 }
25 
26 int main ()
27 {
28     pid_t pid = 0; 
29     struct sigaction act; 
30     sigemptyset (&act.sa_mask); 
31     act.sa_sigaction = sig_cld; 
32     act.sa_flags = SA_SIGINFO | SA_NOCLDSTOP; 
33     int ret = sigaction (SIGCHLD, &act, 0); 
34     if (ret == -1)
35         perror ("sigaction error"); 
36 
37     for (int i=0; i<CLD_NUM; ++ i)
38     {
39         if ((pid = fork ()) < 0)
40             perror ("fork error"); 
41         else if (pid == 0) 
42         {
43             sleep (3); 
44             printf ("child %u exit\n", getpid ()); 
45             _exit (0); 
46         }
47 
48         sleep (1); 
49     }
50 
51     for (int i=0; i<CLD_NUM; ++ i)
52     {
53         pause (); 
54         printf ("wake up by signal %d\n", i); 
55     }
56 
57     printf ("parent exit\n"); 
58     return 0; 
59 }

輸出是一樣的。

關於signal與sigaction的區別,有以下幾點:

a) 使用sigaction可以避免重新安裝訊號處理器的問題;

b) 使用sigaction可以在wait之前得知是哪個子程序結束了,這是通過指定SA_SIGINFO標誌位,並提供帶siginfo_t引數的訊號處理器來實現的(info->si_pid就是結束的程序號);

c) 使用sigaction可以獲取除子程序結束以外的狀態變更通知,例如掛起、繼續,預設接收相應通知,除非指定SA_NOCLDSTOP標誌。而對於signal而言,沒有辦法不接收子程序非結束狀態的通知(此時呼叫wait可能會卡死);

d) 使用sigaction可以自動wait已結束的子程序,只要指定SA_NOCLDWAIT標誌即可。此時在訊號處理器中不用再呼叫wait函數了。

  當使用SA_NOCLDWAIT標誌位時,使用systemtap可以觀察到子程序還是向父程序傳送了SIGCHLD訊號的:

30049    cldsig           30048 cldsig           17     SIGCHLD         
30050    cldsig           30048 cldsig           17     SIGCHLD       

   很有可能是系統內部自動wait了相關子程序。

  另外在使用SA_NOCLDWAIT時,可以不指定訊號處理器,此時sa_sigaction欄位可以設定為SIG_DFL。

 

關於SIGCHLD訊號,有以下幾點需要注意:

a) 如果在註冊訊號之前,就已經有已結束但未等待的子程序存在,則事件不會被觸發;

b) 可以為SIGCHLD註冊一個處理器,也可以忽略該訊號(SIG_IGN),忽略時系統自動回收已結束的子程序;

  當正常捕獲SIGCHLD時,使用systemtap是可以觀察到子程序向父程序傳送的SIGCHLD訊號的:

29877    cldsig           29876 cldsig           17     SIGCHLD         
29878    cldsig           29876 cldsig           17     SIGCHLD         
29876    cldsig           27771 bash             17     SIGCHLD         

   當忽略SIGCHLD時,是看不到的,只能看到父程序結束時向bash傳送的SIGCHLD訊號:

29893    cldsig           27771 bash             17     SIGCHLD  

   這裡注意一下二者在細節處的一點區別。

 c) 還有一個SIGCLD訊號,在大多數unix like系統中與SIGCHLD表現一致,在某些古老的unix系統上,可能有獨特的表現需要注意,這方面請參考 apue 第十章第七節

  在我測試的環境上(CentOS 6.7),該訊號被定義為SIGCHLD,因此是完全相同的;

 

關於使用訊號等待子程序最後需要談的一點就是訊號的競爭行為,對上面的例子稍加修改,就可以演示一下:

 1 #include "../apue.h" 
 2 #include <sys/wait.h> 
 3 
 4 #define CLD_NUM 2
 5 void pid_remove (pid_t pid)
 6 {
 7     printf ("remove pid %u\n", pid); 
 8 }
 9 void pid_add (pid_t pid)
10 {
11     printf ("add pid %u\n", pid); 
12 }
13 
14 static void sig_cld (int signo)
15 {
16     pid_t pid = 0; 
17     int status = 0; 
18     printf ("SIGCHLD received\n"); 
19     if (signal (SIGCHLD, sig_cld) == SIG_ERR)
20         perror ("signal error"); 
21     if ((pid = wait (&status)) < 0)
22         perror ("wait(in signal) error"); 
23     printf ("pid (wait in signal) = %d\n", pid); 
24     pid_remove (pid); 
25 }
26 
27 int main ()
28 {
29     pid_t pid = 0; 
30     __sighandler_t ret = signal (SIGCHLD, sig_cld);
31     if (ret == SIG_ERR)
32         perror ("signal error"); 
33     else 
34         printf ("old handler %x\n", ret); 
35 
36     for (int i=0; i<CLD_NUM; ++ i)
37     {
38         if ((pid = fork ()) < 0)
39             perror ("fork error"); 
40         else if (pid == 0) 
41         {
42             //sleep (3); 
43             printf ("child %u exit\n", getpid ()); 
44             _exit (0); 
45         }
46 
47         sleep (1);
48         pid_add (pid);  
49     }
50 
51     sleep (1); 
52     printf ("parent exit\n"); 
53     return 0; 
54 }

 

父程序在啟動子程序後需要將它的資訊通過pid_add新增到某種資料結構中,當收到SIGCHLD訊號後,又通過pid_remove將它從這個資料結構中移出。

在上面的例子中,子程序一啟動就退出了,快到甚至父程序還沒有來得及執行pid_add就先執行了pid_remove,這必然導致某種問題。

(注意,為了能更好的呈現訊號競爭的問題,這裡故意在父程序sleep之後呼叫pid_add),執行結果如下:

old handler 0
child 31213 exit
SIGCLD received
pid (wait in signal) = 31213
remove pid 31213
add pid 31213
child 31214 exit
SIGCLD received
pid (wait in signal) = 31214
remove pid 31214
add pid 31214
parent exit

 

可以看到,remove總是在add之前執行。而解決方案也很直接,就是在pid_add完成之前,我們需要遮蔽SIGCHLD訊號:

 1 #include "../apue.h" 
 2 #include <sys/wait.h> 
 3 
 4 #define CLD_NUM 2
 5 void pid_remove (pid_t pid)
 6 {
 7     printf ("remove pid %u\n", pid); 
 8 }
 9 void pid_add (pid_t pid)
10 {
11     printf ("add pid %u\n", pid); 
12 }
13 
14 static void sig_cld (int signo)
15 {
16     pid_t pid = 0; 
17     int status = 0; 
18     printf ("SIGCHLD received\n"); 
19     if (signal (SIGCHLD, sig_cld) == SIG_ERR)
20         perror ("signal error"); 
21     if ((pid = wait (&status)) < 0)
22         perror ("wait(in signal) error"); 
23     printf ("pid (wait in signal) = %d\n", pid); 
24     pid_remove (pid); 
25 }
26 
27 int main ()
28 {
29     pid_t pid = 0; 
30     __sighandler_t ret = signal (SIGCHLD, sig_cld);
31     if (ret == SIG_ERR)
32         perror ("signal error"); 
33     else 
34         printf ("old handler %x\n", ret); 
35 
36     for (int i=0; i<CLD_NUM; ++ i)
37     {
38         sigset_t mask; 
39         sigemptyset(&mask);
40         sigaddset(&mask, SIGCHLD);
41         sigprocmask(SIG_BLOCK, &mask, NULL);
42         if ((pid = fork ()) < 0)
43             perror ("fork error"); 
44         else if (pid == 0) 
45         {
46             sigprocmask(SIG_UNBLOCK, &mask, NULL);
47             //sleep (3); 
48             printf ("child %u exit\n", getpid ()); 
49             _exit (0); 
50         }
51 
52         sleep (1);
53         pid_add (pid);  
54         sigprocmask(SIG_UNBLOCK, &mask, NULL);
55     }
56 
57     sleep (1); 
58     printf ("parent exit\n"); 
59     return 0; 
60 }

 

這裡用到了sigprocmask去遮蔽以及解除某種訊號的遮蔽。新的程式碼執行結果如下:

old handler 0
child 31246 exit
add pid 31246
SIGCLD received
pid (wait in signal) = 31246
remove pid 31246
child 31247 exit
SIGCLD received
pid (wait in signal) = 31247
remove pid 31247
add pid 31247
parent exit

 

可以看到一切正常了,add這次位於remove之前。

 

總結一下,使用SIGCHLD訊號適合非同步等待子程序的場景,並且通常搭配wait來回收子程序。

 

2. 然後談單獨使用wait函式族的場景。典型程式碼如下:

 1 #include "../apue.h" 
 2 #include <sys/wait.h> 
 3 
 4 #define CLD_NUM 2
 5 int main ()
 6 {
 7     pid_t pid = 0; 
 8     for (int i=0; i<CLD_NUM; ++ i)
 9     {
10         if ((pid = fork ()) < 0)
11             perror ("fork error"); 
12         else if (pid == 0) 
13         {
14             sleep (3); 
15             printf ("child %u exit\n", getpid ()); 
16             _exit (0); 
17         }
18 
19         sleep (1); 
20     }
21 
22     int status = 0; 
23     for (int i=0; i<CLD_NUM; ++ i)
24     {
25         if ((pid = wait (&status)) < 0)
26             perror ("wait error"); 
27 
28         printf ("pid = %d\n", pid); 
29     }
30 
31     printf ("parent exit\n"); 
32     return 0; 
33 }

 

與之前場景不同的是,這裡父程序同步等待啟動的子程序結束。上面的程式碼會有如下輸出:

child 28583 exit
child 28584 exit
pid = 28583
pid = 28584
parent exit

 

關於wait函式族,需要注意以下幾點:

a) wait用於等待任何一個子程序,相當於waitpid(-1, status, 0); 當沒有任何子程序存在時,返回-1,errno設定為ECHILD;

b) waitpid相對於wait的優勢在於:

  i) 可以指定子程序(組)來等待;

  ii) 可以捕獲子程序除結束以外的其它狀態變更通知,如掛起(WUNTRACED)、繼續(WCONTINUED)等;

  iii) 可以不阻塞的測試某個子程序是否已結束(WNOHANG);

c) wait函式族可被訊號中斷,此時返回-1,errno設定為EINTR,必要時需要重啟wait;

 

總結一下,使用wait函式族適合同步等待子程序,例如某種命令執行器程序,通常配合waitpid來回收子程序。

 

3. 最後談談混合使用同步wait與非同步wait函式族的場景。

其實前面已經提到SIGCHLD要搭配wait使用,但那是非同步使用wait的單一場景,而這裡講的混合,是指同時在訊號處理器與執行流程中使用wait。

例如bash,它除了在主流程中同步等待前臺正在執行的子程序,還必需在訊號處理器中非同步接收後臺執行子程序的狀態反饋,這樣就不得不混合使用wait。

同步等待某個子程序一般使用waitpid,而在訊號處理器中一般使用wait,典型的程式碼如下所示:

 1 #include "../apue.h" 
 2 #include <sys/wait.h> 
 3 #include <errno.h> 
 4 
 5 #define CLD_NUM 2
 6 
 7 static void sig_cld (int signo)
 8 {
 9     pid_t pid = 0; 
10     int status = 0; 
11     printf ("SIGCLD received\n"); 
12     if (signal (SIGCLD, sig_cld) == SIG_ERR)
13         perror ("signal error"); 
14 
15     if ((pid = wait (&status)) < 0)
16         perror ("wait(in signal) error"); 
17     else
18         printf ("pid (wait in signal) = %d\n", pid); 
19 }
20 
21 int main ()
22 {
23     pid_t pid = 0; 
24     __sighandler_t ret = signal (SIGCLD, sig_cld);
25     if (ret == SIG_ERR)
26         perror ("signal error"); 
27     else 
28         printf ("old handler %x\n", ret); 
29 
30     for (int i=0; i<CLD_NUM; ++ i)
31     {
32         if ((pid = fork ()) < 0)
33             perror ("fork error"); 
34         else if (pid == 0) 
35         {
36             if (i % 2 == 0) { 
37                 // simulate background
38                 sleep (3); 
39             }
40             else {
41                 // simulate foreground
42                 sleep (4); 
43             }
44 
45             printf ("child %u exit\n", getpid ()); 
46             _exit (0); 
47         }
48 
49         sleep (1); 
50     }
51 
52     int status = 0; 
53     printf ("before wait pid %u\n", pid); 
54     if (waitpid (pid, &status, 0) < 0)
55         printf ("wait %u error %d\n", pid, errno); 
56     else
57         printf ("wait child pid = %d\n", pid); 
58 
59     sleep (2);
60     printf ("parent exit\n"); 
61     return 0; 
62 }

 

父程序啟動兩個子程序,第一個休眠3秒後退出,第二個休眠4秒後退出,由於父程序同步等待的是第二個子程序,因此第二個程序模擬前臺程序,第一個程序模擬後臺程序。執行輸出如下:

old handler 0
before wait pid 2481
child 2480 exit
SIGCLD received
pid (wait in signal) = 2480
wait 2481 error 4
child 2481 exit
SIGCLD received
pid (wait in signal) = 2481
parent exit

 

此時同步等待的waitpid被訊號中斷了(EINTR),此種情況下,我們需要重啟waitpid:

 1     int status = 0; 
 2     while (1) { 
 3         printf ("before wait pid %u\n", pid); 
 4         if (waitpid (pid, &status, 0) < 0)
 5         {
 6             int err = errno; 
 7             printf ("wait %u error %d\n", pid, err); 
 8             if (err == EINTR)
 9                 continue; 
10         }
11         else
12             printf ("wait child pid = %d\n", pid); 
13 
14         break; 
15     }

 

如果因EINTR引發的錯誤,則重新呼叫waitpid;否則,退出。新的程式碼輸出如下:

old handler 0
before wait pid 2513
child 2512 exit
SIGCLD received
pid (wait in signal) = 2512
wait 2513 error 4
before wait pid 2513
child 2513 exit
SIGCLD received
wait(in signal) error: No child processes
wait child pid = 2513
parent exit

 

 可以看到兩個程序退出時,都收到了SIGCHLD訊號,只是前臺程序被waitpid優先等待到了,所以訊號處理器中的wait返回的ECHILD錯誤,但是如果還有其它子程序在執行,這裡將會在訊號處理器的wait中卡死。

之前提到,可以使用SIG_IGN來自動回收子程序,這裡試一下使用SIG_IGN來代替sig_cld,看看有什麼改觀。

old handler 0
before wait pid 2557
child 2556 exit
child 2557 exit
wait 2557 error 10
parent exit

 

  同樣的,兩個子程序都走了忽略訊號,而同步等待的waitpid因沒有程序可等返回了ECHILD。因為waitpid是指定程序等待的,所以即使還有其它子程序存在,這個也會返回錯誤,不會卡死在那裡。

相比上面的方法,似乎好了一點,但是因為我們沒有安裝處理器,所以無從得知哪個後臺程序結束了,這並不是我們想到的結果。

之前提到,可以使用sigaction代替signal以獲取更多的控制,我們看看換新的方式捕獲訊號,會不會有一些改變,新的程式碼邏輯如下:

 1 #include "../apue.h" 
 2 #include <sys/wait.h> 
 3 #include <errno.h> 
 4 
 5 #define CLD_NUM 2
 6 
 7 static void sig_cld (int signo, siginfo_t *info, void* param)
 8 {
 9     int status = 0; 
10     if (signo == SIGCHLD)
11     {
12         if (info->si_code == CLD_EXITED ||
13                 info->si_code == CLD_KILLED || 
14                 info->si_code == CLD_DUMPED)
15         {
16             if (waitpid (info->si_pid, &status, 0) < 0)
17                 err_ret ("wait(in signal) %u error", info->si_pid); 
18             else 
19                 printf ("pid (wait in signal) = %d\n", info->si_pid); 
20         }
21         else 
22         {
23             printf ("unknown signal code %d\n", info->si_code); 
24         }
25     }
26 }
27 
28 int main ()
29 {
30     pid_t pid = 0; 
31     struct sigaction act; 
32     sigemptyset (&act.sa_mask); 
33     act.sa_sigaction = sig_cld; 
34     act.sa_flags = SA_SIGINFO | SA_NOCLDSTOP; 
35     int ret = sigaction (SIGCHLD, &act, 0); 
36     if (ret == -1)
37         perror ("sigaction error"); 
38 
39     for (int i=0; i<CLD_NUM; ++ i)
40     {
41         if ((pid = fork ()) < 0)
42             perror ("fork error"); 
43         else if (pid == 0) 
44         {
45             if (i % 2 == 0) { 
46                 // simulate background
47                 sleep (3); 
48             }
49             else {
50                 // simulate foreground
51                 sleep (4); 
52             }
53 
54             printf ("child %u exit\n", getpid ()); 
55             _exit (0); 
56         }
57 
58         sleep (1); 
59     }
60 
61     int status = 0; 
62     while (1) { 
63         printf ("before wait pid %u\n", pid); 
64         if (waitpid (pid, &status, 0) < 0)
65         {
66             int err = errno; 
67             printf ("wait %u error %d\n", pid, err); 
68             if (err == EINTR)
69                 continue; 
70         }
71         else
72             printf ("wait child pid = %d\n", pid); 
73 
74         break; 
75     }
76 
77     sleep (2);
78     printf ("parent exit\n"); 
79     return 0; 
80 }

 

執行輸出如下:

before wait pid 2585
child 2584 exit
pid (wait in signal) = 2584
wait 2585 error 4
before wait pid 2585
child 2585 exit
wait(in signal) 2585 error: No child processes
wait child pid = 2585
parent exit

 

  結果與使用signal很相似,但是因為在訊號處理器中我們能明確的知道是哪個子程序終結了,使用的是waitpid而不是wait,所以即使還有其它子程序未結束,也不會在訊號處理器的waitpid中卡住。

結論是無論使用signal還是sigaction,同步等待的waitpid總比SIGCHLD訊號處理器中的wait(xxx)具有更高的優先順序。當然,這個前提是在父程序同步waitpid之前,子程序還沒有結束;

如果要等待的子程序先結束了,SIGCHLD當然先被執行,這種情況下,建議先使用sigprocmask遮蔽SIGCHLD訊號,然後在waitpid之前解除遮蔽。雖然不能保證完全解決訊號競爭的問題,

也能極大的緩解此種情況,即使出現了訊號競爭,導致同步等待的waitpid返回ECHILD,我們也能從這些錯誤碼中得知發生的事情,不會出現卡死的情況。

 

出於好奇,我們看一下改使用SIG_IGN後的執行效果:

before wait pid 2613
child 2612 exit
child 2613 exit
wait 2613 error 10
parent exit

 

與使用signal時並無二致,仍然是忽略訊號佔了上風。結論是無論使用signal還是sigaction,當忽略SIGCHLD訊號時,訊號優先於wait被忽略。出於同樣的原因,這種方式我們並不採納。

之前提到,sigaction還有一種高階的忽略SIGCHLD的方式,即指定SA_NOCLDWAIT標誌位,同時給訊號處理器指定SIG_DFL,這種情況下,我們看看輸出會有什麼變化:

before wait pid 2719
child 2718 exit
child 2719 exit
wait 2719 error 10
parent exit

 

 可以看到,與使用SIG_IGN並無二致。

與SIG_IGN不同的是,我們可以為SIGCHLD提供一個處理器,雖然在此訊號處理器中無需再次等待子程序,但是我們擁有了獲取子程序資訊的能力,相對而言,比SIG_IGN更有用一些。新的輸出如下:

before wait pid 2737
child 2736 exit
pid (auto wait in signal) = 2736
wait 2737 error 4
before wait pid 2737
child 2737 exit
pid (auto wait in signal) = 2737
wait 2737 error 10
parent exit

 

可以看到,同步waitpid仍然返回ECHILD,顯然是訊號更具有優先順序。

 

好了,到這裡就全明瞭了,對於混合使用同步與非同步wait的應用來說,最佳的方法應該是同步waitpid等待前臺程序,非同步使用sigaction註冊SIGCHLD訊號處理器等待後臺程序,且不設定SA_NOCLDWAIT標誌位。

在處理器中也應使用waitpid等待子程序,如返回ECHILD錯誤,證明該子程序是前臺程序,已經被同步wait掉了,不需要後續處理;否則作為後臺程序處理。

 

 最後,我們發現同步等待的waitpid沒有被中斷的情況只在忽略訊號的時候產生,而之前也證明了忽略訊號時,系統壓根不產生SIGCHLD訊號,這兩者似乎到現在是對上了…… :)

 

場景 1&2 測試程式碼

場景3 測試程式碼

完整的shell