说一说 Linux 进程控制

引言

 

在上一则发表的关于 Linux 的文章中，叙述了 Linux 的相关概念，其中就包括进程的资源，进程的状态，以及进程的属性等相关内容，在本则教程中，将着重叙述 Linux 进程管理的内容，其中就包括 Linux 进程的创建，进程的终止，进程的等待相关内容。

Linux 进程的创建

 

函数 fork

现有的一个进程可以调用 fork 函数创建一个新进程：

1. #include <unistd.h> 
2. pid_t fork(void); 
3. /* 返回值：子进程返回 0，父进程返回子进程 ID;若出错，返回 -1 */ 

由 fork 创建的新进程被称为子进程。fork 函数被调用一次，但返回两次。两次返回的区别是子进程返回值是0，而父进程的返回值是新建子进程的进程 ID，子进程创建的过程大概是这样的：从调用系统调用 fork 后就有了子进程，fork 创建子进程是以父进程为模板的、

下面是一个 fork 函数创建一个进程的例子：

1. int main(int argc, char **argv) 
2. { 
3.     printf("I am process!\r\n"); 
4.     pid_t id = fork(); 
5.     if (id < 0) 
6.     { 
7.         printf("fork error\r\n"); 
8.     } 
9.     else if (id == 0) 
10.     { 
11.         printf("I am child process and myid is :%d, my parent id is :%d\r\n",getpid(),getppid()); 
12.         sleep(3); 
13.     } 
14.     else 
15.     { 
16.         printf("I am parent process and myid is:%d\r\n",getpid()); 
17.         sleep(3); 
18.     } 
19.     printf("Now you can see me!\r\n"); 
20.     sleep(3); 
21.     return 0; 
22. } 

下面是代码的运行结果：

在使用 fork 创建子进程的时候，内核所做的工作是：

• 分配新的内存块和描述进程的数据结构给子进程
• 将父进程部分数据结构内容拷贝到子进程
• 添加子子进程到系统进程列表中
• fork 返回，开始调度器调度

需要注意的是：fork 之前父进程独立运行，fork 之后，父子两个执行流分别运行。且 fork 之后，由调度器决定运行顺序

子进程获得父进程数据空间、堆和栈的副本。需要注意的是，这是子进程所拥有的副本。父进程和子进程并不共享这些存储空间部分，但是由于在 fork 之后经常跟随着 exec，所以现在很多实现并不执行一个父进程数据段、堆和栈的完全副本，作为替代，使用了写时复制技术，这些区域由父进程和子进程共享，而且内核将他们的访问权限改变为只读。

写时复制原理

在讲述写时复制的原理之前，首先得弄明白虚拟内存和物理内存两个概念：

• 物理内存：也就是相电脑的内存条，如果电脑安装了 2GB 的内存条，那么系统就拥有 0~2GB 的物理内存空间。
• 虚拟内存：虚拟内存是使用软件模拟的，例如在 32 位的操作系统下，那么每个进程都独占 4GB 的虚拟内存空间

应用程序使用的是虚拟内存，而虚拟内存必须要映射到物理内存中才可以使用，如果没有映射到虚拟内存地址，那么就会导致缺页异常。下面是虚拟内存和物理内存映射时的一个示意图：

通过上述的示意图可以看出来，引入了虚拟内存的概念之后，两个进程相同的虚拟内存地址能够映射到不同的物理地址中。

在介绍了虚拟内存和物理内存之后，紧接着来介绍写时复制的基本原理，在前面的介绍中，我们知道虚拟内存要能够进行使用，必须映射到物理内存，如果不同进程的虚拟内存地址映射到相同的物理内存地址，那么就实现了共享内存机制。也就是如下图所示：

通过上述的示意图可以看出来，进程 A 的虚拟内存空间和进程 B 的虚拟内存空间映射到了一块相同的物理内存地址中，所以呢，当修改进程 A 的虚拟内存空间的数据时，那么进程 B 虚拟内存的数据也会跟着改变。

依据这样一个原理，实现了写时复制的机制：

写时复制的一个过程大致如下所示：

• 创建子进程时，将父进程的虚拟内存与物理内存映射关系复制到子进程，并将内存设置为只读
• 当子进程或者父进程对内存数据进行修改的时候，便会触发写时复制机制，将原来的内存页复制一份新的，并重新设置其内存映射关系，将父子进程的内存读写权限设置为可读写。

image-20210627103516488

但这个时候只能对内存进行读操作，如果父进程或子进程对内存进行写操作，那么将会触发 缺页异常，而在 缺页异常 处理中会对物理内存进行复制，并且重新映射其内存映射关系，这也就是写时复制的机制。

回过头来，对于 fork 来讲，有以下两种用法：

• 一个父进程希望复制自己，使得父进程和子进程同时执行不同的代码段，这在网络服务进程中是常见的，父进程等待客户端的服务请求。当这种请求到达的时候，父进程调用 fork ，使子进程处理此请求。父进程则继续等待下一服务请求。
• 一个进程要执行一个不同的程序，在这种情况下，子进程调用 fork 返回后立即调用 exec 。

而调用 fork 失败的原因主要是：

• 系统中已经有太多的进程了
• 该实际用户 ID 的进程总数超过了系统限制

进程中止

进程有五种正常终止以及3种异常终止方式。首先叙述下5种正常的终止方式：

• 在 main 函数中执行 return 语句，这等效于调用 exit。
• 调用 exit 函数
• 调用 _exit或 _Exit，对于 _Exit 来说，其目的是为进程提供一种无需运行终止处理程序或者信号处理程序而终止的方法。
• 进程的最后一个线程在启动例程中执行 return 语句。但是，该线程的返回值不用作进程的返回值。当最后一个线程从其启动例程返回时，该进程以终止状态 0 返回。
• 进程的最后一个线程调用 pthread_exit函数，与前面一样，进程的终止状态总是 0。

三种异常终止具体如下：

• 调用 abort,产生 SIGABRT 信号，这是下一种异常终止的特例。
• 当进程收到某些信号时
• 最后一个进程对“取消”请求做出响应

不管进程如何终止，最后都会执行内核中的同一段代码。这段代码为相应进程关闭所有打开描述符，释放它所使用的存储器。

函数 wait 和 waitpid

调用 wait 和 waitpid 会发生如下几件事：

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

如果进程是在接受到 SIGABRT 信号而调用 wait ，我们期望 wait 会立即返回，但是如果是在随机时间点调用 wait ,那么进程可能会阻塞。

下面是这两个函数的原型：

1. #include <sys/wait.h> 
2.  
3. pid_t wait(int *statloc); 
4. pid_t waitpid(pid_t pid,int *statloc,int options); 
5. /* 两个函数返回值:若成功，则返回进程 ID；若失败，则返回 0 或者 -1 */ 

除了这两个函数之外，类似的调用还有其他的函数，这里就不进行赘述了。

竞争条件

当多个进程都企图对共享数据进行某种处理，而最后的结果又取决于进程运行的顺序时，我们认为发生了竞争条件。如果在 fork 之后的某种逻辑显示或隐式地依赖于在 fork 之后是父进程先运行还是子进程先运行，那么 fork 函数就会是竞争条件活跃的滋生地。

如果一个进程希望等待一个子进程终止，则它必须调用 wait 函数中的一个，如果一个进程要等待其父进程终止，则可以使用下列形式的循环：

1. while (getppid() != 1) 
2.     sleep(1); 

这种形式的循环称为轮询，它的问题是浪费了 CPU 时间，因为调用者每隔 1s 都被唤醒，然后进行条件测试，为了避免竞争条件和轮询，在多个进程之间需要有某种形式的信号发送和接收的方法。详细地在下次进行叙述。

函数 exec

在使用了 fork 函数创建新的子进程后，子进程往往要调用一种 exec 函数以执行另一个程序。当进程调用一种 exec 函数时，该进程执行的程序完全替换为新程序。通俗地理解这句话，也就是说，在 Window 平台下，我们可以通过双击运行可执行程序，让这个可执行程序成为一个进程;然而在 Linux 平台下，我们可以通过运行 ./，让一个可执行程序成为一个进程。

如果我们本来就运行着一个程序(进程),如何在这个进程内部启动一个外部程序，由内核将这个外部程序读入内存，使其执行起来成为一个进程呢?这里通过 exec函数族来实现。

exec函数族，顾名思义，也就是一族函数，在 Linux 中，也不存在着exec()函数，exec指的是一组函数 ：

1. #include <unistd.h> 
2. int execl(const char *path, const char *arg, ...); 
3. int execlp(const char *file, const char *arg, ...); 
4. int execle(const char *path, const char *arg, ..., char * const envp[]); 
5. int execv(const char *path, char *const argv[]); 
6. int execvp(const char *file, char *const argv[]); 
7. int execve(const char *path, char *const argv[], char *const envp[]); 

其中只有execve()是真正意义上的系统调用，其它都是在此基础上经过包装的库函数。

进程调用一种 exec 函数时，该进程完全由新程序替换，而新程序则从其 main 函数开始执行。因为调用 exec 并不创建新进程，所以前后的进程 ID (当然还有父进程号、进程组号、当前工作目录……)并未改变。exec 只是用另一个新程序替换了当前进程的正文、数据、堆和栈段(进程替换)。

接下来举一个例子，关于execl() 示例代码:

1. #include <stdio.h> 
2. #include <unistd.h> 
3.  
4. int main(int argc, char *argv[]) 
5. { 
6.      printf("before exec\n\n"); 
7.  
8.      /* /bin/ls：外部程序，这里是/bin目录的 ls 可执行程序，必须带上路径（相对或绝对） 
9.        ls：没有意义，如果需要给这个外部程序传参，这里必须要写上字符串，至于字符串内容任意 
10.        -a，-l，-h：给外部程序 ls 传的参数 
11.        NULL：这个必须写上，代表给外部程序 ls 传参结束 
12.     */ 
13.      execl("/bin/ls", "ls", "-a", "-l", "-h", NULL); 
14.  
15.      // 如果 execl() 执行成功，下面执行不到，因为当前进程已经被执行的 ls 替换了 
16.      perror("execl"); 
17.      printf("after exec\n\n"); 
18.  
19.      return 0; 
20. } 

下面是代码执行的结果：

小结

本次内容的分享就到这里了，主要是叙述了Linux进程管理的相关内容，其中就包括Linux进程创建，进程中止，进程等待等内容，在下一则内容中将着重分享进程间通信的相关内容，每周一篇，坚持呀~

原文链接：https://mp.weixin.qq.com/s/TxDVQcZlSRE0ZPonHps_eg