Linux/Unix系统编程手册-笔记21. 进程的创建、终止

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

#include <unistd.h>
pid_t fork(void);
/* In parent: returns process ID of child on success, or –1 on error;
in successfully created child: always returns 0*/

// 常用的使用模板如下：

pid_t childPid; /* Used in parent after successful fork() 
to record PID of child */
switch (childPid = fork()) {
case -1: /* fork() failed */
 /* Handle error */
case 0: /* Child of successful fork() comes here */
 /* Perform actions specific to child */
default: /* Parent comes here after successful fork() */
 /* Perform actions specific to parent */
}

1
2
3
4
5
6
7
8

#include <unistd.h>
void _exit(int status);


#include <stdlib.h>
void exit(int status);

// status只有低8位有用

1
2
3
4
5
6
7

#include <stdlib.h>
int atexit(void (*func)(void));


#define _BSD_SOURCE /* Or: #define _SVID_SOURCE */
#include <stdlib.h>
int on_exit(void (*func)(int, void *), void *arg);

1
2
3

#include <sys/wait.h>
pid_t wait(int *status);
// Returns process ID of terminated child, or –1 on error

1
2
3
4
5
6

while ((childPid = wait(NULL)) != -1)
    continue;

// 当没有子进程需要等待的时候，errno=ECHILD
if (errno != ECHILD) /* An unexpected error... */
    errExit("wait");

1
2
3

#include <sys/wait.h>
pid_t waitpid(pid_t pid, int *status, int options);
// Returns process ID of child, 0 (see text), or –1 on error

1
2
3
4

#include <sys/wait.h>
int waitid(idtype_t idtype, id_t id, siginfo_t *infop, int options);
/* Returns 0 on success or if WNOHANG was specified and
there were no children to wait for, or –1 on error */

1
2

while (waitpid(-1, NULL, WNOHANG) > 0)
    continue;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

#include <signal.h>
#include <libgen.h>             /* For basename() declaration */
#include "tlpi_hdr.h"

#define CMD_SIZE 200
#define SYNC_SIG SIGUSR1                /* Synchronization signal */

static void             /* Signal handler - does nothing but return */
handler(int sig)
{
}

int
main(int argc, char *argv[])
{
    char cmd[CMD_SIZE];
    pid_t childPid;
    sigset_t blockMask, origMask, emptyMask;
    struct sigaction sa;

    setbuf(stdout, NULL);       /* Disable buffering of stdout */

    sigemptyset(&blockMask);
    sigaddset(&blockMask, SYNC_SIG);    /* Block signal */
    if (sigprocmask(SIG_BLOCK, &blockMask, &origMask) == -1)
        errExit("sigprocmask");

    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART;
    sa.sa_handler = handler;
    if (sigaction(SYNC_SIG, &sa, NULL) == -1)
        errExit("sigaction");

    printf("Parent PID=%ld\n", (long) getpid());

    switch (childPid = fork()) {
    case -1:
        errExit("fork");

    case 0:     /* Child: immediately exits to become zombie */
        printf("Child (PID=%ld) exiting!!\n", (long) getpid());

        sleep(3);
        if (kill(getppid(), SYNC_SIG) == -1)
            errExit("kill");

        _exit(EXIT_SUCCESS);

    default:    /* Parent */

        sigemptyset(&emptyMask);
        if (sigsuspend(&emptyMask) == -1 && errno != EINTR)
            errExit("sigsuspend");

        printf("got signal\n");

        if (sigprocmask(SIG_SETMASK, &origMask, NULL) == -1)
            errExit("sigprocmask");

        snprintf(cmd, CMD_SIZE, "ps | grep %s", basename(argv[0]));
        system(cmd);            /* View zombie child */

        /* Now send the "sure kill" signal to the zombie */

        if (kill(childPid, SIGKILL) == -1)
            errMsg("kill");
        sleep(3);               /* Give child a chance to react to signal */
        printf("After sending SIGKILL to zombie (PID=%ld):\n", (long) childPid);
        system(cmd);            /* View zombie child again */

        exit(EXIT_SUCCESS);
    }
}