Linux 进程

进程与程序

main()函数由谁调用？

C 语言程序总是从main 函数开始执行，main()函数的原型是：

int main(void)

或

int main(int argc, char *argv[])

如果需要向应用程序传参，则选择第二种写法。不知大家是否想过“谁”调用了main()函数？事实上，操作系统下的应用程序在运行main()函数之前需要先执行一段引导代码，最终由这段引导代码去调用应用程序的main()函数，我们在编写应用程序的时候，不用考虑引导代码的问题，在编译链接时，由链接器将引导代码链接到我们的应用程序当中，一起构成最终的可执行文件。
当执行应用程序时，在Linux 下输入可执行文件的相对路径或绝对路径就可以运行该程序，譬如./app
或/home/dt/app，还可根据应用程序是否接受传参在执行命令时在后面添加传入的参数信息，譬如./app arg1 arg2 或/home/dt/app arg1 arg2。程序运行需要通过操作系统的加载器来实现，加载器是操作系统中的程序，当执行程序时，加载器负责将此应用程序加载内存中去执行。
所以由此可知，对于操作系统下的应用程序来说，链接器和加载器都是很重要的角色！
再来看看argc 和argv 传参是如何实现的呢？譬如./app arg1 arg2，这两个参数arg1 和arg2 是如何传递给应用程序的main 函数的呢？当在终端执行程序时，命令行参数（command-line argument）由shell 进程逐一进行解析，shell 进程会将这些参数传递给加载器，加载器加载应用程序时会将其传递给应用程序引导代码，当引导程序调用main()函数时，在由它最终传递给main()函数，如此一来，在我们的应用程序当中便可以获取到命令行参数了。

程序如何结束？

程序结束其实就是进程终止，进程终止的方式通常有多种，大体上分为正常终止和异常终止，正常终止包括：
⚫ main()函数中通过return 语句返回来终止进程；
⚫ 应用程序中调用exit()函数终止进程；
⚫ 应用程序中调用_exit()或_Exit()终止进程；
以上这些是在前面的课程中给大家介绍的，异常终止包括：
⚫ 应用程序中调用abort()函数终止进程；
⚫ 进程接收到一个信号，譬如SIGKILL 信号。
注册进程终止处理函数atexit()
atexit()库函数用于注册一个进程在正常终止时要调用的函数，其函数原型如下所示：

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

使用该函数需要包含头文件<stdlib.h>。
函数参数和返回值含义如下：
function：函数指针，指向注册的函数，此函数无需传入参数、无返回值。
返回值：成功返回0；失败返回非0。
测试

编写一个测试程序，使用atexit()函数注册一个进程在正常终止时需要调用的函数，测试代码如下。

#include <stdio.h>
#include <stdlib.h>
static void bye(void)
{
    puts("Goodbye!");
}
int main(int argc, char *argv[])
{
    if (atexit(bye))
    {
        fprintf(stderr, "cannot set exit function\n");
        exit(-1);
    }
    exit(0);
}

运行结果：

需要说明的是，如果程序当中使用了_exit()或_Exit()终止进程而并非是exit()函数，那么将不会执行注册的终止处理函数。

何为进程？

本小节正式向大家介绍进程这个概念，前面的内容中也已经多次提到了，其实这个概念本身非常简单，进程其实就是一个可执行程序的实例，这句话如何理解呢？可执行程序就是一个可执行文件，文件是一个静态的概念，存放磁盘中，如果可执行文件没有被运行，那它将不会产生什么作用，当它被运行之后，它将会对系统环境产生一定的影响，所以可执行程序的实例就是可执行文件被运行。
进程是一个动态过程，而非静态文件，它是程序的一次运行过程，当应用程序被加载到内存中运行之后它就称为了一个进程，当程序运行结束后也就意味着进程终止，这就是进程的一个生命周期。

进程号

Linux 系统下的每一个进程都有一个进程号（process ID，简称PID），进程号是一个正数，用于唯一标识系统中的某一个进程。在Ubuntu 系统下执行ps 命令可以查到系统中进程相关的一些信息，包括每个进程的进程号，如下所示：

上图中红框标识显示的便是每个进程所对应的进程号，进程号的作用就是用于唯一标识系统中某一个进程，在某些系统调用中，进程号可以作为传入参数、有时也可作为返回值。譬如系统调用kill()允许调用者向某一个进程发送一个信号，如何表示这个进程呢？则是通过进程号进行标识。
在应用程序中，可通过系统调用getpid()来获取本进程的进程号，其函数原型如下所示：

#include <sys/types.h>
#include <unistd.h>
pid_t getpid(void);

使用该函数需要包含头文件<sys/types.h>和<unistd.h>。
函数返回值为pid_t 类型变量，便是对应的进程号。
使用示例
使用getpid()函数获取进程的进程号。

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
int main(void)
{
    pid_t pid = getpid();
    printf("本进程的PID 为: %d\n", pid);
    exit(0);
}

运行结果：

除了getpid()用于获取本进程的进程号之外，还可以使用getppid()系统调用获取父进程的进程号，其函数原型如下所示：

#include <sys/types.h>
#include <unistd.h>
pid_t getppid(void);

返回值对应的便是父进程的进程号。
使用示例
获取进程的进程号和父进程的进程号。

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
int main(void)
{
    pid_t pid = getpid(); // 获取本进程pid
    printf("本进程的PID 为: %d\n", pid);
    pid = getppid(); // 获取父进程pid
    printf("父进程的PID 为: %d\n", pid);
    exit(0);
}

运行结果：

进程的环境变量

每一个进程都有一组与其相关的环境变量，这些环境变量以字符串形式存储在一个字符串数组列表中，把这个数组称为环境列表。其中每个字符串都是以“名称=值（name=value）”形式定义，所以环境变量是“名称-值”的成对集合，譬如在shell 终端下可以使用env 命令查看到shell 进程的所有环境变量，如下所示：

使用export 命令还可以添加一个新的环境变量或删除一个环境变量：

export LINUX_APP=123456 # 添加LINUX_APP 环境变量

使用"export -n LINUX_APP"命令则可以删除LINUX_APP 环境变量。

export -n LINUX_APP # 删除LINUX_APP 环境变量

应用程序中获取环境变量

在我们的应用程序当中也可以获取当前进程的环境变量，事实上，进程的环境变量是从其父进程中继承过来的，譬如在shell 终端下执行一个应用程序，那么该进程的环境变量就是从其父进程（shell 进程）中继承过来的。新的进程在创建之前，会继承其父进程的环境变量副本。
环境变量存放在一个字符串数组中，在应用程序中，通过environ 变量指向它，environ 是一个全局变量，在我们的应用程序中只需申明它即可使用，如下所示：

extern char **environ; // 申明外部全局变量environ

测试
编写应用程序，获取进程的所有环境变量。

#include <stdio.h>
#include <stdlib.h>
extern char **environ;
int main(int argc, char *argv[])
{
    int i;
    /* 打印进程的环境变量*/
    for (i = 0; NULL != environ[i]; i++)
        puts(environ[i]);
    exit(0);
}

通过字符串数组元素是否等于NULL 来判断是否已经到了数组的末尾。
运行结果：

获取指定环境变量getenv()
如果只想要获取某个指定的环境变量，可以使用库函数getenv()，其函数原型如下所示：

#include <stdlib.h>
char *getenv(const char *name);

使用该函数需要包含头文件<stdlib.h>。
函数参数和返回值含义如下：
name：指定获取的环境变量名称。
返回值：如果存放该环境变量，则返回该环境变量的值对应字符串的指针；如果不存在该环境变量，则返回NULL。
使用getenv()需要注意，不应该去修改其返回的字符串，修改该字符串意味着修改了环境变量对应的值，
Linux 提供了相应的修改函数，如果需要修改环境变量的值应该使用这些函数，不应直接改动该字符串。
使用示例

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
    const char *str_val = NULL;
    if (2 > argc)
    {
        fprintf(stderr, "Error: 请传入环境变量名称\n");
        exit(-1);
    }
    /* 获取环境变量*/
    str_val = getenv(argv[1]);
    if (NULL == str_val)
    {
        fprintf(stderr, "Error: 不存在[%s]环境变量\n", argv[1]);
        exit(-1);
    }
    /* 打印环境变量的值*/
    printf("环境变量的值: %s\n", str_val);
    exit(0);
}

运行结果：

添加/删除/修改环境变量

C 语言函数库中提供了用于修改、添加、删除环境变量的函数，譬如putenv()、setenv()、unsetenv()、
clearenv()函数等。
putenv()函数
putenv()函数可向进程的环境变量数组中添加一个新的环境变量，或者修改一个已经存在的环境变量对应的值，其函数原型如下所示：

#include <stdlib.h>
int putenv(char *string);

使用该函数需要包含头文件<stdlib.h>。
函数参数和返回值含义如下：
string：参数string 是一个字符串指针，指向name=value 形式的字符串。
返回值：成功返回0；失败将返回非0 值，并设置errno。
该函数调用成功之后，参数string 所指向的字符串就成为了进程环境变量的一部分了，换言之，putenv()
函数将设定environ 变量（字符串数组）中的某个元素（字符串指针）指向该string 字符串，而不是指向它的复制副本，这里需要注意！因此，不能随意修改参数string 所指向的内容，这将影响进程的环境变量，出于这种原因，参数string 不应为自动变量（即在栈中分配的字符数组）。
测试
使用putenv()函数为当前进程添加一个环境变量。

#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
    if (2 > argc)
    {
        fprintf(stderr, "Error: 传入name=value\n");
        exit(-1);
    }
    /* 添加/修改环境变量*/
    if (putenv(argv[1]))
    {
        perror("putenv error");
        exit(-1);
    }
    exit(0);
}

setenv()函数
setenv()函数可以替代putenv()函数，用于向进程的环境变量列表中添加一个新的环境变量或修改现有环境变量对应的值，其函数原型如下所示：

#include <stdlib.h>
int setenv(const char *name, const char *value, int overwrite);

使用该函数需要包含头文件<stdlib.h>。
函数参数和返回值含义如下：
name：需要添加或修改的环境变量名称。
value：环境变量的值。
overwrite：若参数name 标识的环境变量已经存在，在参数overwrite 为0 的情况下，setenv()函数将不改变现有环境变量的值，也就是说本次调用没有产生任何影响；如果参数overwrite 的值为非0，若参数name
标识的环境变量已经存在，则覆盖，不存在则表示添加新的环境变量。
返回值：成功返回0；失败将返回-1，并设置errno。
setenv()函数为形如name=value 的字符串分配一块内存缓冲区，并将参数name 和参数value 所指向的字符串复制到此缓冲区中，以此来创建一个新的环境变量，所以，由此可知，setenv()与putenv()函数有两个区别：

⚫ putenv()函数并不会为name=value 字符串分配内存；
⚫ setenv()可通过参数overwrite 控制是否需要修改现有变量的值而仅以添加变量为目的，显然putenv()
并不能进行控制。
推荐大家使用setenv()函数，这样使用自动变量作为setenv()的参数也不会有问题。
使用示例

#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
    if (3 > argc)
    {
        fprintf(stderr, "Error: 传入name value\n");
        exit(-1);
    }
    /* 添加环境变量*/
    if (setenv(argv[1], argv[2], 0))
    {
        perror("setenv error");
        exit(-1);
    }
    exit(0);
}

除了上面给大家介绍的函数之外，我们还可以通过一种更简单地方式向进程环境变量表中添加环境变量，用法如下：

NAME=value ./app

在执行程序的时候，在其路径前面添加环境变量，以name=value 的形式添加，如果是多个环境变量，则在./app 前面放置多对name=value 即可，以空格分隔。
unsetenv()函数
unsetenv()函数可以从环境变量表中移除参数name 标识的环境变量，其函数原型如下所示：

#include <stdlib.h>
int unsetenv(const char *name);

清空环境变量

有时，需要清除环境变量表中的所有变量，然后再进行重建，可以通过将全局变量environ 赋值为NULL
来清空所有变量。
environ = NULL;
也可通过clearenv()函数来操作，函数原型如下所示：

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

clearenv()函数内部的做法其实就是将environ 赋值为NULL。在某些情况下，使用setenv()函数和clearenv()
函数可能会导致程序内存泄漏，前面提到过，setenv()函数会为环境变量分配一块内存缓冲区，随之称为进程的一部分；而调用clearenv()函数时没有释放该缓冲区（clearenv()调用并不知晓该缓冲区的存在，故而也无法将其释放），反复调用者两个函数的程序，会不断产生内存泄漏。

环境变量的作用

环境变量常见的用途之一是在shell 中，每一个环境变量都有它所表示的含义，譬如HOME 环境变量表示用户的家目录，USER 环境变量表示当前用户名，SHELL 环境变量表示shell 解析器名称，PWD 环境变量表示当前所在目录等，在我们自己的应用程序当中，也可以使用进程的环境变量。

进程的内存布局

历史沿袭至今，C 语言程序一直都是由以下几部分组成的：
⚫ 正文段。也可称为代码段，这是CPU 执行的机器语言指令部分，文本段具有只读属性，以防止程序由于意外而修改其指令；正文段是可以共享的，即使在多个进程间也可同时运行同一段程序。
⚫ 初始化数据段。通常将此段称为数据段，包含了显式初始化的全局变量和静态变量，当程序加载到内存中时，从可执行文件中读取这些变量的值。
⚫ 未初始化数据段。包含了未进行显式初始化的全局变量和静态变量，通常将此段称为bss 段，这一名词来源于早期汇编程序中的一个操作符，意思是“由符号开始的块”（block started by symbol），在程序开始执行之前，系统会将本段内所有内存初始化为0，可执行文件并没有为bss 段变量分配存储空间，在可执行文件中只需记录bss 段的位置及其所需大小，直到程序运行时，由加载器来分配这一段内存空间。
⚫ 栈。函数内的局部变量以及每次函数调用时所需保存的信息都放在此段中，每次调用函数时，函数传递的实参以及函数返回值等也都存放在栈中。栈是一个动态增长和收缩的段，由栈帧组成，系统会为每个当前调用的函数分配一个栈帧，栈帧中存储了函数的局部变量（所谓自动变量）、实参和返回值。
⚫ 堆。可在运行时动态进行内存分配的一块区域，譬如使用malloc()分配的内存空间，就是从系统堆内存中申请分配的。
Linux 下的size 命令可以查看二进制可执行文件的文本段、数据段、bss 段的段大小：

图9.3.2 显示了这些段在内存中的典型布局方式，当然，并不要求具体的实现一定是以这种方式安排其存储空间，但这是一种便于我们说明的典型方式。

进程的虚拟地址空间

上一小节我们讨论了C 语言程序的构成以及运行时进程在内存中的布局方式，在Linux 系统中，采用了虚拟内存管理技术，事实上大多数现在操作系统都是如此！在Linux 系统中，每一个进程都在自己独立的地址空间中运行，在32 位系统中，每个进程的逻辑地址空间均为4GB，这4GB 的内存空间按照3:1 的比例进行分配，其中用户进程享有3G 的空间，而内核独自享有剩下的1G 空间，如下所示：

学习过驱动开发的读者对“虚拟地址”这个概念应该并不陌生，虚拟地址会通过硬件MMU（内存管理单元）映射到实际的物理地址空间中，建立虚拟地址到物理地址的映射关系后，对虚拟地址的读写操作实际上就是对物理地址的读写操作，MMU 会将物理地址“翻译”为对应的物理地址，其关系如下所示：

Linux 系统下，应用程序运行在一个虚拟地址空间中，所以程序中读写的内存地址对应也是虚拟地址，并不是真正的物理地址，譬如应用程序中读写0x80800000 这个地址，实际上并不对应于硬件的0x80800000
这个物理地址。
为什么需要引入虚拟地址呢？
计算机物理内存的大小是固定的，就是计算机的实际物理内存，试想一下，如果操作系统没有虚拟地址机制，所有的应用程序访问的内存地址就是实际的物理地址，所以要将所有应用程序加载到内存中，但是我们实际的物理内存只有4G，所以就会出现一些问题：
⚫ 当多个程序需要运行时，必须保证这些程序用到的内存总量要小于计算机实际的物理内存的大小。
⚫ 内存使用效率低。内存空间不足时，就需要将其它程序暂时拷贝到硬盘中，然后将新的程序装入内存。然而由于大量的数据装入装出，内存的使用效率就会非常低。
⚫ 进程地址空间不隔离。由于程序是直接访问物理内存的，所以每一个进程都可以修改其它进程的内存数据，甚至修改内核地址空间中的数据，所以有些恶意程序可以随意修改别的进程，就会造成一些破坏，系统不安全、不稳定。
⚫ 无法确定程序的链接地址。程序运行时，链接地址和运行地址必须一致，否则程序无法运行！因为程序代码加载到内存的地址是由系统随机分配的，是无法预知的，所以程序的运行地址在编译程序时是无法确认的。
针对以上的一些问题，就引入了虚拟地址机制，程序访问存储器所使用的逻辑地址就是虚拟地址，通过逻辑地址映射到真正的物理内存上。所有应用程序运行在自己的虚拟地址空间中，使得进程的虚拟地址空间和物理地址空间隔离开来，这样做带来了很多的优点：
⚫ 进程与进程、进程与内核相互隔离。一个进程不能读取或修改另一个进程或内核的内存数据，这是因为每一个进程的虚拟地址空间映射到了不同的物理地址空间。提高了系统的安全性与稳定性。
⚫ 在某些应用场合下，两个或者更多进程能够共享内存。因为每个进程都有自己的映射表，可以让不同进程的虚拟地址空间映射到相同的物理地址空间中。通常，共享内存可用于实现进程间通信。
⚫ 便于实现内存保护机制。譬如在多个进程共享内存时，允许每个进程对内存采取不同的保护措施，例如，一个进程可能以只读方式访问内存，而另一进程则能够以可读可写的方式访问。
⚫ 编译应用程序时，无需关心链接地址。前面提到了，当程序运行时，要求链接地址与运行地址一致，在引入了虚拟地址机制后，便无需关心这个问题。
关于本小节的内容就介绍这么多，理解本小节的内容可以帮助我们更好地理解后面小节中将要介绍的内容。

fork()创建子进程

一个现有的进程可以调用fork()函数创建一个新的进程，调用fork()函数的进程称为父进程，由fork()函数创建出来的进程被称为子进程（child process），fork()函数原型如下所示（fork()为系统调用）：

#include <unistd.h>
pid_t fork(void);

使用该函数需要包含头文件<unistd.h>。
在诸多的应用中，创建多个进程是任务分解时行之有效的方法，譬如，某一网络服务器进程可在监听客户端请求的同时，为处理每一个请求事件而创建一个新的子进程，与此同时，服务器进程会继续监听更多的客户端连接请求。在一个大型的应用程序任务中，创建子进程通常会简化应用程序的设计，同时提高了系统的并发性（即同时能够处理更多的任务或请求，多个进程在宏观上实现同时运行）。

理解fork()系统调用的关键在于，完成对其调用后将存在两个进程，一个是原进程（父进程）、另一个则是创建出来的子进程，并且每个进程都会从fork()函数的返回处继续执行，会导致调用fork()返回两次值，子进程返回一个值、父进程返回一个值。在程序代码中，可通过返回值来区分是子进程还是父进程。
fork()调用成功后，将会在父进程中返回子进程的PID，而在子进程中返回值是0；如果调用失败，父进程返回值-1，不创建子进程，并设置errno。
fork()调用成功后，子进程和父进程会继续执行fork()调用之后的指令，子进程、父进程各自在自己的进程空间中运行。事实上，子进程是父进程的一个副本，譬如子进程拷贝了父进程的数据段、堆、栈以及继承了父进程打开的文件描述符，父进程与子进程并不共享这些存储空间，这是子进程对父进程相应部分存储空间的完全复制，执行fork()之后，每个进程均可修改各自的栈数据以及堆段中的变量，而并不影响另一个进程。
虽然子进程是父进程的一个副本，但是对于程序代码段（文本段）来说，两个进程执行相同的代码段，因为代码段是只读的，也就是说父子进程共享代码段，在内存中只存在一份代码段数据。
使用示例1
使用fork()创建子进程。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(void)
{
    pid_t pid;
    pid = fork();
    switch (pid)
    {
    case -1:
        perror("fork error");
        exit(-1);
    case 0:
        printf("这是子进程打印信息<pid: %d, 父进程pid: %d>\n",
               getpid(), getppid());
        _exit(0); // 子进程使用_exit()退出
    default:
        printf("这是父进程打印信息<pid: %d, 子进程pid: %d>\n",
               getpid(), pid);
        exit(0);
    }
}

上述示例代码中，case 0 是子进程的分支，这里使用了_exit()结束进程而没有使用exit()。

Tips：C 库函数exit()建立在系统调用_exit()之上，这两个函数在3.3 小节中向大家介绍过，这里我们强调，在调用了fork()之后，父、子进程中一般只有一个会通过调用exit()退出进程，而另一个则应使用_exit()
退出，具体原因将会在后面章节内容中向大家做进一步说明！
直接测试运行查看打印结果：

从打印结果可知，fork()之后的语句被执行了两次，所以switch…case 语句被执行了两次，第一次进入到了"case 0"分支，通过上面的介绍可知，fork()返回值为0 表示当前处于子进程；在子进程中我们通过getpid()
获取到子进程自己的PID（46802），通过getppid()获取到父进程的PID（46803），将其打印出来。
第二次进入到了default 分支，表示当前处于父进程，此时fork()函数的返回值便是创建出来的子进程对应的PID。
fork()函数调用完成之后，父进程、子进程会各自继续执行fork()之后的指令，最终父进程会执行到exit()
结束进程，而子进程则会通过_exit()结束进程。
使用示例2

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(void)
{
    pid_t pid;
    pid = fork();
    switch (pid)
    {
    case -1:
        perror("fork error");
        exit(-1);
    case 0:
        printf("这是子进程打印信息\n");
        printf("%d\n", pid);
        _exit(0);
    default:
        printf("这是父进程打印信息\n");
        printf("%d\n", pid);
        exit(0);
    }
}

运行结果：

在exit()函数之前添加了打印信息，而从上图中可以知道，打印的pid 值并不相同，0 表示子进程打印出来的，46953 表示的是父进程打印出来的，所以从这里可以证实，fork()函数调用完成之后，父进程、子进程会各自继续执行fork()之后的指令，它们共享代码段，但并不共享数据段、堆、栈等，而是子进程拥有父进程数据段、堆、栈等副本，所以对于同一个局部变量，它们打印出来的值是不相同的，因为fork()调用返回值不同，在父、子进程中赋予了pid 不同的值。
关于子进程
子进程被创建出来之后，便是一个独立的进程，拥有自己独立的进程空间，系统内唯一的进程号，拥有自己独立的PCB（进程控制块），子进程会被内核同等调度执行，参与到系统的进程调度中。
子进程与父进程之间的这种关系被称为父子进程关系，父子进程关系相比于普通的进程间关系多多少少存在一些关联与“羁绊”，关于这些关联与“羁绊”我们将会在后面的课程中为大家介绍。
Tips：系统调度。Linux 系统是一个多任务、多进程、多线程的操作系统，一般来说系统启动之后会运行成百甚至上千个不同的进程，那么对于单核CPU 计算机来说，在某一个时间它只能运行某一个进程的代码指令，那其它进程怎么办呢（多核处理器也是如此，同一时间每个核它只能运行某一个进程的代码）？这里就出现了调度的问题，系统是这样做的，每一个进程（或线程）执行一段固定的时间，时间到了之后切换执行下一个进程或线程，依次轮流执行，这就称为调度，由操作系统负责这件事情，当然系统调度的实现本身是一件非常复杂的事情，需要考虑的因素很多，这里只是让大家有个简单地认识，系统调度的基本单元是线程，关于线程，后面章节内容将会向大家介绍。

父、子进程间的文件共享

调用fork()函数之后，子进程会获得父进程所有文件描述符的副本，这些副本的创建方式类似于dup()，这也意味着父、子进程对应的文件描述符均指向相同的文件表，如下图所示：

由此可知，子进程拷贝了父进程的文件描述符表，使得父、子进程中对应的文件描述符指向了相同的文件表，也意味着父、子进程中对应的文件描述符指向了磁盘中相同的文件，因而这些文件在父、子进程间实现了共享，譬如，如果子进程更新了文件偏移量，那么这个改变也会影响到父进程中相应文件描述符的位置偏移量。
接下来我们进行一个测试，父进程打开文件之后，然后fork()创建子进程，此时子进程继承了父进程打开的文件描述符（父进程文件描述符的副本），然后父、子进程同时对文件进行写入操作，测试代码如下所示：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main(void)
{
    pid_t pid;
    int fd;
    int i;
    fd = open("./test.txt", O_RDWR | O_TRUNC);
    if (0 > fd)
    {
        perror("open error");
        exit(-1);
    }
    pid = fork();
    switch (pid)
    {
    case -1:
        perror("fork error");
        close(fd);
        exit(-1);
    case 0:
        /* 子进程*/
        for (i = 0; i < 4; i++) // 循环写入4 次
            write(fd, "1122", 4);
        close(fd);
        _exit(0);
    default:
        /* 父进程*/
        for (i = 0; i < 4; i++) // 循环写入4 次
            write(fd, "AABB", 4);
        close(fd);
        exit(0);
    }
}

上述代码中，父进程open 打开文件之后，才调用fork()创建了子进程，所以子进程了继承了父进程打开的文件描述符fd，我们需要验证的便是两个进程对文件的写入操作是分别各自写入、还是每次都在文件末尾接续写入。
运行测试：

有上述测试结果可知，此种情况下，父、子进程分别对同一个文件进行写入操作，结果是接续写，不管是父进程，还是子进程，在每次写入时都是从文件的末尾写入，很像使用了O_APPEND 标志的效果。其原因也非常简单，图9.6.1 中便给出了答案，子进程继承了父进程的文件描述符，两个文件描述符都指向了一个相同的文件表，意味着它们的文件偏移量是同一个、绑定在了一起，相互影响，子进程改变了文件的位置偏移量就会作用到父进程，同理，父进程改变了文件的位置偏移量就会作用到子进程。
再来测试另外一种情况，父进程在调用fork()之后，此时父进程和子进程都去打开同一个文件，然后再对文件进行写入操作，测试代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main(void)
{
    pid_t pid;
    int fd;
    int i;
    pid = fork();
    switch (pid)
    {
    case -1:
        perror("fork error");
        exit(-1);
    case 0:
        /* 子进程*/
        fd = open("./test.txt", O_WRONLY);
        if (0 > fd)
        {
            perror("open error");
            _exit(-1);
        }
        for (i = 0; i < 4; i++) // 循环写入4 次
            write(fd, "1122", 4);
        close(fd);
        _exit(0);
    default:
        /* 父进程*/
        fd = open("./test.txt", O_WRONLY);
        if (0 > fd)
        {
            perror("open error");
            exit(-1);
        }
        for (i = 0; i < 4; i++) // 循环写入4 次
            write(fd, "AABB", 4);
        close(fd);
        exit(0);
    }
}

在上述示例中，父进程调用fork()之后，然后在父、子进程中都去打开test.txt 文件，然后在对其进行写入操作，子进程调用了4 次write、每次写入“1122”；而父进程调用了4 次write、每次写入“AABB”，测试结果如下：

从测试结果可知，这种文件共享方式实现的是一种两个进程分别各自对文件进行写入操作，因为父、子进程的这两个文件描述符分别指向的是不同的文件表，意味着它们有各自的文件偏移量，一个进程修改了文件偏移量并不会影响另一个进程的文件偏移量，所以写入的数据会出现覆盖的情况。
fork()函数使用场景
fork()函数有以下两种用法：
⚫ 父进程希望子进程复制自己，使父进程和子进程同时执行不同的代码段。这在网络服务进程中是常见的，父进程等待客户端的服务请求，当接收到客户端发送的请求事件后，调用fork()创建一个子进程，使子进程去处理此请求、而父进程可以继续等待下一个服务请求。
⚫ 一个进程要执行不同的程序。譬如在程序app1 中调用fork()函数创建了子进程，此时子进程是要去执行另一个程序app2，也就是子进程需要执行的代码是app2 程序对应的代码，子进程将从app2
程序的main 函数开始运行。这种情况，通常在子进程从fork()函数返回之后立即调用exec 族函数来实现，关于exec 函数将在后面内容向大家介绍。

系统调用vfork()

除了fork()系统调用之外，Linux 系统还提供了vfork()系统调用用于创建子进程，vfork()与fork()函数在功能上是相同的，并且返回值也相同，在一些细节上存在区别，vfork()函数原型如下所示：
#include <sys/types.h>
#include <unistd.h>
pid_t vfork(void);
使用该函数需要包含头文件<sys/types.h>和<unistd.h>。

从前面的介绍可知，可以将fork()认作对父进程的数据段、堆段、栈段以及其它一些数据结构创建拷贝，由此可以看出，使用fork()系统调用的代价是很大的，它复制了父进程中的数据段和堆栈段中的绝大部分内容，这将会消耗比较多的时间，效率会有所降低，而且太浪费，原因有很多，其中之一在于，fork()函数之后子进程通常会调用exec 函数，也就是fork()第二种使用场景下，这使得子进程不再执行父程序中的代码段，而是执行新程序的代码段，从新程序的main 函数开始执行、并为新程序重新初始化其数据段、堆段、栈段等；那么在这种情况下，子进程并不需要用到父进程的数据段、堆段、栈段（譬如父程序中定义的局部变量、全局变量等）中的数据，此时就会导致浪费时间、效率降低。
事实上，现代Linux 系统采用了一些技术来避免这种浪费，其中很重要的一点就是内核采用了写时复制（copy-on-write）技术，关于这种技术的实现细节就不给大家介绍了，有兴趣读者可以自己搜索相应的文档了解。
出于这一原因，引入了vfork()系统调用，虽然在一些细节上有所不同，但其效率要高于fork()函数。类似于fork()，vfork()可以为调用该函数的进程创建一个新的子进程，然而，vfork()是为子进程立即执行exec()
新的程序而专门设计的，也就是fork()函数的第二个使用场景。
vfork()与fork()函数主要有以下两个区别：
⚫ vfork()与fork()一样都创建了子进程，但vfork()函数并不会将父进程的地址空间完全复制到子进程中，因为子进程会立即调用exec（或_exit），于是也就不会引用该地址空间的数据。不过在子进程调用exec 或_exit 之前，它在父进程的空间中运行、子进程共享父进程的内存。这种优化工作方式的实现提高的效率；但如果子进程修改了父进程的数据（除了vfork 返回值的变量）、进行了函数调用、或者没有调用exec 或_exit 就返回将可能带来未知的结果。
⚫ 另一个区别在于，vfork()保证子进程先运行，子进程调用exec 之后父进程才可能被调度运行。
虽然vfork()系统调用在效率上要优于fork()，但是vfork()可能会导致一些难以察觉的程序bug，所以尽量避免使用vfork()来创建子进程，虽然fork()在效率上并没有vfork()高，但是现代的Linux 系统内核已经采用了写时复制技术来实现fork()，其效率较之于早期的fork()实现要高出许多，除非速度绝对重要的场合，我们的程序当中应舍弃vfork()而使用fork()。
使用示例

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
int main(void)
{
    pid_t pid;
    int num = 100;
    pid = vfork();
    switch (pid)
    {
    case -1:
        perror("vfork error");
        exit(-1);
    case 0:
        /* 子进程*/
        printf("子进程打印信息\n");
        printf("子进程打印num: %d\n", num);
        _exit(0);
    default:
        /* 父进程*/
        printf("父进程打印信息\n");
        printf("父进程打印num: %d\n", num);
        exit(0);
    }
}

测试结果：

在正式的使用场合下，一般应在子进程中立即调用exec，如果exec 调用失败，子进程则应调用_exit()
退出（vfork 产生的子进程不应调用exit 退出，因为这会导致对父进程stdio 缓冲区的刷新和关闭）。上述示例代码只是一个简单地演示，并不是vfork()的真正用法，后面学习到exec 的时候还会再给大家进行介绍。

fork()之后的竞争条件

调用fork()之后，子进程成为了一个独立的进程，可被系统调度运行，而父进程也继续被系统调度运行，这里出现了一个问题，调用fork 之后，无法确定父、子两个进程谁将率先访问CPU，也就是说无法确认谁先被系统调用运行（在多核处理器中，它们可能会同时各自访问一个CPU），这将导致谁先运行、谁后运行这个顺序是不确定的，譬如有如下示例代码：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(void)
{
    switch (fork())
    {
    case -1:
        perror("fork error");
        exit(-1);
    case 0:
        /* 子进程*/
        printf("子进程打印信息\n");
        _exit(0);
    default:
        /* 父进程*/
        printf("父进程打印信息\n");
        exit(0);
    }
}

示例代码中我们是无法确认"子进程打印信息"和"父进程打印信息"谁先会被打印出来，有时子进程先被执行，打印出"子进程打印信息"，而有时父进程会先被执行，打印出"子进程打印信息"，测试结果如下所示：

从测试结果可知，虽然绝大部分情况下，父进程会先于子进程被执行，但是并不排除子进程先于父进程被执行的可能性。而对于有些特定的应用程序，它对于执行的顺序有一定要求的，譬如它必须要求父进程先运行，或者必须要求子进程先运行，程序产生正确的结果它依赖于特定的执行顺序，那么将可能因竞争条件而导致失败、无法得到正确的结果。
那如何明确保证某一特性执行顺序呢？这个时候可以通过采用采用某种同步技术来实现，譬如前面给大家介绍的信号，如果要让子进程先运行，则可使父进程被阻塞，等到子进程来唤醒它，示例代码如下所示：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
static void sig_handler(int sig)
{

    printf("接收到信号\n");
}
int main(void)
{
    struct sigaction sig = {0};
    sigset_t wait_mask;
    /* 初始化信号集*/
    sigemptyset(&wait_mask);
    /* 设置信号处理方式*/
    sig.sa_handler = sig_handler;
    sig.sa_flags = 0;
    if (-1 == sigaction(SIGUSR1, &sig, NULL))
    {
        perror("sigaction error");
        exit(-1);
    }
    switch (fork())
    {
    case -1:
        perror("fork error");
        exit(-1);
    case 0:
        /* 子进程*/
        printf("子进程开始执行\n");
        printf("子进程打印信息\n");
        printf("~~~~~~~~~~~~~~~\n");
        sleep(2);
        kill(getppid(), SIGUSR1); // 发送信号给父进程、唤醒它
        _exit(0);
    default:
        /* 父进程*/
        if (-1 != sigsuspend(&wait_mask)) // 挂起、阻塞
            exit(-1);
        printf("父进程开始执行\n");
        printf("父进程打印信息\n");
        exit(0);
    }
}

示例代码比较简单，这里我们希望子进程先运行打印相应信息，之后再执行父进程打印信息，在父进程分支中，直接调用了sigsuspend()使父进程进入挂起状态，由子进程通过kill 命令发送信号唤醒，测试结果如下：

进程的诞生与终止

进程的诞生

一个进程可以通过fork()或vfork()等系统调用创建一个子进程，一个新的进程就此诞生！事实上，Linux
系统下的所有进程都是由其父进程创建而来，譬如在shell 终端通过命令的方式执行一个程序./app，那么app
进程就是由shell 终端进程创建出来的，shell 终端就是该进程的父进程。
既然所有进程都是由其父进程创建出来的，那么总有一个最原始的父进程吧，否则其它进程是怎么创建出来的呢？确实如此，在Ubuntu 系统下使用"ps -aux"命令可以查看到系统下所有进程信息，如下：

上图中进程号为1 的进程便是所有进程的父进程，通常称为init 进程，它是Linux 系统启动之后运行的第一个进程，它管理着系统上所有其它进程，init 进程是由内核启动，因此理论上说它没有父进程。
init 进程的PID 总是为1，它是所有子进程的父进程，一切从1 开始、一切从init 进程开始！
一个进程的生命周期便是从创建开始直至其终止。

进程的终止

通常，进程有两种终止方式：异常终止和正常终止，分别在3.3 小节和8.12 小节中给大家介绍过，如前所述，进程的正常终止有多种不同的方式，譬如在main 函数中使用return 返回、调用exit()函数结束进程、调用_exit()或_Exit()函数结束进程等。
异常终止通常也有多种不同的方式，譬如在程序当中调用abort()函数异常终止进程、当进程接收到某些信号导致异常终止等。
_exit()函数和exit()函数的status 参数定义了进程的终止状态（termination status），父进程可以调用wait()
函数以获取该状态。虽然参数status 定义为int 类型，但仅有低8 位表示它的终止状态，一般来说，终止状态为0 表示进程成功终止，而非0 值则表示进程在执行过程中出现了一些错误而终止，譬如文件打开失败、读写失败等等，对非0 返回值的解析并无定例。
在我们的程序当中，一般使用exit()库函数而非_exit()系统调用，原因在于exit()最终也会通过_exit()终止进程，但在此之前，它将会完成一些其它的工作，exit()函数会执行的动作如下：
⚫ 如果程序中注册了进程终止处理函数，那么会调用终止处理函数。在9.1.2 小节给大家介绍如何注册进程的终止处理函数；
⚫ 刷新stdio 流缓冲区。关于stdio 流缓冲区的问题，稍后编写一个简单地测试程序进行说明；
⚫ 执行_exit()系统调用。
所以，由此可知，exit()函数会比_exit()会多做一些事情，包括执行终止处理函数、刷新stdio 流缓冲以及调用_exit()，在前面曾提到过，在我们的程序当中，父、子进程不应都使用exit()终止，只能有一个进程使用exit()、而另一个则使用_exit()退出，当然一般推荐的是子进程使用_exit()退出、而父进程则使用exit()退出。其原因就在于调用exit()函数终止进程时会刷新进程的stdio 缓冲区。接下来我们便通过一个示例代码进行说明：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(void)
{
    printf("Hello World!\n");
    switch (fork())
    {
    case -1:
        perror("fork error");
        exit(-1);
    case 0:
        /* 子进程*/
        exit(0);
    default:
        /* 父进程*/
        exit(0);
    }
}

在上述代码中，在fork()创建子进程之前，我们通过printf()打印了一行包括换行符\n 在内字符串，在
fork()创建子进程之后，都使用exit()退出进程，正常的情况下程序就只会打印一行"Hello World!"，这是一个正常的情况，事实上也确实如此，如下所示：

打印结果确实如我们所料，接下来将代码进行简单地修改，把printf()打印的字符串最后面的换行符\n
去掉，如下所示：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(void)
{
    printf("Hello World!");
    switch (fork())
    {
    case -1:
        perror("fork error");
        exit(-1);
    case 0:
        /* 子进程*/
        exit(0);
    default:
        /* 父进程*/
        exit(0);
    }
}

printf 中将字符串后面的\n 换行符给去掉了，接下再进行测试，结果如下：

从打印结果可知，"Hello World!"被打印了两次，这是怎么回事呢？在程序当中明明只使用了printf 打印了一次字符串。要解释这个问题，首先要知道，进程的用户空间内存中维护了stdio 缓冲区，0 小节给大家介绍过，因此通过fork()创建子进程时会复制这些缓冲区。标准输出设备默认使用的是行缓冲，当检测到换行符\n 时会立即显示函数printf()输出的字符串，在示例代码9.9.1 中printf 输出的字符串中包含了换行符，所以会立即读走缓冲区中的数据并显示，读走之后此时缓冲区就空了，子进程虽然拷贝了父进程的缓冲区，但是空的，虽然父、子进程使用exit()退出时会刷新各自的缓冲区，但对于空缓冲区自然无数据可读。
而对于示例代码9.9.2 来说，printf()并没有添加换行符\n，当调用printf()时并不会立即读取缓冲区中的数据进行显示，由此fork()之后创建的子进程也自然拷贝了缓冲区的数据，当它们调用exit()函数时，都会刷新各自的缓冲区、显示字符串，所以就会看到打印出了两次相同的字符串。
可以采用以下任一方法来避免重复的输出结果：
⚫ 对于行缓冲设备，可以加上对应换行符，譬如printf 打印输出字符串时在字符串后面添加\n 换行符，对于puts()函数来说，本身会自动添加换行符；
⚫ 在调用fork()之前，使用函数fflush()来刷新stdio 缓冲区，当然，作为另一种选择，也可以使用
setvbuf()和setbuf()来关闭stdio 流的缓冲功能，这些内容在3.11 中已经给大家介绍过；
⚫ 子进程调用_exit()退出进程、而非使用exit()，调用_exit()在退出时便不会刷新stdio 缓冲区，这也解释前面为什么我们要在子进程中使用_exit()退出这样做的一个原因。将示例代码9.9.2 中子进程的退出操作exit()替换成_exit()进行测试，打印的结果便只会显示一次字符串，大家自己动手试一试！
关于本小节的内容，到这里就结束了，虽然笔者觉得自己已经介绍得很详细了，如果大家觉得还有不懂的地方，可以自己编写程序进行测试、验证，编程是一门动手实践性很强的工作，大家要善于从中发现一些问题，然后自己能够编写程序进行测试、验证，大家加油！

监视子进程

在很多应用程序的设计中，父进程需要知道子进程于何时被终止，并且需要知道子进程的终止状态信息，是正常终止、还是异常终止亦或者被信号终止等，意味着父进程会对子进程进行监视。

wait()函数

对于许多需要创建子进程的进程来说，有时设计需要监视子进程的终止时间以及终止时的一些状态信息，在某些设计需求下这是很有必要的。系统调用wait()可以等待进程的任一子进程终止，同时获取子进程的终止状态信息，其函数原型如下所示：

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

使用该函数需要包含头文件<sys/types.h>和<sys/wait.h>。

函数参数和返回值含义如下：
status：参数status 用于存放子进程终止时的状态信息，参数status 可以为NULL，表示不接收子进程终止时的状态信息。
返回值：若成功则返回终止的子进程对应的进程号；失败则返回-1。

系统调用wait()将执行如下动作：
⚫ 调用wait()函数，如果其所有子进程都还在运行，则wait()会一直阻塞等待，直到某一个子进程终止；

⚫ 如果进程调用wait()，但是该进程并没有子进程，也就意味着该进程并没有需要等待的子进程，那么wait()将返回错误，也就是返回-1、并且会将errno 设置为ECHILD。
⚫ 如果进程调用wait()之前，它的子进程当中已经有一个或多个子进程已经终止了，那么调用wait()也不会阻塞。wait()函数的作用除了获取子进程的终止状态信息之外，更重要的一点，就是回收子进程的一些资源，俗称为子进程“收尸”，关于这个问题后面再给大家进行介绍。所以在调用wait()函数之前，已经有子进程终止了，意味着正等待着父进程为其“收尸”，所以调用wait()将不会阻塞，而是会立即替该子进程“收尸”、处理它的“后事”，然后返回到正常的程序流程中，一次wait()调用只能处理一次。
参数status 不为NULL 的情况下，则wait()会将子进程的终止时的状态信息存储在它指向的int 变量中，可以通过以下宏来检查status 参数：
⚫ WIFEXITED(status)：如果子进程正常终止，则返回true；
⚫ WEXITSTATUS(status)：返回子进程退出状态，是一个数值，其实就是子进程调用_exit()或exit()时指定的退出状态；wait()获取得到的status 参数并不是调用_exit()或exit()时指定的状态，可通过WEXITSTATUS 宏转换；
⚫ WIFSIGNALED(status)：如果子进程被信号终止，则返回true；
⚫ WTERMSIG(status)：返回导致子进程终止的信号编号。如果子进程是被信号所终止，则可以通过此宏获取终止子进程的信号；
⚫ WCOREDUMP(status)：如果子进程终止时产生了核心转储文件，则返回true；
还有一些其它的宏定义，这里就不给一一介绍了，具体的请查看man 手册。

使用示例

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <errno.h>
int main(void)
{
    int status;
    int ret;
    int i;
    /* 循环创建3 个子进程*/
    for (i = 1; i <= 3; i++)
    {
        switch (fork())
        {
        case -1:
            perror("fork error");
            exit(-1);
        case 0:
            /* 子进程*/

            printf("子进程<%d>被创建\n", getpid());
            sleep(i);
            _exit(i);
        default:
            /* 父进程*/
            break;
        }
    }
    sleep(1);
    printf("~~~~~~~~~~~~~~\n");
    for (i = 1; i <= 3; i++)
    {
        ret = wait(&status);
        if (-1 == ret)
        {
            if (ECHILD == errno)
            {
                printf("没有需要等待回收的子进程\n");
                exit(0);
            }
            else
            {
                perror("wait error");
                exit(-1);
            }
        }
        printf("回收子进程<%d>, 终止状态<%d>\n", ret,
               WEXITSTATUS(status));
    }
    exit(0);
}

示例代码中，通过for 循环创建了3 个子进程，父进程中循环调用wait()函数等待回收子进程，并将本次回收的子进程进程号以及终止状态打印出来，编译测试结果如下：

waitpid()函数

使用wait()系统调用存在着一些限制，这些限制包括如下：
⚫ 如果父进程创建了多个子进程，使用wait()将无法等待某个特定的子进程的完成，只能按照顺序等待下一个子进程的终止，一个一个来、谁先终止就先处理谁；
⚫ 如果子进程没有终止，正在运行，那么wait()总是保持阻塞，有时我们希望执行非阻塞等待，是否有子进程终止，通过判断即可得知；
⚫ 使用wait()只能发现那些被终止的子进程，对于子进程因某个信号（譬如SIGSTOP 信号）而停止（注意，这里停止指的暂停运行），或是已停止的子进程收到SIGCONT 信号后恢复执行的情况就无能为力了。
而设计waitpid()则可以突破这些限制，waitpid()系统调用函数原型如下所示：
#include <sys/types.h>
#include <sys/wait.h>
pid_t waitpid(pid_t pid, int *status, int options);
使用该函数需要包含头文件<sys/types.h>和<sys/wait.h>。
函数参数和返回值含义如下：
pid：参数pid 用于表示需要等待的某个具体子进程，关于参数pid 的取值范围如下：
⚫ 如果pid 大于0，表示等待进程号为pid 的子进程；
⚫ 如果pid 等于0，则等待与调用进程（父进程）同一个进程组的所有子进程；
⚫ 如果pid 小于-1，则会等待进程组标识符与pid 绝对值相等的所有子进程；
⚫ 如果pid 等于-1，则等待任意子进程。wait(&status)与waitpid(-1, &status, 0)等价。
status：与wait()函数的status 参数意义相同。
options：稍后介绍。
返回值：返回值与wait()函数的返回值意义基本相同，在参数options 包含了WNOHANG 标志的情况下，返回值会出现0，稍后介绍。
参数options 是一个位掩码，可以包括0 个或多个如下标志：
⚫ WNOHANG：如果子进程没有发生状态改变（终止、暂停），则立即返回，也就是执行非阻塞等待，可以实现轮训poll，通过返回值可以判断是否有子进程发生状态改变，若返回值等于0 表示没有发生改变。
⚫ WUNTRACED：除了返回终止的子进程的状态信息外，还返回因信号而停止（暂停运行）的子进程状态信息；
⚫ WCONTINUED：返回那些因收到SIGCONT 信号而恢复运行的子进程的状态信息。
从以上的介绍可知，waitpid()在功能上要强于wait()函数，它弥补了wait()函数所带来的一些限制，具体在实际的编程使用当中，可根据自己的需求进行选择。
使用示例
使用waitpid()替换wait()，改写示例代码9.10.1。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <errno.h>
int main(void)
{
    int status;
    int ret;
    int i;
    /* 循环创建3 个子进程*/
    for (i = 1; i <= 3; i++)
    {
        switch (fork())
        {
        case -1:
            perror("fork error");
            exit(-1);
        case 0:
            /* 子进程*/
            printf("子进程<%d>被创建\n", getpid());
            sleep(i);
            _exit(i);
        default:
            /* 父进程*/
            break;
        }
    }
    sleep(1);
    printf("~~~~~~~~~~~~~~\n");
    for (i = 1; i <= 3; i++)
    {
        ret = waitpid(-1, &status, 0);
        if (-1 == ret)
        {
            if (ECHILD == errno)
            {
                printf("没有需要等待回收的子进程\n");
                exit(0);
            }
            else
            {
                perror("wait error");
                exit(-1);
            }
        }
        printf("回收子进程<%d>, 终止状态<%d>\n", ret,
               WEXITSTATUS(status));
    }
    exit(0);
}

将wait(&status)替换成了waitpid(-1, &status, 0)，通过上面的介绍可知，waitpid()函数的这种参数配置情况与wait()函数是完全等价的，运行结果与示例代码9.10.1 运行结果相同，这里不再演示！
将上述代码进行简单修改，将其修改成轮训方式，如下所示：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <errno.h>
int main(void)
{
    int status;
    int ret;
    int i;
    /* 循环创建3 个子进程*/
    for (i = 1; i <= 3; i++)
    {
        switch (fork())
        {
        case -1:
            perror("fork error");
            exit(-1);
        case 0:
            /* 子进程*/
            printf("子进程<%d>被创建\n", getpid());
            sleep(i);
            _exit(i);
        default:
            /* 父进程*/
            break;
        }
    }
    sleep(1);
    printf("~~~~~~~~~~~~~~\n");
    for (;;)
    {
        ret = waitpid(-1, &status, WNOHANG);
        if (0 > ret)
        {
            if (ECHILD == errno)
                exit(0);
            else
            {
                perror("wait error");
                exit(-1);
            }
        }
        else if (0 == ret)
            continue;
        else
            printf("回收子进程<%d>, 终止状态<%d>\n", ret,
                   WEXITSTATUS(status));
    }
    exit(0);
}

将waitpid()函数的options 参数添加WNOHANG 标志，将waitpid()配置成非阻塞模式，使用轮训的方式依次回收各个子进程，测试结果如下：

waitid()函数

除了以上给大家介绍的wait()和waitpid()系统调用之外，还有一个waitid()系统调用，waitid()与waitpid()
类似，不过waitid()提供了更多的扩展功能，具体的使用方法笔者便不再介绍，大家有兴趣可以自己通过man
进行学习。

僵尸进程与孤儿进程

当一个进程创建子进程之后，它们俩就成为父子进程关系，父进程与子进程的生命周期往往是不相同的，这里就会出现两个问题：
⚫ 父进程先于子进程结束。
⚫ 子进程先于父进程结束。
本小节我们就来讨论下这两种不同的情况。
孤儿进程
父进程先于子进程结束，也就是意味着，此时子进程变成了一个“孤儿”，我们把这种进程就称为孤儿进程。在Linux 系统当中，所有的孤儿进程都自动成为init 进程（进程号为1）的子进程，换言之，某一子进程的父进程结束后，该子进程调用getppid()将返回1，init 进程变成了孤儿进程的“养父”；这是判定某一子进程的“生父”是否还“在世”的方法之一，通过下面的代码进行测试：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(void)
{
    /* 创建子进程*/
    switch (fork())
    {
    case -1:
        perror("fork error");
        exit(-1);
    case 0:
        /* 子进程*/
        printf("子进程<%d>被创建, 父进程<%d>\n", getpid(), getppid());
        sleep(3);                          // 休眠3 秒钟等父进程结束
        printf("父进程<%d>\n", getppid()); // 再次获取父进程pid
        _exit(0);
    default:
        /* 父进程*/
        break;
    }
    sleep(1); // 休眠1 秒
    printf("父进程结束!\n");
    exit(0);
}

在上述代码中，子进程休眠3 秒钟，保证父进程先结束，而父进程休眠1 秒钟，保证子进程能够打印出第一个printf()，也就是在父进程结束前，打印子进程的父进程进程号；子进程3 秒休眠时间过后，再次打印父进程的进程号，此时它的“生父”已经结束了。
我们来看看打印结果：

可以发现，打印结果并不是1，意味着并不是init 进程，而是1911，这是怎么回事呢？通过"ps -axu"查询可知，进程号1911 对应的是upstart 进程，如下所示：

事实上，/sbin/upstart 进程与Ubuntu 系统图形化界面有关系，是图形化界面下的一个后台守护进程，可负责“收养”孤儿进程，所以图形化界面下，upstart 进程就自动成为了孤儿进程的父进程，这里笔者是在
Ubuntu 16.04 版本下进行的测试，可能不同的版本这里看到的结果会有不同。
既然在图形化界面下孤儿进程的父进程不是init 进程，那么我们进入Ubuntu 字符界面，按Ctrl + Alt + F1 进入，如下所示：

输入Linux 用户名和密码登录，我们在运行一次：

字符界面模式下无法显示中文，所以出现了很多白色小方块，从打印结果可以发现，此时孤儿进程的父进程就成了init 进程，大家可以自己测试下，按Ctrl + Alt + F7 回到Ubuntu 图形化界面。
僵尸进程
进程结束之后，通常需要其父进程为其“收尸”，回收子进程占用的一些内存资源，父进程通过调用
wait()（或其变体waitpid()、waitid()等）函数回收子进程资源，归还给系统。
如果子进程先于父进程结束，此时父进程还未来得及给子进程“收尸”，那么此时子进程就变成了一个僵尸进程。子进程结束后其父进程并没有来得及立马给它“收尸”，子进程处于“曝尸荒野”的状态，在这么一个状态下，我们就将子进程成为僵尸进程；至于名字由来，肯定是对电影情节的一种效仿！
当父进程调用wait()（或其变体，下文不再强调）为子进程“收尸”后，僵尸进程就会被内核彻底删除。另外一种情况，如果父进程并没有调用wait()函数然后就退出了，那么此时init 进程将会接管它的子进程并自动调用wait()，故而从系统中移除僵尸进程。
如果父进程创建了某一子进程，子进程已经结束，而父进程还在正常运行，但父进程并未调用wait()回收子进程，此时子进程变成一个僵尸进程。首先来说，这样的程序设计是有问题的，如果系统中存在大量的僵尸进程，它们势必会填满内核进程表，从而阻碍新进程的创建。需要注意的是，僵尸进程是无法通过信号将其杀死的，即使是“一击必杀”信号SIGKILL 也无法将其杀死，那么这种情况下，只能杀死僵尸进程的父进程（或等待其父进程终止），这样init 进程将会接管这些僵尸进程，从而将它们从系统中清理掉！所以，在我们的一个程序设计中，一定要监视子进程的状态变化，如果子进程终止了，要调用wait()将其回收，避免僵尸进程。
示例代码
编写示例代码，产生一个僵尸进程。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(void)
{
    /* 创建子进程*/
    switch (fork())
    {
    case -1:
        perror("fork error");
        exit(-1);
    case 0:
        /* 子进程*/
        printf("子进程<%d>被创建\n", getpid());
        sleep(1);
        printf("子进程结束\n");
        _exit(0);
    default:
        /* 父进程*/
        break;
    }
    for (;;)
        sleep(1);
    exit(0);
}

在上述代码中，子进程已经退出，但其父进程并没调用wait()为其“收尸”，使得子进程成为一个僵尸进程，使用命令"ps -aux"可以查看到该僵尸进程，测试结果如下：


通过命令可以查看到子进程113456 依然存在，可以看到它的状态栏显示的是“Z”（zombie，僵尸），表示它是一个僵尸进程。僵尸进程无法被信号杀死，大家可以试试，要么等待其父进程终止、要么杀死其父进程，让init 进程来处理，当我们杀死其父进程之后，僵尸进程也会被随之清理。

SIGCHLD 信号

SIGCHLD 信号在第八章中给大家介绍过，当发生以下两种情况时，父进程会收到该信号：
⚫ 当父进程的某个子进程终止时，父进程会收到SIGCHLD 信号；
⚫ 当父进程的某个子进程因收到信号而停止（暂停运行）或恢复时，内核也可能向父进程发送该信号。
子进程的终止属于异步事件，父进程事先是无法预知的，如果父进程有自己需要做的事情，它不能一直
wait()阻塞等待子进程终止（或轮训），这样父进程将啥事也做不了，那么有什么办法来解决这样的尴尬情况，当然有办法，那就是通过SIGCHLD 信号。
那既然子进程状态改变时（终止、暂停或恢复），父进程会收到SIGCHLD 信号，SIGCHLD 信号的系统默认处理方式是将其忽略，所以我们要捕获它、绑定信号处理函数，在信号处理函数中调用wait()收回子进程，回收完毕之后再回到父进程自己的工作流程中。
不过，使用这一方式时需要掌握一些窍门！
由8.4.1 和8.4.2 小节的介绍可知，当调用信号处理函数时，会暂时将引发调用的信号添加到进程的信号掩码中（除非sigaction()指定了SA_NODEFER 标志），这样一来，当SIGCHLD 信号处理函数正在为一个终止的子进程“收尸”时，如果相继有两个子进程终止，即使产生了两次SIGCHLD 信号，父进程也只能捕获到一次SIGCHLD 信号，结果是，父进程的SIGCHLD 信号处理函数每次只调用一次wait()，那么就会导致有些僵尸进程成为“漏网之鱼”。
解决方案就是：在SIGCHLD 信号处理函数中循环以非阻塞方式来调用waitpid()，直至再无其它终止的子进程需要处理为止，所以，通常SIGCHLD 信号处理函数内部代码如下所示：
while (waitpid(-1, NULL, WNOHANG) > 0)
continue;
上述代码一直循环下去，直至waitpid()返回0，表明再无僵尸进程存在；或者返回-1，表明有错误发生。应在创建任何子进程之前，为SIGCHLD 信号绑定处理函数。
使用示例

通过SIGCHLD 信号实现异步方式监视子进程。

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
static void wait_child(int sig)
{
    /* 替子进程收尸*/
    printf("父进程回收子进程\n");
    while (waitpid(-1, NULL, WNOHANG) > 0)
        continue;
}
int main(void)
{
    struct sigaction sig = {0};
    /* 为SIGCHLD 信号绑定处理函数*/
    sigemptyset(sig.sa_mask);
    sig.sa_handler = wait_child;
    sig.sa_flags = 0;
    if (-1 == sigaction(SIGCHLD, &sig, NULL))
    {
        perror("sigaction error");
        exit(-1);
    }
    /* 创建子进程*/
    switch (fork())
    {
    case -1:
        perror("fork error");
        exit(-1);
    case 0:
        /* 子进程*/
        printf("子进程<%d>被创建\n", getpid());
        sleep(1);
        printf("子进程结束\n");
        _exit(0);
    default:
        /* 父进程*/
        break;
    }
    sleep(3);
    exit(0);
}

运行结果如下：

执行新程序

在前面已经大家提到了exec 函数，当子进程的工作不再是运行父进程的代码段，而是运行另一个新程序的代码，那么这个时候子进程可以通过exec 函数来实现运行另一个新的程序。本小节我们就来学习下，如何在程序中运行一个新的程序，从新程序的main()函数开始运行。

execve()函数

系统调用execve()可以将新程序加载到某一进程的内存空间，通过调用execve()函数将一个外部的可执行文件加载到进程的内存空间运行，使用新的程序替换旧的程序，而进程的栈、数据、以及堆数据会被新程序的相应部件所替换，然后从新程序的main()函数开始执行。
execve()函数原型如下所示：

#include <unistd.h>
int execve(const char *filename, char *const argv[], char *const envp[]);

使用该函数需要包含头文件<unistd.h>。
函数参数和返回值含义如下：
filename：参数filename 指向需要载入当前进程空间的新程序的路径名，既可以是绝对路径、也可以是相对路径。
argv：参数argv 则指定了传递给新程序的命令行参数。是一个字符串数组，该数组对应于main(int argc, char *argv[])函数的第二个参数argv，且格式也与之相同，是由字符串指针所组成的数组，以NULL 结束。
argv[0]对应的便是新程序自身路径名。
envp：参数envp 也是一个字符串指针数组，指定了新程序的环境变量列表，参数envp 其实对应于新程序的environ 数组，同样也是以NULL 结束，所指向的字符串格式为name=value。
返回值：execve 调用成功将不会返回；失败将返回-1，并设置errno。
对execve()的成功调用将永不返回，而且也无需检查它的返回值，实际上，一旦该函数返回，就表明它发生了错误。
基于系统调用execve()，还提供了一系列以exec 为前缀命名的库函数，虽然函数参数各异，当其功能相同，通常将这些函数（包括系统调用execve()）称为exec 族函数，所以exec 函数并不是指某一个函数、而是exec 族函数，下一小节将会向大家介绍这些库函数。
通常将调用这些exec 函数加载一个外部新程序的过程称为exec 操作。
使用示例
编写一个简单地程序，在测试程序testApp 当中通过execve()函数运行另一个新程序newApp。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(int argc, char *argv[])
{
    char *arg_arr[5];
    char *env_arr[5] = {"NAME=app", "AGE=25",
                        "SEX=man", NULL};
    if (2 > argc)
        exit(-1);
    arg_arr[0] = argv[1];
    arg_arr[1] = "Hello";
    arg_arr[2] = "World";
    arg_arr[3] = NULL;
    execve(argv[1], arg_arr, env_arr);
    perror("execve error");
    exit(-1);
}

将上述程序编译成一个可执行文件testApp。
接着编写新程序，在新程序当中打印出环境变量和传参，如下所示：

#include <stdio.h>
#include <stdlib.h>
extern char **environ;
int main(int argc, char *argv[])
{
    char **ep = NULL;
    int j;
    for (j = 0; j < argc; j++)
        printf("argv[%d]: %s\n", j, argv[j]);
    puts("env:");
    for (ep = environ; *ep != NULL; ep++)
        printf(" %s\n", *ep);
    exit(0);
}

将新程序编译成newApp 可执行文件，两份程序编译好之后，如下所示：

接下来进行测试，运行testApp 程序，传入一个参数，该参数便是新程序newApp 的可执行文件路径：

由上图打印结果可知，在我们的testApp 程序中，成功通过execve()运行了另一个新的程序newApp，当
newApp 程序运行完成退出后，testApp 进程就结束了。
示例代码9.11.1 中execve()函数的使用并不是它真正的应用场景，通常由fork()生成的子进程对execve()
的调用最为频繁，也就是子进程执行exec 操作；示例代码9.11.1 中的execve 用法在实际的应用不常见，这里只是给大家进行演示说明。
说到这里，我们来分析一个问题，为什么需要在子进程中执行新程序？其实这个问题非常简单，虽然可以直接在子进程分支编写子进程需要运行的代码，但是不够灵活，扩展性不够好，直接将子进程需要运行的代码单独放在一个可执行文件中不是更好吗，所以就出现了exec 操作。

exec 库函数

exec 族函数包括多个不同的函数，这些函数命名都以exec 为前缀，上一小节给大家介绍的execve()函数也属于exec 族函数中的一员，但它属于系统调用；本小节我们介绍exec 族函数中的库函数，这些库函数都是基于系统调用execve()而实现的，虽然参数各异、但功能相同，包括：execl()、execlp()、execle()、execv()、
execvp()、execvpe()，它们的函数原型如下所示：

#include <unistd.h>
extern char **environ;
int execl(const char *path, const char *arg, ... /* (char *) NULL */);
int execlp(const char *file, const char *arg, ... /* (char *) NULL */);
int execle(const char *path, const char *arg, ... /*, (char *) NULL, char * const envp[] */);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execvpe(const char *file, char *const argv[], char *const envp[]);

使用这些函数需要包含头文件<unistd.h>。
接下来简单地介绍下它们之间的区别：
⚫ execl()和execv()都是基本的exec 函数，都可用于执行一个新程序，它们之间的区别在于参数格式不同；参数path 意义和格式都相同，与系统调用execve()的filename 参数相同，指向新程序的路径名，既可以是绝对路径、也可以是相对路径。execl()和execv()不同的在于第二个参数，execv()的
argv 参数与execve()的argv 参数相同，也是字符串指针数组；而execl()把参数列表依次排列，使用可变参数形式传递，本质上也是多个字符串，以NULL 结尾，如下所示：

// execv 传参
char *arg_arr[5];
arg_arr[0] = "./newApp";
arg_arr[1] = "Hello";
arg_arr[2] = "World";
arg_arr[3] = NULL;
execv("./newApp", arg_arr);
// execl 传参
execl("./newApp", "./newApp", "Hello", "World", NULL);

⚫ execlp()和execvp()在execl()和execv()基础上加了一个p，这个p 其实表示的是PATH；execl()和
execv()要求提供新程序的路径名，而execlp()和execvp()则允许只提供新程序文件名，系统会在由环境变量PATH 所指定的目录列表中寻找相应的可执行文件，如果执行的新程序是一个Linux 命令，这将很有用；当然，execlp()和execvp()函数也兼容相对路径和绝对路径的方式。
⚫ execle()和execvpe()这两个函数在命名上加了一个e，这个e 其实表示的是environment 环境变量，意味着这两个函数可以指定自定义的环境变量列表给新程序，参数envp 与系统调用execve()的envp
参数相同，也是字符串指针数组，使用方式如下所示：

// execvpe 传参
char *env_arr[5] = {"NAME=app", "AGE=25",
"SEX=man", NULL};
char *arg_arr[5];
arg_arr[0] = "./newApp";
arg_arr[1] = "Hello";
arg_arr[2] = "World";
arg_arr[3] = NULL;
execvpe("./newApp", arg_arr, env_arr);
// execle 传参
execle("./newApp", "./newApp", "Hello", "World", NULL, env_arr);

给大家介绍完这些exec 函数之后，下面将进行实战。

exec 族函数使用示例

使用以上给大家介绍的6 个exec 库函数运行ls 命令，并加入参数-a 和-l。
1、execl()函数运行ls 命令。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(void)
{
    execl("/bin/ls", "ls", "-a", "-l", NULL);
    perror("execl error");
    exit(-1);
}

2、execv()函数运行ls 命令。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(void)
{
    char *arg_arr[5];
    arg_arr[0] = "ls";
    arg_arr[1] = "-a";
    arg_arr[2] = "-l";
    arg_arr[3] = NULL;
    execv("/bin/ls", arg_arr);
    perror("execv error");
    exit(-1);
}

3、execlp()函数运行ls 命令。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(void)
{
    execlp("ls", "ls", "-a", "-l", NULL);
    perror("execlp error");
    exit(-1);
}

4、execvp()函数运行ls 命令。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(void)
{
    char *arg_arr[5];
    arg_arr[0] = "ls";
    arg_arr[1] = "-a";
    arg_arr[2] = "-l";
    arg_arr[3] = NULL;
    execvp("ls", arg_arr);
    perror("execvp error");
    exit(-1);
}

5、execle()函数运行ls 命令。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
extern char **environ;
int main(void)
{
    execle("/bin/ls", "ls", "-a", "-l", NULL, environ);
    perror("execle error");
    exit(-1);
}

6、execvpe()函数运行ls 命令。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
extern char **environ;
int main(void)
{
    char *arg_arr[5];
    arg_arr[0] = "ls";
    arg_arr[1] = "-a";
    arg_arr[2] = "-l";
    arg_arr[3] = NULL;
    execvpe("ls", arg_arr, environ);
    perror("execvpe error");
    exit(-1);
}

以上所有的这些示例代码，运行结果都是一样的，与"ls -al"命令效果相同，如下所示：

system()函数

使用system()函数可以很方便地在我们的程序当中执行任意shell 命令，本小节来学习下system()函数的用法，以及介绍system()函数的实现方法。
首先来看看system()函数原型，如下所示：

#include <stdlib.h>
int system(const char *command);

这是一个库函数，使用该函数需要包含头文件<stdlib.h>。
函数参数和返回值含义如下：

command：参数command 指向需要执行的shell 命令，以字符串的形式提供，譬如"ls -al"、"echo
HelloWorld"等。
返回值：关于system()函数的返回值有多种不同的情况，稍后给大家介绍。
system()函数其内部的是通过调用fork()、execl()以及waitpid()这三个函数来实现它的功能，首先system()
会调用fork()创建一个子进程来运行shell（可以把这个子进程成为shell 进程），并通过shell 执行参数
command 所指定的命令。譬如：

system("ls -la")
system("echo HelloWorld")

system()的返回值如下：
⚫ 当参数command 为NULL，如果shell 可用则返回一个非0 值，若不可用则返回0；针对一些非
UNIX 系统，该系统上可能是没有shell 的，这样就会导致shell 不可能；如果command 参数不为
NULL，则返回值从以下的各种情况所决定。
⚫ 如果无法创建子进程或无法获取子进程的终止状态，那么system()返回-1；
⚫ 如果子进程不能执行shell，则system()的返回值就好像是子进程通过调用_exit(127)终止了；
⚫ 如果所有的系统调用都成功，system()函数会返回执行command 的shell 进程的终止状态。
system()的主要优点在于使用上方便简单，编程时无需自己处理对fork()、exec 函数、waitpid()以及exit()
等调用细节，system()内部会代为处理；当然这些优点通常是以牺牲效率为代价的，使用system()运行shell
命令需要至少创建两个进程，一个进程用于运行shell、另外一个或多个进程则用于运行参数command 中解析出来的命令，每一个命令都会调用一次exec 函数来执行；所以从这里可以看出，使用system()函数其效率会大打折扣，如果我们的程序对效率或速度有所要求，那么建议大家不是直接使用system()。
使用示例
以下示例代码演示了system()函数的用法，执行测试程序时，将需要执行的命令通过参数传递给main()
函数，在main 函数中调用system()来执行该条命令。

#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
    int ret;
    if (2 > argc)
        exit(-1);
    ret = system(argv[1]);
    if (-1 == ret)
        fputs("system error.\n", stderr);
    else
    {
        if (WIFEXITED(ret) && (127 == WEXITSTATUS(ret)))
            fputs("could not invoke shell.\n", stderr);
    }
    exit(0);
}

运行测试：

进程状态与进程关系

本小节来聊一聊关于进程状态与进程关系相关的话题。

进程状态

Linux 系统下进程通常存在6 种不同的状态，分为：就绪态、运行态、僵尸态、可中断睡眠状态（浅度睡眠）、不可中断睡眠状态（深度睡眠）以及暂停态。
⚫ 就绪态（Ready）：指该进程满足被CPU 调度的所有条件但此时并没有被调度执行，只要得到CPU
就能够直接运行；意味着该进程已经准备好被CPU 执行，当一个进程的时间片到达，操作系统调度程序会从就绪态链表中调度一个进程；
⚫ 运行态：指该进程当前正在被CPU 调度运行，处于就绪态的进程得到CPU 调度就会进入运行态；
⚫ 僵尸态：僵尸态进程其实指的就是僵尸进程，指该进程已经结束、但其父进程还未给它“收尸”；
⚫ 可中断睡眠状态：可中断睡眠也称为浅度睡眠，表示睡的不够“死”，还可以被唤醒，一般来说可以通过信号来唤醒；
⚫ 不可中断睡眠状态：不可中断睡眠称为深度睡眠，深度睡眠无法被信号唤醒，只能等待相应的条件成立才能结束睡眠状态。把浅度睡眠和深度睡眠统称为等待态（或者叫阻塞态），表示进程处于一种等待状态，等待某种条件成立之后便会进入到就绪态；所以，处于等待态的进程是无法参与进程系统调度的。
⚫ 暂停态：暂停并不是进程的终止，表示进程暂停运行，一般可通过信号将进程暂停，譬如SIGSTOP
信号；处于暂停态的进程是可以恢复进入到就绪态的，譬如收到SIGCONT 信号。
一个新创建的进程会处于就绪态，只要得到CPU 就能被执行。以下列出了进程各个状态之间的转换关系，如下所示：

进程关系

介绍完进程状态之后，接下来聊一聊进程关系，在Linux 系统下，每个进程都有自己唯一的标识：进程号（进程ID、PID），也有自己的生命周期，进程都有自己的父进程、而父进程也有父进程，这就形成了一个以init 进程为根的进程家族树；当子进程终止时，父进程会得到通知并能取得子进程的退出状态。
除此之外，进程间还存在着其它一些层次关系，譬如进程组和会话；所以，由此可知，进程间存在着多种不同的关系，主要包括：无关系（相互独立）、父子进程关系、进程组以及会话。
1、无关系
两个进程间没有任何关系，相互独立。
2、父子进程关系
两个进程间构成父子进程关系，譬如一个进程fork()创建出了另一个进程，那么这两个进程间就构成了父子进程关系，调用fork()的进程称为父进程、而被fork()创建出来的进程称为子进程；当然，如果“生父”先与子进程结束，那么init 进程（“养父”）就会成为子进程的父进程，它们之间同样也是父子进程关系。
3、进程组
每个进程除了有一个进程ID、父进程ID 之外，还有一个进程组ID，用于标识该进程属于哪一个进程组，进程组是一个或多个进程的集合，这些进程并不是孤立的，它们彼此之间或者存在父子、兄弟关系，或者在功能上有联系。
Linux 系统设计进程组实质上是为了方便对进程进行管理。假设为了完成一个任务，需要并发运行100
个进程，但当处于某种场景时需要终止这100 个进程，若没有进程组就需要一个一个去终止，这样非常麻烦且容易出现一些问题；有了进程组的概念之后，就可以将这100 个进程设置为一个进程组，这些进程共享一个进程组ID，这样一来，终止这100 个进程只需要终止该进程组即可。
关于进程组需要注意以下以下内容：
⚫ 每个进程必定属于某一个进程组、且只能属于一个进程组；
⚫ 每一个进程组有一个组长进程，组长进程的ID 就等于进程组ID；
⚫ 在组长进程的ID 前面加上一个负号即是操作进程组；

⚫ 组长进程不能再创建新的进程组；
⚫ 只要进程组中还存在一个进程，则该进程组就存在，这与其组长进程是否终止无关；
⚫ 一个进程组可以包含一个或多个进程，进程组的生命周期从被创建开始，到其内所有进程终止或离开该进程组；
⚫ 默认情况下，新创建的进程会继承父进程的进程组ID。
通过系统调用getpgrp()或getpgid()可以获取进程对应的进程组ID，其函数原型如下所示：

#include <unistd.h>
pid_t getpgid(pid_t pid);
pid_t getpgrp(void);

首先使用该函数需要包含头文件<unistd.h>。
这两个函数都用于获取进程组ID，getpgrp()没有参数，返回值总是调用者进程对应的进程组ID；而对于getpgid()函数来说，可通过参数pid 指定获取对应进程的进程组ID，如果参数pid 为0 表示获取调用者进程的进程组ID。
getpgid()函数成功将返回进程组ID；失败将返回-1、并设置errno。
所以由此可知，getpgrp()就等价于getpgid(0)。
使用示例

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(void)
{
    pid_t pid = getpid();
    printf("进程组ID<%d>---getpgrp()\n", getpgrp());
    printf("进程组ID<%d>---getpgid(0)\n", getpgid(0));
    printf("进程组ID<%d>---getpgid(%d)\n", getpgid(pid), pid);
    exit(0);
}

测试结果：

从上面的结果可以发现，其新创建的进程对应的进程组ID 等于该进程的ID。
调用系统调用setpgid()或setpgrp()可以加入一个现有的进程组或创建一个新的进程组，其函数原型如下所示：

#include <unistd.h>
int setpgid(pid_t pid, pid_t pgid);
int setpgrp(void);

使用这些函数同样需要包含头文件<unistd.h>。
setpgid()函数将参数pid 指定的进程的进程组ID 设置为参数gpid。如果这两个参数相等（pid==gpid），则由pid 指定的进程变成为进程组的组长进程，创建了一个新的进程；如果参数pid 等于0，则使用调用者的进程ID；另外，如果参数gpid 等于0，则创建一个新的进程组，由参数pid 指定的进程作为进程组组长进程。
setpgrp()函数等价于setpgid(0, 0)。
一个进程只能为它自己或它的子进程设置进程组ID，在它的子进程调用exec 函数后，它就不能更改该子进程的进程组ID 了。
使用示例

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(void)
{
    printf("更改前进程组ID<%d>\n", getpgrp());
    setpgrp();
    printf("更改后进程组ID<%d>\n", getpgrp());
    exit(0);
}

4、会话
介绍完进程组之后，再来看下会话，会话是一个或多个进程组的集合，其与进程组、进程之间的关系如下图所示：

一个会话可包含一个或多个进程组，但只能有一个前台进程组，其它的是后台进程组；每个会话都有一个会话首领（leader），即创建会话的进程。一个会话可以有控制终端、也可没有控制终端，在有控制终端
的情况下也只能连接一个控制终端，这通常是登录到其上的终端设备（在终端登录情况下）或伪终端设备（譬如通过SSH 协议网络登录），一个会话中的进程组可被分为一个前台进程组以及一个或多个后台进程组。
会话的首领进程连接一个终端之后，该终端就成为会话的控制终端，与控制终端建立连接的会话首领进程被称为控制进程；产生在终端上的输入和信号将发送给会话的前台进程组中的所有进程，譬如Ctrl + C（产生SIGINT 信号）、Ctrl + Z（产生SIGTSTP 信号）、Ctrl + \（产生SIGQUIT 信号）等等这些由控制终端产生的信号。
当用户在某个终端登录时，一个新的会话就开始了；当我们在Linux 系统下打开了多个终端窗口时，实际上就是创建了多个终端会话。
一个进程组由组长进程的ID 标识，而对于会话来说，会话的首领进程的进程组ID 将作为该会话的标识，也就是会话ID（sid），在默认情况下，新创建的进程会继承父进程的会话ID。通过系统调用getsid()可以获取进程的会话ID，其函数原型如下所示：

#include <unistd.h>
pid_t getsid(pid_t pid);

使用该函数需要包含头文件<unistd.h>，如果参数pid 为0，则返回调用者进程的会话ID；如果参数pid
不为0，则返回参数pid 指定的进程对应的会话ID。成功情况下，该函数返回会话ID，失败则返回-1、并设置errno。
使用示例

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(void)
{
    printf("会话ID<%d>\n", getsid(0));
    exit(0);
}

打印结果：

使用系统调用setsid()可以创建一个会话，其函数原型如下所示：

#include <unistd.h>
pid_t setsid(void);

如果调用者进程不是进程组的组长进程，调用setsid()将创建一个新的会话，调用者进程是新会话的首领进程，同样也是一个新的进程组的组长进程，调用setsid()创建的会话将没有控制终端。
setsid()调用成功将返回新会话的会话ID；失败将返回-1，并设置errno。

守护进程

守护进程（Daemon）也称为精灵进程，是运行在后台的一种特殊进程，它独立于控制终端并且周期性地执行某种任务或等待处理某些事情的发生，主要表现为以下两个特点：

⚫ 长期运行。守护进程是一种生存期很长的一种进程，它们一般在系统启动时开始运行，除非强行终止，否则直到系统关机都会保持运行。与守护进程相比，普通进程都是在用户登录或运行程序时创建，在运行结束或用户注销时终止，但守护进程不受用户登录注销的影响，它们将会一直运行着、直到系统关机。
⚫ 与控制终端脱离。在Linux 中，系统与用户交互的界面称为终端，每一个从终端开始运行的进程都会依附于这个终端，这是上一小节给大家介绍的控制终端，也就是会话的控制终端。当控制终端被关闭的时候，该会话就会退出，由控制终端运行的所有进程都会被终止，这使得普通进程都是和运行该进程的终端相绑定的；但守护进程能突破这种限制，它脱离终端并且在后台运行，脱离终端的目的是为了避免进程在运行的过程中的信息在终端显示并且进程也不会被任何终端所产生的信息所打断。

守护进程是一种很有用的进程。Linux 中大多数服务器就是用守护进程实现的，譬如，Internet 服务器inetd、Web 服务器httpd 等。同时，守护进程完成许多系统任务，譬如作业规划进程crond 等。

守护进程Daemon，通常简称为d，一般进程名后面带有d 就表示它是一个守护进程。守护进程与终端无任何关联，用户的登录与注销与守护进程无关、不受其影响，守护进程自成进程组、自成会话，即pid=gid=sid。通过命令"ps -ajx"查看系统所有的进程，如下所示：

TTY 一栏是问号？表示该进程没有控制终端，也就是守护进程，其中COMMAND 一栏使用中括号[]括起来的表示内核线程，这些线程是在内核里创建，没有用户空间代码，因此没有程序文件名和命令行，通常采用 k 开头的名字，表示Kernel。

编写守护进程程序

如何将自己编写的程序运行之后变成一个守护进程呢？本小节就来学习如何编写守护进程程序，编写守护进程一般包含如下几个步骤：

1. 创建子进程、终止父进程
   父进程调用fork()创建子进程，然后父进程使用exit()退出，这样做实现了下面几点：
   第一，如果该守护进程是作为一条简单地 shell 命令启动，那么父进程终止会让shell 认为这条命令已经执行完毕。第二，虽然子进程继承了父进程的进程组ID，但它有自己独立的进程ID，这保证了子进程不是一个进程组的组长进程，这是下面将要调用setsid 函数的先决条件！

2. 子进程调用setsid 创建会话
   这步是关键，在子进程中调用上一小节给大家介绍的setsid()函数创建新的会话，由于之前子进程并不是进程组的组长进程，所以调用setsid()会使得子进程创建一个新的会话，子进程成为新会话的首领进程，同样也创建了新的进程组、子进程成为组长进程，此时创建的会话将没有控制终端。所以这里调用setsid 有三个作用：让子进程摆脱原会话的控制、让子进程摆脱原进程组的控制和让子进程摆脱原控制终端的控制。
   在调用fork 函数时，子进程继承了父进程的会话、进程组、控制终端等，虽然父进程退出了，但原先的会话期、进程组、控制终端等并没有改变，因此，那还不是真正意义上使两者独立开来。setsid 函数能够使子进程完全独立出来，从而脱离所有其他进程的控制。

3. 将工作目录更改为根目录
   子进程是继承了父进程的当前工作目录，由于在进程运行中，当前目录所在的文件系统是不能卸载的，这对以后使用会造成很多的麻烦。因此通常的做法是让“/”作为守护进程的当前目录，当然也可以指定其它目录来作为守护进程的工作目录。

4. 重设文件权限掩码umask
   文件权限掩码umask 用于对新建文件的权限位进行屏蔽，在5.5.5 小节中有介绍。由于使用fork 函数新建的子进程继承了父进程的文件权限掩码，这就给子进程使用文件带来了诸多的麻烦。因此，把文件权限掩码设置为0，确保子进程有最大操作权限、这样可以大大增强该守护进程的灵活性。设置文件权限掩码的函数是umask，通常的使用方法为umask(0)。

5. 关闭不再需要的文件描述符
   子进程继承了父进程的所有文件描述符，这些被打开的文件可能永远不会被守护进程（此时守护进程指的就是子进程，父进程退出、子进程成为守护进程）读或写，但它们一样消耗系统资源，可能导致所在的文件系统无法卸载，所以必须关闭这些文件，这使得守护进程不再持有从其父进程继承过来的任何文件描述符。

6. 将文件描述符号为0、1、2 定位到/dev/null
   将守护进程的标准输入、标准输出以及标准错误重定向到/dev/null，这使得守护进程的输出无处显示、也无处从交互式用户那里接收输入。

7. 其它：忽略SIGCHLD 信号
   处理SIGCHLD 信号不是必须的，但对于某些进程，特别是并发服务器进程往往是特别重要的，服务器进程在接收到客户端请求时会创建子进程去处理该请求，如果子进程结束之后，父进程没有去wait 回收子进程，则子进程将成为僵尸进程；如果父进程wait 等待子进程退出，将又会增加父进程的负担、也就是增加服务器的负担，影响服务器进程的并发性能，在Linux 下，可以将SIGCHLD 信号的处理方式设置为SIG_IGN，也就是忽略该信号，可让内核将僵尸进程转交给init 进程去处理，这样既不会产生僵尸进程、又省去了服务器进程回收子进程所占用的时间。

守护进程一般以单例模式运行，关于单例模式运行请看9.13.3 小节内容。

接下来，我们根据上面的介绍的步骤，来编写一个守护进程程序，示例代码如下所示：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <signal.h>
int main(void)
{
    pid_t pid;
    int i;
    /* 创建子进程*/
    pid = fork();
    if (0 > pid)
    {
        perror("fork error");
        exit(-1);
    }
    else if (0 < pid) // 父进程
        exit(0);      // 直接退出
    /*
     *子进程
     */
    /* 1.创建新的会话、脱离控制终端*/
    if (0 > setsid())
    {
        perror("setsid error");
        exit(-1);
    }
    /* 2.设置当前工作目录为根目录*/
    if (0 > chdir("/"))
    {
        perror("chdir error");
        exit(-1);
    }
    /* 3.重设文件权限掩码umask */
    umask(0);
    /* 4.关闭所有文件描述符*/
    for (i = 0; i < sysconf(_SC_OPEN_MAX); i++)
        close(i);
    /* 5.将文件描述符号为0、1、2 定位到/dev/null */
    open("/dev/null", O_RDWR);
    dup(0);
    dup(0);
    /* 6.忽略SIGCHLD 信号*/
    signal(SIGCHLD, SIG_IGN);
    /* 正式进入到守护进程*/
    for (;;)
    {
        sleep(1);
        puts("守护进程运行中......");
    }
    exit(0);
}

第4 步中调用sysconf(_SC_OPEN_MAX)用于获取当前系统允许进程打开的最大文件数量。

我们在守护进程中添加了死循环，每隔1 秒钟打印一行字符串信息，接下来编译运行：

运行之后，没有任何打印信息输出，原因在于守护进程已经脱离了控制终端，它的打印信息并不会输出显示到终端，在代码中已经将标准输入、输出以及错误重定位到了/dev/null，/dev/null 是一个黑洞文件，自然是看不到输出信息。

使用"ps -ajx"命令查看进程，如下所示：

从上图可知，testApp 进程成为了一个守护进程，与控制台脱离，当关闭当前控制终端时，testApp 进程并不会受到影响，依然会正常继续运行；而对于普通进程来说，终端关闭，那么由该终端运行的所有进程都会被强制关闭，因为它们处于同一个会话。关于这个问题，大家可以自己去测试下，对比测试普通进程与守护进程，当终端关闭之后是否还在继续运行。

守护进程可以通过终端命令行启动，但通常它们是由系统初始化脚本进行启动，譬如/etc/rc*或/etc/init.d/*等。

使用 waitpid() 实现进程异常退出时恢复功能(配合守护进程使用)

https://zhuanlan.zhihu.com/p/70327948

单例模式运行

通常情况下，一个程序可以被多次执行，即程序在还没有结束的情况下，又再次执行该程序，也就是系统中同时存在多个该程序的实例化对象（进程），譬如大家所熟悉的聊天软件QQ，我们可以在电脑上同时登陆多个QQ 账号，譬如还有一些游戏也是如此，在一台电脑上同时登陆多个游戏账号，只要你电脑不卡机、随便你开几个号。
但对于有些程序设计来说，不允许出现这种情况，程序只能被执行一次，只要该程序没有结束，就无法再次运行，我们把这种情况称为单例模式运行。譬如系统中守护进程，这些守护进程一般都是服务器进程，服务器程序只需要运行一次即可，能够在系统整个的运行过程中提供相应的服务支持，多次同时运行并没有意义、甚至还会带来错误！
如果希望我们的程序具有单例模式运行的功能，应该如何去实现呢？

通过文件存在与否进行判断

首先这是一个非常简单且容易想到的方法：用一个文件的存在与否来做标志，在程序运行正式代码之前，先判断一个特定的文件是否存在，如果存在则表明进程已经运行，此时应该立马退出；如果不存在则表明进程没有运行，然后创建该文件，当程序结束时再删除该文件即可！
这种方法是大家比较容易想到的，通过一个特定文件的存在与否来做判断，当然这个特定的文件的命名要弄的特殊一点，避免在文件系统中不会真的存在该文件，接下来我们编写一个程序进行测试。

#include <stdio.h>
#include <stdlib.h>
#include <sys/file.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#define LOCK_FILE "./testApp.lock"
static void delete_file(void)
{
    remove(LOCK_FILE);
}
int main(void)
{
    /* 打开文件*/
    int fd = open(LOCK_FILE, O_RDONLY | O_CREAT | O_EXCL, 0666);
    if (-1 == fd)
    {
        fputs("不能重复执行该程序!\n", stderr);
        exit(-1);
    }
    /* 注册进程终止处理函数*/
    if (atexit(delete_file))
        exit(-1);
    puts("程序运行中...");
    sleep(10);
    puts("程序结束");
    close(fd); // 关闭文件
    exit(0);
}

在上述示例代码中，通过当前目录下的testApp.lock 文件作为特定文件进行判断该文件是否存在，当然这里只是举个例子，如果在实际应用编程中使用了这种方法，这个特定文件需要存放在一个特定的路径下。
代码中以O_RDONLY | O_CREAT | O_EXCL 的方式打开文件，如果文件不存在则创建文件，如果文件存在则open 会报错返回-1；使用atexit 注册进程终止处理函数，当程序退出时，使用remove()删除该文件。
运行测试：

在上面测试中，首先第一次以后台方式运行了testApp 程序，之后再运行testApp 程序，由于文件已经存在，所以open()调用会失败，所以意味着进程正在运行中，所以会打印相应的字符串然后退出。直到第一次运行的程序结束时，才能执行testApp 程序，这样就实现了一个简单地具有单例模式运行功能的程序。
虽然上面实现了一个简单地单例模式运行的程序，但是仔细一想其实有很大的问题，主要包括如下三个方面：
⚫ 程序中使用_exit()退出，那么将无法执行delete_file()函数，意味着无法删除这个特定的文件；
⚫ 程序异常退出。程序异常同样无法执行到进程终止处理函数delete_file()，同样将导致无法删除这个特定的文件；
⚫ 计算机掉电关机。这种情况就更加直接了，计算机可能在程序运行到任意位置时发生掉电关机的情况，这是无法预料的；如果文件没有删除就发生了这种情况，计算机重启之后文件依然存在，导致程序无法执行。
针对第一种情况，我们使用exit()代替_exit()可以很好的解决这种问题；但是对于第二种情况来说，异常退出，譬如进程接收到信号导致异常终止，有一种解决办法便是设置信号处理方式为忽略信号，这样当进程接收到信号时就会被忽略，或者是针对某些信号注册信号处理函数，譬如SIGTERM、SIGINT 等，在信号处理函数中删除文件然后再退出进程；但依然有个问题，并不是所有信号都可被忽略或捕获的，譬如
SIGKILL 和SIGSTOP，这两个信号是无法被忽略和捕获的，故而这种也不靠谱。
针对第三种情况的解决办法便是，使得该特定文件会随着系统的重启而销毁，这个怎么做呢？其实这个非常简单，将文件放置到系统/tmp 目录下，/tmp 是一个临时文件系统，当系统重启之后/tmp 目录下的文件就会被销毁，所以该目录下的文件的生命周期便是系统运行周期。
由此可知，虽然针对第一种情况和第三种情况都有相应的解决办法，但对于第二种情况来说，其解决办法并不靠谱，所以使用这种方法实现单例模式运行并不靠谱。

使用文件锁

介绍完上面第一种比较容易想到的方法外，接下来介绍一种靠谱的方法，使用文件锁来实现，事实上这种方式才是实现单例模式运行靠谱的方法。
同样也需要通过一个特定的文件来实现，当程序启动之后，首先打开该文件，调用open 时一般使用
O_WRONLY | O_CREAT 标志，当文件不存在则创建该文件，然后尝试去获取文件锁，若是成功，则将程序的进程号（PID）写入到该文件中，写入后不要关闭文件或解锁（释放文件锁），保证进程一直持有该文件锁；若是程序获取锁失败，代表程序已经被运行、则退出本次启动。
Tips：当程序退出或文件关闭之后，文件锁会自动解锁！
文件锁属于本书高级I/O 章节内容，在13.6 小节对此做了详细介绍，这里就不再说明，通过系统调用
flock()、fcntl()或库函数lockf()均可实现对文件进行上锁，本小节我们以系统调用flock()为例，系统调用flock()
产生的是咨询锁（建议性锁）、并不能产生强制性锁。
接下来编写一个示例代码，使用flock()函数对文件上锁，实现程序以单例模式运行，如下所示：

#include <stdio.h>
#include <stdlib.h>
#include <sys/file.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>
#define LOCK_FILE "./testApp.pid"
int main(void)
{
    char str[20] = {0};
    int fd;
    /* 打开lock 文件，如果文件不存在则创建*/
    fd = open(LOCK_FILE, O_WRONLY | O_CREAT, 0666);
    if (-1 == fd)
    {
        perror("open error");
        exit(-1);
    }
    /* 以非阻塞方式获取文件锁*/
    if (-1 == flock(fd, LOCK_EX | LOCK_NB))
    {
        fputs("不能重复执行该程序!\n", stderr);
        close(fd);
        exit(-1);
    }
    puts("程序运行中...");
    ftruncate(fd, 0); // 将文件长度截断为0
    sprintf(str, "%d\n", getpid());
    write(fd, str, strlen(str)); // 写入pid
    for (;;)
        sleep(1);
    exit(0);
}

程序启动首先打开一个特定的文件，这里只是举例，以当前目录下的testApp.pid 文件作为特定文件，以O_WRONLY | O_CREAT 方式打开，如果文件不存在则创建该文件；打开文件之后使用flock 尝试获取文件锁，调用flock()时指定了互斥锁标志LOCK_NB，意味着同时只能有一个进程拥有该锁，如果获取锁失败，表示该程序已经启动了，无需再次执行，然后退出；如果获取锁成功，将进程的PID 写入到该文件中，当程序退出时，会自动解锁、关闭文件。
运行测试：

这种机制在一些程序尤其是服务器程序中很常见，服务器程序使用这种方法来保证程序的单例模式运行；在Linux 系统中/var/run/目录下有很多以.pid 为后缀结尾的文件，这个实际上是为了保证程序以单例模式运行而设计的，作为程序实现单例模式运行所需的特定文件，如下所示：

这些以.pid 为后缀的文件，命名方式通常是程序名+.pid，譬如acpid.pid 对应的程序便是acpid、lightdm.pid
对应的程序便是lightdm 等等。如果我们要去实现一个以单例模式运行的程序，譬如一个守护进程，那么也应该将这个特定文件放置于Linux 系统/var/run/目录下，并且文件的命名方式为name.pid（name 表示进程名）。
关于实现单例模式运行相关内容就给大家介绍这么多，最常用的还是使用文件锁，第一种方法通过文件存在否与进行判断事实上并不靠谱；除此之外，还有其它一些方法也可用于实现单例模式运行，譬如在程序启动时通过ps 判断进程是否存在等，关于更多的方法，欢迎大家留言！