Linux系统进程编程之回收子进程（三）

   #include <sys/types.h>
   #include <sys/wait.h>

   pid_t wait(int *wstatus);

 wait(): on success, returns the process ID of the terminated child; on error, -1 is returned.

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>  
#include <sys/wait.h>
#include <stdlib.h>
 int main(void)
{
pid_t pid = -1;
pid_t ret = -1;
int  wstatus = -1;

pid = fork();
if (pid > 0)
{
    // 父进程
    //sleep(1);
    printf("parent.\n");
    ret = wait(&wstatus);

    printf("子进程已经被回收，子进程pid = %d.\n", ret);
    printf("子进程是否正常退出：%d\n", WIFEXITED(wstatus));
    printf("子进程是否非正常退出：%d\n", WIFSIGNALED(wstatus));
    printf("正常终止的终止值是：%d.\n", WEXITSTATUS(wstatus));
}
else if (pid == 0)
{
    // 子进程
    printf("child pid = %d.\n", getpid());
    return 51;
    //exit(0);
}
else
{
    perror("fork");
    return -1;
}

return 0;
}

   WIFEXITED(wstatus)
          returns true if the child terminated normally, that is, by call‐
          ing exit(3) or _exit(2), or by returning from main().

   WEXITSTATUS(wstatus)
          returns the exit status of the  child.   This  consists  of  the
          least  significant  8 bits of the status argument that the child
          specified in a call to exit(3) or _exit(2) or  as  the  argument
          for a return statement in main().  This macro should be employed
          only if WIFEXITED returned true.

   WIFSIGNALED(wstatus)
          returns true if the child process was terminated by a signal.

SYNOPSIS
   #include <signal.h>

   typedef void (*sighandler_t)(int);

   sighandler_t signal(int signum, sighandler_t handler);

DESCRIPTION
   The  behavior  of signal() varies across UNIX versions, and has also varied historically across different versions of Linux.  Avoid its use: use sigaction(2) instead.  See
   Portability below.

   signal() sets the disposition of the signal signum to handler, which is either SIG_IGN, SIG_DFL, or the address of a programmer-defined function (a "signal handler").

   If the signal signum is delivered to the process, then one of the following happens:

   *  If the disposition is set to SIG_IGN, then the signal is ignored.

   *  If the disposition is set to SIG_DFL, then the default action associated with the signal (see signal(7)) occurs.

   *  If the disposition is set to a function, then first either the disposition is reset to SIG_DFL, or the signal is blocked (see Portability below), and  then  handler  is
      called with argument signum.  If invocation of the handler caused the signal to be blocked, then the signal is unblocked upon return from the handler.

   The signals SIGKILL and SIGSTOP cannot be caught or ignored.

RETURN VALUE
   signal() returns the previous value of the signal handler, or SIG_ERR on error.  In the event of an error, errno is set to indicate the cause.

 #include <stdio.h>
 #include <unistd.h>
 #include <errno.h>
 #include <stdlib.h>
 #include <signal.h>
 6    #include <sys/types.h>  
            #include <sys/wait.h> 7 static void sig_child(int signo);
 8
 9 int main()
10{
11 pid_t pid;
12 //创建捕捉子进程退出信号
13 signal(SIGCHLD,sig_child);
14pid = fork();
15if (pid < 0)
16{
17    perror("fork error:");
18    exit(1);
19}
20else if (pid == 0)     {
21     printf("I am child process,pid id %d.I am exiting.\n",getpid());
22     exit(0);
23 }
24 printf("I am father process.I will sleep two seconds\n");
25//等待子进程先退出
26 sleep(2);
27 //输出进程信息
28 system("ps -o pid,ppid,state,tty,command");
29printf("father process is exiting.\n");
30 return 0;
31 }
32
33 static void sig_child(int signo)
34{
35 pid_t        pid;
36 int        stat;
37  //处理僵尸进程
38  while ((pid = wait(&stat) >0)
39         printf("child %d terminated.\n", pid);
40}

#include <sys/types.h>
#include <sys/wait.h>
pid_t waitpid(pid_t pid, int *status, int options);

The waitpid() system call suspends execution of the calling process until a child specified by pid argument has changed state.  By default, waitpid() waits only for termi‐
   nated children, but this behavior is modifiable via the options argument, as described below.

   The value of pid can be:

   < -1   meaning wait for any child process whose process group ID is equal to the absolute value of pid.

   -1     meaning wait for any child process.

   0      meaning wait for any child process whose process group ID is equal to that of the calling process.

   > 0    meaning wait for the child whose process ID is equal to the value of pid.

   The value of options is an OR of zero or more of the following constants:

   WNOHANG     return immediately if no child has exited.

   WUNTRACED   also return if a child has stopped (but not traced via ptrace(2)).  Status for traced children which have stopped is provided even if this option is not speci‐
               fied.

   WCONTINUED (since Linux 2.6.10)
               also return if a stopped child has been resumed by delivery of SIGCONT.

   #include <stdio.h>
   #include <unistd.h>
   #include <sys/types.h>  
   #include <sys/wait.h>
   #include <stdlib.h>
   int main(void)
  {
pid_t pid = -1;
pid_t ret = -1;
int status = -1;

pid = fork();
if (pid > 0)
{
    // 父进程
    sleep(1);
    printf("parent, 子进程id = %d.\n", pid);
    //ret = wait(&status);



    //ret = waitpid(-1, &status, 0);    
    /* -1表示不等待某个特定PID的子进程而是回收任意一个子进程，0表示用默认的方式（阻塞式）来进行等待，返回值ret是本次回收的子进程的PID */


    /*  等待回收PID为pid的这个子进程，如果当前进程并没有一个ID号为pid的子进程，则返回值为-1；如果成功回收了pid这个子进程则返回值为回收的进程的PID  */

    //ret = waitpid(pid, &status, 0);


    /* 非阻塞式    这种表示父进程要【非阻塞式】的回收子进程。
    此时如果父进程执行waitpid时子进程已经先结束等待回收则waitpid直接回收成功，返回值是回收的子进程的PID；
    如果父进程waitpid时子进程尚未结束则父进程立刻返回（非阻塞），但是返回值为0（表示回收不成功）。
    */
    ret = waitpid(pid, &status, WNOHANG);       

    printf("子进程已经被回收，子进程pid = %d.\n", ret);
    printf("子进程是否正常退出：%d\n", WIFEXITED(status));
    printf("子进程是否非正常退出：%d\n", WIFSIGNALED(status));
    printf("正常终止的终止值是：%d.\n", WEXITSTATUS(status));
}
else if (pid == 0)
{
    // 子进程
    //sleep(1);
    printf("child pid = %d.\n", getpid());
    return 51;
    //exit(0);
}
else
{
    perror("fork");
    return -1;
}

return 0;
 }