进程控制

#include <unistd.h>
pid_t getpid(void);    //return value:  调用进程的进程ID
pid_t getppid(void);   //return value:  调用进程的父进程ID

//返回值：子进程中返回0，父进程中返回子进程ID，出错返回-1
pid_t fork(void);

子进程和父进程继续执行fork调用之后的指令。子进程是父进程的副本。

　　例如，子进程获得父进程数据空间、堆和栈的副本。

　　注意，这是子进程所拥有的副本。父、子进程并不共享这些存储空间部分。父、子进程共享正文段。

• 正文段，这是由CPU执行的机器指令部分。
• 数据段（初始化数据段），包含程序中需明确赋初的变量。例如C程序中出现在任何函数之外的声明（全局变量？）
• int maxcount = 99；
• 栈，自动变量（局部变量？）以及每次函数调用时所需保存的信息。
• 堆，动态存储分配。

程序演示了 fork 函数，从中可以看到子进程对变量所做的改变并不影响父进程中该变量的值。

#include "apue.h"

int        globvar = 6;        /* external variable in initialized data */
char    buf[] = "a write to stdout\n";

int
main(void)
{
    int        var;        /* automatic variable on the stack */
    pid_t    pid;

    var = 88;
    if (write(STDOUT_FILENO, buf, sizeof(buf)-1) != sizeof(buf)-1)
        err_sys("write error");
    printf("before fork\n");    /* we don't flush stdout */

    if ((pid = fork()) < 0) {
        err_sys("fork error");
    } else if (pid == 0) {        /* child */
        globvar++;                /* modify variables */
        var++;
    } else {
        sleep(2);                /* parent */
    }

    printf("pid = %ld, glob = %d, var = %d\n", (long)getpid(), globvar,
      var);
    exit(0);
}

一般来说，fork之后父、子进程的执行顺序是不确定的，这取决于内核所使用的调度算法。

待文件IO章节学习完毕后回看184-186页

fork有以下两种用法。

（1）一个父进程希望复制自己，使父进程和子进程同时执行不同的代码段。这在网络服务中是常见的——父进程等待客户端的服务请求。当这种请求到达时，父进程调用fork，使子进程处理此请求。父进程则继续等待下一个服务请求。

（2）一个进程要执行一个不同的程序。这对shell是常见的情况。在这种情况下，子进程从fork返回后立即调用exec。

 

当一个进程正常或异常终止时，内核就向其父进程发送SIGCHLD信号。因为子进程终止是个异步事件（这可以发生在父进程运行的任何时候发生），所以这种信号也是内核向父进程发的异步通知。父进程可以选择忽略该信号，或者提供一个该信号发生时即被调用执行的函数（信号处理函数）。对于这种信号的系统默认动作是忽略它。

调用 wait 和 waitpid 函数的进程可能会发生什么？

• 如果其所有子进程都还在运行，则阻塞。
• 如果一个子进程已终止，正等待父进程获取其终止状态，则取得该子进程的终止状态立即返回。
• 如果它没有任何子进程，则立即出错返回。

如果进程由于接收到SIGCHLD信号而调用wait ， 我们期望wait 会立即返回。但是如果在随机时间点调用wait，则进程可能会阻塞。

如果一个进程 fork 一个子进程，但不要它等待子进程终止，也不希望子进程处于僵死进程直到父进程终止，实现这一要求的诀窍是调用 fork 两次。

 https://blog.csdn.net/keyeagle/article/details/6679934

首先，要了解什么叫僵尸进程，什么叫孤儿进程，以及服务器进程运行所需要的一些条件。两次fork()就是为了解决这些相关的问题而出现的一种编程方法。

• 孤儿进程

       孤儿进程是指父进程在子进程结束之前死亡(return 或exit)。如下图1所示：

　　　　

　　　　　　　　　　　　　　　　图1  孤儿进程

 

　　但是孤儿进程并不会像上面画的那样持续很长时间，当系统发现孤儿进程时，init进程就收养孤儿进程，成为它的父亲，child进程exit后的资源回收就都由init进程来完成。

• 僵尸进程

       僵尸进程是指子进程在父进程之前结束了，但是父进程没有用wait或waitpid回收子进程。如下图所示：

     

　　　　

　　　　　　　　　　　　　　　　图2   僵尸进程

         父进程没有用wait回收子进程并不说明它不会回收子进程。子进程在结束的时候会给其父进程发送一个SIGCHILD信号，父进程默认是忽略SIGCHILD信号的，如果父进程通过signal()函数设置了SIGCHILD的信号处理函数，则在信号处理函数中可以回收子进程的资源。

      事实上，即便是父进程没有设置SIGCHILD的信号处理函数，也没有关系，因为在父进程结束之前，子进程可以一直保持僵尸状态，当父进程结束后，init进程就会负责回收僵尸子进程。

      但是，如果父进程是一个服务器进程，一直循环着不退出，那子进程就会一直保持着僵尸状态。虽然僵尸进程不会占用任何内存资源，但是过多的僵尸进程总还是会影响系统性能的。黔驴技穷的情况下，该怎么办呢？

         这个时候就需要一个英雄来拯救整个世界，它就是两次fork()技法。

• 两次fork()技法

         两次fork()的流程如下所示：

　　　　

　　　　　　　　　　　　　　　　图3    两次fork的控制流

       如上图3所示，为了避免子进程child成为僵尸进程，我们可以人为地创建一个子进程child1，再让child1成为工作子进程child2的父进程，child2出生后child1退出，这个时候child2相当于是child1产生的孤儿进程，这个孤儿进程由系统进程init回收。这样，当child2退出的时候，init就会回收child2的资源。

int main(void)
{
    pid_t        pid;
 
    if ( (pid = fork()) < 0)
          err_sys("fork error");
    else if (pid == 0) 
        {                /* first child */
           if ( (pid = fork()) < 0)
                        err_sys("fork error");
           else if (pid > 0)
                 exit(0);        /* parent from second fork == first child */
 
                /* We're the second child; our parent becomes init as soon
                   as our real parent calls exit() in the statement above.
                   Here's where we'd continue executing, knowing that when
                   we're done, init will reap our status. */
 
            sleep(2);
            printf("second child, parent pid = %d\n", getppid());
            exit(0);
        }
 
    if (waitpid(pid, NULL, 0) != pid)        /* wait for first child */
            err_sys("waitpid error");
 
        /* We're the parent (the original process); we continue executing,
           knowing that we're not the parent of the second child. */
 
    exit(0);
}

 

理所当然，第二个子进程的父进程是进程号为1的init进程。

 

总之，两次fork()是人为地创建一个工作子进程的父进程，然后让这个人为父进程退出，之后工作子进程就由init回收，避免了工作子进程成为僵尸进程。

 

如果要求父、子进程之间相互同步，则要求某种形式的进程间通信。

下方程序中，当第二个子进程打印其父进程ID时，我们看到了一个潜在的竞争条件。如果第二个子进程在第一个子进程之前运行，则其父进程会是第一个子进程。

但是，如果第一个子进程先运行，并有足够的时间到达并执行exit，则第二个子进程的父进程就是init。即使在程序中调用sleep，也不能保证什么。如果系统负载很重，那么在sleep返回之后、第一个子进程得到机会之前，第二个子进程可能恢复运行。这种形式的问题很难调试，因为在大部分时间，这种问题并不会出现。

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

int
main(void)
{
    pid_t    pid;

    if ((pid = fork()) < 0) {
        err_sys("fork error");
    } else if (pid == 0) {        /* first child */
        if ((pid = fork()) < 0)
            err_sys("fork error");
        else if (pid > 0)
            exit(0);    /* parent from second fork == first child */

        /*
         * We're the second child; our parent becomes init as soon
         * as our real parent calls exit() in the statement above.
         * Here's where we'd continue executing, knowing that when
         * we're done, init will reap our status.
         */
        sleep(2);
        printf("second child, parent pid = %ld\n", (long)getppid());
        exit(0);
    }

    if (waitpid(pid, NULL, 0) != pid)    /* wait for first child */
        err_sys("waitpid error");

    /*
     * We're the parent (the original process); we continue executing,
     * knowing that we're not the parent of the second child.
     */
    exit(0);
}

如果一个进程希望等待一个子进程终止，则它必须调用wait函数中的一个。

如果一个进程要等待其父进程终止（例如上述程序），则可使用下列形式的循环：

whie（getppid（）！=1）
    sleep（1）；

这种形式的循环称为轮训（polling），它的问题是浪费了CPU时间，因为调用者每隔1s都被唤醒，然后进行条件测试。

为了避免竞争条件和轮训，在多个进程之间需要有某种形式的信号发送和接收方法，在unix中可以使用信号机制。各种形式的进程间通信（IPC）也可使用。