在實際開發中難免會處理程序間的關係，最常見的是父子程序的相互監督。父程序等待子程序，或者自程序知道父程序執行是否結束，以方便釋放資源。

一、關於程序

程序是作業系統進行資源分配和排程的基本單位。linux系統使用fork建立程序，程序pid 0是swapper程序，程序pid 1是init程序，init程序是所有普通使用者程序的父程序。 fork在 <unistd.h>檔案中定義如下： pid_t fork(void); 當fork成功時會返回兩次，一次返回給父程序，一次返回給子程序。 如果fork呼叫成功，返回pid > 0 給父程序，返回pid == 0給子程序。 如果fork呼叫失敗，返回pid == -1給父程序，並且設定errno。

二、父程序與子程序的關係

通過fork後，為什麼父程序返回pid > 0，而子程序返回pid == 0呢？這是因為父程序無法知道自己有多少子程序，子程序建立後就獨立於父程序了，無法知道子程序的id。子程序能夠通過getppid獲取父程序的pid。當父程序比子程序提前退出時，子程序會成為孤兒程序，系統會將重置孤兒程序的父程序到init程序ppid == 1。如果子程序提前退出並且父程序沒有使用wait函式監聽處理結束的子程序，那麼該子程序會成為殭屍程序，即系統認為該程序存在，它佔用的程序資訊如程序pid等，會導致系統無法重複利用該pid號，可以這麼理解殭屍程序就是名存實亡的程序，系統認為程序還存在，而子程序已經完成他的執行任務了。

三、簡單的程序例程

simple_process.cpp

#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/wait.h>

int main(int argc, char *argv[]) {
    printf("start program %s, pid: %ld, ppid: %ld \n", argv[0], getpid(), getppid());
    pid_t pid = fork();
    if (-1 == pid) {
        printf("fork process failed. errno: %u, error: %s\n", errno, strerror(errno));
        exit(-1);
    }   
    if (pid > 0) { // parent 
        printf("parent precess\n");
        sleep(1);
/** 標記一、wait 等待子程序結束*/
//      int status;
//      wait(&status);
    } else { // child 
        printf("child process, pid: %ld, ppid: %ld\n", getpid(), getppid());
        for (int i = 0; i < 5; i++) {
            printf("child sleep %ds\n", i); 
            sleep(1);
        }   
        printf("##child process, pid: %ld, ppid: %ld\n", getpid(), getppid());
    }   
    return 0;
}
 

編譯執行 $ g++ simple_process.cpp $ ./a.out start program ./a.out, pid: 17164, ppid: 8564 parent precess child process, pid: 17165, ppid: 17164 child sleep 0s [[email protected] process-wait]$ child sleep 1s child sleep 2s child sleep 3s child sleep 4s ##child process, pid: 17165, ppid: 1 可以看到，當父程序提前結束時，子程序的父進臣變化為init程序，ppid == 1。

四、實現父程序監聽子程序執行結束

如果我們把“標誌一”的wait程式碼刪除註釋， 即 使用下面程式碼

     /** 標記一、wait 等待子程序結束 */
     int status;
     wait(&status);

編譯 $ g++ simple_process.cpp $ ./a.out start program ./a.out, pid: 28989, ppid: 8564 parent precess child process, pid: 28990, ppid: 28989 child sleep 0s child sleep 1s child sleep 2s child sleep 3s child sleep 4s ##child process, pid: 28990, ppid: 28989 因為wait函式的作用是等待子程序結束，並獲取子程序結束的狀態，所以父程序wait等待子程序結束後才繼續執行退出，故自程序的ppid一直是原來fork父程序的pid。因為wait函式是阻塞的，所以在實際開發中，需要監聽子程序退出，可以新建執行緒來監聽，並通過回撥函式處理。

五、實現子程序監聽父程序執行結束

fork建立程序以後子程序就成為獨立的執行單位（程序是作業系統資源分配和排程的基本單位），雖然子程序會繼承父程序原來的變數，但是子程序對這些變數的操作不會影響相應父程序變數的值等（這裡只是指簡單的int，long變數，如果是socket，file等共享資源那麼還可能會影響）。子程序已經無法通過普通方式知道父程序的執行狀態（正在執行還是執行結束，程序是否存活）。 子程序要知道父程序的狀態只能通過程序通訊方法解決，常用的程序間通訊：匿名管道，有名管道，訊號量，訊息佇列，訊號，共享記憶體，套接字。 本文將介紹使用套接字實現父程序結束自動結束子程序的方式，主要運用兩個特性。 1）socketpair會產生一個雙向的控制代碼，兩個控制代碼相當於通訊兩端，程式能夠通過一端寫入，然後再另一端控制代碼讀取內容。 2）程序執行退出時系統會自動回收資源，關閉該程序所佔有的檔案控制代碼，套接字控制代碼也是一種控制代碼。 程式碼實現

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <errno.h>
#include <pthread.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>

void * thr_child(void *arg) {
    int sock = *((int*)arg);
    char buf[2] = {0};
    ssize_t len = 0;
    while (-1 == (len = read(sock, buf, sizeof(buf))) && EINTR == errno);
    printf("thr_child. pid: %ld, ppid:%ld\n", getpid(), getppid());
    exit(-1 == len ? -1 : 0);
}

int main(int argc, char *argv[]) {
    printf("start program: %s, pid: %ld, ppid: %ld\n", argv[0], getpid(), getppid());
    int fd[2] = {0};
    if (-1 == socketpair(PF_LOCAL, SOCK_STREAM, 0, fd)) {
        perror("socketpair failed\n");
        exit(-1);
    }

    pid_t pid = fork();
    if (-1 == pid) {
        perror("fork failed\n");
        exit(-1);
    }
    if (0 == pid) { // child
        printf("child process, pid: %ld, ppid: %ld\n", getpid(), getppid());
        close(fd[0]);
        int sock = fd[1];

        pthread_t pid;
        if (pthread_create(&pid, NULL, thr_child, (void *)&sock)) {
            perror("child. create thread failed\n");
            exit(-1);
        }

        for (int i = 0; i < 20; i++) {
            sleep(1);
            printf("child sleep: %ds\n", i + 1);
        }
    } else { // parent
        printf("parent process, pid: %ld, ppid: %ld\n", getpid(), getppid());
        close(fd[1]);
        int sock = fd[0];
        for (int i = 0; i < 5; i++) {
            sleep(1);
            printf("parent sleep: %ds\n", i + 1);
        }
    }

    printf("process %s finish\n", pid > 0 ? "parent" : "child");
    return 0;
}

編譯及執行 $ g++ -pthread notify_parent_quit.cpp $ ./a.out start program: ./a.out, pid: 31141, ppid: 8564 parent process, pid: 31141, ppid: 8564 child process, pid: 31142, ppid: 31141 parent sleep: 1s child sleep: 1s parent sleep: 2s child sleep: 2s parent sleep: 3s child sleep: 3s parent sleep: 4s child sleep: 4s parent sleep: 5s process parent finish child sleep: 5s thr_child. pid: 31142, ppid:1 可以看到，如果使用wait函式，那麼父程序會等待子程序sleep 20秒再自行結束。但是因為父程序結束時會關閉套接字控制代碼sock導致子程序read返回0表示達到檔案結尾，因為父程序沒有主動close套接字控制代碼sock，所以只有父程序退出時由作業系統關閉該控制代碼。上面的notify程式就是運用這點，在父程序結束時通知子程序的。通過執行緒函式thr_child可以知道，線上程退出前列印ppid時，子程序的父程序ppid == 1,即由於父程序結束導致子程序成為孤兒程序。 總結、socketpair只是其中一種簡單的實現方式。這裡只是使用簡單的例子說明，在實際應用中處理的情況會比較複雜。