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

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

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

#include "../apue.h" 
#include <sys/wait.h> 

#define CLD_NUM 2
static void sig_cld (int signo)
{
    pid_t pid = 0; 
    int status = 0; 
    printf ("SIGCHLD received\n"); 
    if (signal (SIGCHLD, sig_cld) == SIG_ERR)
        perror ("signal error"); 
    if ((pid = wait (&status)) < 0)
        perror ("wait(in signal) error"); 
    printf ("pid (wait in signal) = %d\n", pid); 
}

int main ()
{
    pid_t pid = 0; 
    __sighandler_t ret = signal (SIGCHLD, sig_cld);
    if (ret == SIG_ERR)
        perror ("signal error"); 
    else 
        printf ("old handler %x\n", ret); 

    for (int i=0; i<CLD_NUM; ++ i)
    {
        if ((pid = fork ()) < 0)
            perror ("fork error"); 
        else if (pid == 0) 
        {
            sleep (3); 
            printf ("child %u exit\n", getpid ()); 
            _exit (0); 
        }

        sleep (1); 
    }

    for (int i=0; i<CLD_NUM; ++ i)
    {
        pause (); 
        printf ("wake up by signal %d\n", i); 
    }

    printf ("parent exit\n"); 
    return 0; 
}

 

父程式啟動了兩個子程式，在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介面：

#include "../apue.h" 
#include <sys/wait.h> 

#define CLD_NUM 2
static void sig_cld (int signo, siginfo_t *info, void* param)
{
    int status = 0; 
    if (signo == SIGCHLD)
    {
        if (info->si_code == CLD_EXITED ||
                info->si_code == CLD_KILLED || 
                info->si_code == CLD_DUMPED)
        {
            //printf ("child %d die\n", info->si_pid); 
            if (waitpid (info->si_pid, &status, 0) < 0)
                perror ("wait(in signal) error"); 
            printf ("pid (wait in signal) = %d\n", info->si_pid); 
        }
        else 
        {
            printf ("unknown signal code %d\n", info->si_code); 
        }
    }
}

int main ()
{
    pid_t pid = 0; 
    struct sigaction act; 
    sigemptyset (&act.sa_mask); 
    act.sa_sigaction = sig_cld; 
    act.sa_flags = SA_SIGINFO | SA_NOCLDSTOP; 
    int ret = sigaction (SIGCHLD, &act, 0); 
    if (ret == -1)
        perror ("sigaction error"); 

    for (int i=0; i<CLD_NUM; ++ i)
    {
        if ((pid = fork ()) < 0)
            perror ("fork error"); 
        else if (pid == 0) 
        {
            sleep (3); 
            printf ("child %u exit\n", getpid ()); 
            _exit (0); 
        }

        sleep (1); 
    }

    for (int i=0; i<CLD_NUM; ++ i)
    {
        pause (); 
        printf ("wake up by signal %d\n", i); 
    }

    printf ("parent exit\n"); 
    return 0; 
}

輸出是一樣的。

關於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，因此是完全相同的；

 

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

#include "../apue.h" 
#include <sys/wait.h> 

#define CLD_NUM 2
void pid_remove (pid_t pid)
{
    printf ("remove pid %u\n", pid); 
}
void pid_add (pid_t pid)
{
    printf ("add pid %u\n", pid); 
}

static void sig_cld (int signo)
{
    pid_t pid = 0; 
    int status = 0; 
    printf ("SIGCHLD received\n"); 
    if (signal (SIGCHLD, sig_cld) == SIG_ERR)
        perror ("signal error"); 
    if ((pid = wait (&status)) < 0)
        perror ("wait(in signal) error"); 
    printf ("pid (wait in signal) = %d\n", pid); 
    pid_remove (pid); 
}

int main ()
{
    pid_t pid = 0; 
    __sighandler_t ret = signal (SIGCHLD, sig_cld);
    if (ret == SIG_ERR)
        perror ("signal error"); 
    else 
        printf ("old handler %x\n", ret); 

    for (int i=0; i<CLD_NUM; ++ i)
    {
        if ((pid = fork ()) < 0)
            perror ("fork error"); 
        else if (pid == 0) 
        {
            //sleep (3); 
            printf ("child %u exit\n", getpid ()); 
            _exit (0); 
        }

        sleep (1);
        pid_add (pid);  
    }

    sleep (1); 
    printf ("parent exit\n"); 
    return 0; 
}

 

父程式在啟動子程式後需要將它的資訊通過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訊號：

#include "../apue.h" 
#include <sys/wait.h> 

#define CLD_NUM 2
void pid_remove (pid_t pid)
{
    printf ("remove pid %u\n", pid); 
}
void pid_add (pid_t pid)
{
    printf ("add pid %u\n", pid); 
}

static void sig_cld (int signo)
{
    pid_t pid = 0; 
    int status = 0; 
    printf ("SIGCHLD received\n"); 
    if (signal (SIGCHLD, sig_cld) == SIG_ERR)
        perror ("signal error"); 
    if ((pid = wait (&status)) < 0)
        perror ("wait(in signal) error"); 
    printf ("pid (wait in signal) = %d\n", pid); 
    pid_remove (pid); 
}

int main ()
{
    pid_t pid = 0; 
    __sighandler_t ret = signal (SIGCHLD, sig_cld);
    if (ret == SIG_ERR)
        perror ("signal error"); 
    else 
        printf ("old handler %x\n", ret); 

    for (int i=0; i<CLD_NUM; ++ i)
    {
        sigset_t mask; 
        sigemptyset(&mask);
        sigaddset(&mask, SIGCHLD);
        sigprocmask(SIG_BLOCK, &mask, NULL);
        if ((pid = fork ()) < 0)
            perror ("fork error"); 
        else if (pid == 0) 
        {
            sigprocmask(SIG_UNBLOCK, &mask, NULL);
            //sleep (3); 
            printf ("child %u exit\n", getpid ()); 
            _exit (0); 
        }

        sleep (1);
        pid_add (pid);  
        sigprocmask(SIG_UNBLOCK, &mask, NULL);
    }

    sleep (1); 
    printf ("parent exit\n"); 
    return 0; 
}

 

這裡用到了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函式族的場景。典型程式碼如下：

#include "../apue.h" 
#include <sys/wait.h> 

#define CLD_NUM 2
int main ()
{
    pid_t pid = 0; 
    for (int i=0; i<CLD_NUM; ++ i)
    {
        if ((pid = fork ()) < 0)
            perror ("fork error"); 
        else if (pid == 0) 
        {
            sleep (3); 
            printf ("child %u exit\n", getpid ()); 
            _exit (0); 
        }

        sleep (1); 
    }

    int status = 0; 
    for (int i=0; i<CLD_NUM; ++ i)
    {
        if ((pid = wait (&status)) < 0)
            perror ("wait error"); 

        printf ("pid = %d\n", pid); 
    }

    printf ("parent exit\n"); 
    return 0; 
}

 

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

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，典型的程式碼如下所示：

#include "../apue.h" 
#include <sys/wait.h> 
#include <errno.h> 

#define CLD_NUM 2

static void sig_cld (int signo)
{
    pid_t pid = 0; 
    int status = 0; 
    printf ("SIGCLD received\n"); 
    if (signal (SIGCLD, sig_cld) == SIG_ERR)
        perror ("signal error"); 

    if ((pid = wait (&status)) < 0)
        perror ("wait(in signal) error"); 
    else
        printf ("pid (wait in signal) = %d\n", pid); 
}

int main ()
{
    pid_t pid = 0; 
    __sighandler_t ret = signal (SIGCLD, sig_cld);
    if (ret == SIG_ERR)
        perror ("signal error"); 
    else 
        printf ("old handler %x\n", ret); 

    for (int i=0; i<CLD_NUM; ++ i)
    {
        if ((pid = fork ()) < 0)
            perror ("fork error"); 
        else if (pid == 0) 
        {
            if (i % 2 == 0) { 
                // simulate background
                sleep (3); 
            }
            else {
                // simulate foreground
                sleep (4); 
            }

            printf ("child %u exit\n", getpid ()); 
            _exit (0); 
        }

        sleep (1); 
    }

    int status = 0; 
    printf ("before wait pid %u\n", pid); 
    if (waitpid (pid, &status, 0) < 0)
        printf ("wait %u error %d\n", pid, errno); 
    else
        printf ("wait child pid = %d\n", pid); 

    sleep (2);
    printf ("parent exit\n"); 
    return 0; 
}

 

父程式啟動兩個子程式，第一個休眠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：

    int status = 0; 
    while (1) { 
        printf ("before wait pid %u\n", pid); 
        if (waitpid (pid, &status, 0) < 0)
        {
            int err = errno; 
            printf ("wait %u error %d\n", pid, err); 
            if (err == EINTR)
                continue; 
        }
        else
            printf ("wait child pid = %d\n", pid); 

        break; 
    }

 

如果因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以獲取更多的控制，我們看看換新的方式捕獲訊號，會不會有一些改變，新的程式碼邏輯如下：

#include "../apue.h" 
#include <sys/wait.h> 
#include <errno.h> 

#define CLD_NUM 2

static void sig_cld (int signo, siginfo_t *info, void* param)
{
    int status = 0; 
    if (signo == SIGCHLD)
    {
        if (info->si_code == CLD_EXITED ||
                info->si_code == CLD_KILLED || 
                info->si_code == CLD_DUMPED)
        {
            if (waitpid (info->si_pid, &status, 0) < 0)
                err_ret ("wait(in signal) %u error", info->si_pid); 
            else 
                printf ("pid (wait in signal) = %d\n", info->si_pid); 
        }
        else 
        {
            printf ("unknown signal code %d\n", info->si_code); 
        }
    }
}

int main ()
{
    pid_t pid = 0; 
    struct sigaction act; 
    sigemptyset (&act.sa_mask); 
    act.sa_sigaction = sig_cld; 
    act.sa_flags = SA_SIGINFO | SA_NOCLDSTOP; 
    int ret = sigaction (SIGCHLD, &act, 0); 
    if (ret == -1)
        perror ("sigaction error"); 

    for (int i=0; i<CLD_NUM; ++ i)
    {
        if ((pid = fork ()) < 0)
            perror ("fork error"); 
        else if (pid == 0) 
        {
            if (i % 2 == 0) { 
                // simulate background
                sleep (3); 
            }
            else {
                // simulate foreground
                sleep (4); 
            }

            printf ("child %u exit\n", getpid ()); 
            _exit (0); 
        }

        sleep (1); 
    }

    int status = 0; 
    while (1) { 
        printf ("before wait pid %u\n", pid); 
        if (waitpid (pid, &status, 0) < 0)
        {
            int err = errno; 
            printf ("wait %u error %d\n", pid, err); 
            if (err == EINTR)
                continue; 
        }
        else
            printf ("wait child pid = %d\n", pid); 

        break; 
    }

    sleep (2);
    printf ("parent exit\n"); 
    return 0; 
}

 

執行輸出如下：

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示例