LINUX基础 [三] - 进程创建

前言

进程创建的初次了解（创建进程的原理）

什么是fork函数？

初识fork函数

写时拷贝

fork函数存在的意义

fork调用失败的原因

进程终止

运行完毕结果不正确

main函数返回

库函数函数exit

系统调用接口_exit

进程异常终止

进程等待

进程等待是什么

进程等待为什么要进行

进程等待怎么做

阻塞和非阻塞轮询

前言

上节我们已经讲了进程的概念了，大家应该对进程有感悟同时也有更深入的思考，上节课介绍了那么多进程，但是进程该怎么创建呢，今天就来给大家讲解一下 进程的创建

进程创建的初次了解（创建进程的原理）

创建新进程在Linux的下是由父进程来完成的，创建完成的新进程是子进程。
新进程的地址空间有两种可能性：

子进程是父进程的复制品（除了PID和task_struct是子进程自己的，其余的都从父进程复制而来）
子进程装入另一个程序。
在Linux下的fork函数用于创建一个新的进程，使用fork函数来创建一个进程时，子进程只是完全复制父进程的资源。这样得到的子进程和父进程是独立的，具有良好的并发性。但是进程间通信需要专门的机制。

什么是fork函数？

之前我们在Linux下启动一个进程的时候利用的是./可执行程序，那是否有其他办法去启动一个进程呢？

初识fork函数

当然是有的，那就是使用fork()这个函数。在使用之前呢我们要先去查看一下这个函数该如何使用------ 使用man 手册查询一下 fork 函数的使用

man 2 fork

可以看到，这个函数的功能就是去创建一个子进程，其返回值为pid_t
注意：这里的 pid_t 类型 是无符号整数

函数说明：

通过复制调用进程创建一个新进程。
fork 有两个返回值。
父子进程代码共享，数据各自私有一份（采用写时拷贝）。

接下来，我们来测试一段代码：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>    // getpid, getppid, fork, sleep
#include <sys/types.h>  // getpid, getppid
 
int main()
{
   printf("before: I am a process\n");
 
   fork();
 
   printf("after: 创建一个新进程\n");
 
   return 0;
}

调用fork函数后，内核做了下面的工作：

1、创建了一个子进程的PCB结构体、并拷贝一份相同的进程地址空间和页表（PCB结构体中的一个指针指向该空间）

2、子进程和父进程起初共享代码和数据，并且页表中的虚拟地址和物理地址的映射关系是一样的，所以也指向相同的物理空间。

3、fork返回后将子进程添加到系统的进程列表中，由调度器调用（每个进程开始自己的旅程）

4、一旦其中任意一方尝试修改数据，那么就会发生写时拷贝，会开辟一块新的物理内存，然后改变页表的映射关系。

写时拷贝

通常，父子代码共享，父子再不写入时，数据也是共享的，当任意一方试图写入，便以写时拷贝的方式各自一份副本。

当父进程形成子进程之后，子进程写入，发生写时拷贝，重新申请空间，进行拷贝，修改页表(OS)

但是，我们怎么知道发生了写时拷贝呢？写时拷贝的内容都是由操作系统来完成的

其实父进程创建子进程的时候首先将自己的读写权限改成只读，然后再创建子进程。

此时是操作系统在做，用户并不知道，而且用户可能会对某一数据进行写入，这时页表转换就会出现问题，操作系统就会介入，就触发了我们重新申请内存拷贝内容的策略机制

fork函数存在的意义

fork函数常规用法：

1、一个父进程希望复制自己，使父子进程同时执行不同的代码段。例如，父进程等待客户端请求，生成子进程来处理请求。

2、一个进程要执行一个不同的程序。例如子进程从fork返回后，调用exec函数。（进程替换

fork调用失败的原因

系统中有太多的进程

实际用户的进程数超过了限制

进程终止

问题引入：为什么main函数要返回0？返回多少的意义是什么？？？

成功只有一种情况，但是失败可以有无数的原因和理由！! 所以main函数的本质是进程运行时是否是正确的结果，如果不是，可以用不同的数字表示不同的出错原因！

进程退出场景:

代码运行完毕，结果正确
代码运行完毕，结果不正确
代码异常终止

运行完毕结果不正确

正常终止（可以通过 echo $? 查看进程退出码）： $?->保存最后一次进程退出的退出码

1. 从main返回

2. 调用exit

3. _exit

main函数返回

进程中，谁会关心我的运行情况呢？？——>父进程！

我们之前写代码中，main函数只能return 0吗？

答案是肯定不是!

在多进程环境中，我们创建子进程的目的就是协助父进程办事，但是父进程怎么知道子进程把事情办得怎么样？所以父进程要知道子进程办的怎么样，就有了退出码，而main函数的返回值，就是进程的退出码！

其实main函数本质上也是一个被别人调用的函数，所以他return的结果其实是想告诉他的父进程自己的运行情况。

返回 0 就表示成功，其他数字就表示进程失败的原因，每个不同的数字代表不同的原因！

我们可以通过 strerror 函数来直接查看每个数字代表的意义

它可以返回描述错误码的字符串

#include<stdio.h>
#include<string.h>

int main()
{
	for(int i = 0; i < 200; i++)
	{
		printf("%d: %s\n", i, strerror(i));
	}
	return 0;
}

我们打印结果来看看

退出码 0 正好对应的是成功！

当我们134位置处时，发现已经没有错误信息了。

注意：错误码我们可以自己自定义！

main函数的退出码是可以被父进程获取的，用来判断子进程的运行结果

int main()
{
	return 31;
}

我们可以直接用 echo $? 指令查看进程的退出码：

我们可以发现指令：echo $? 返回的是上一个进程的错误码。当读取了一次之后，再读取就变成了0

库函数函数exit

exit和return的区别：return和exit在main函数里是等价的，因为exit表示退出进程，而main函数恰好执行完return也会退出进程，但是return在其他函数中代表的是函数返回。

系统调用接口_exit

#include void _exit(int status);

参数：status 定义了进程的终止状态，父进程通过wait来获取该值

exit与_exit的区别

首先他们二者都可以让进程终止，并且使用方法也一样，那他们到底有什么区别呢？我们用代码来一探究竟！

//代码一：
int main()
{
	printf("Hello");
	exit(0); 
}

......
//代码二：
int main()
{
	printf("Hello");
    _exit(0); 
}

为什么会出现这种情况呢？

printf打印如果不使用\n换行的话，数据会被存储到缓冲区里。exit函数会帮助我们刷新缓冲区的数据,然而_exit函数不会。因为exit函数在调用exit之前将所有缓存数据都写入了，所以在终止进程时，会将数据打印在屏幕上！

exit比_exit多做了一层最重要的工作就是刷新缓存，我们还可以得出另一个结论就是：缓冲区绝对不在内核区！！因为如果在内核区的话，系统调用的_exit在终止的时候也必然会把缓冲区刷新一下，因为现代操作系统不做任何浪费时间和空间的事情，所以肯定不是由内核维护缓存区，而是由用户区在维护！！（_exit压根看不到缓冲区，所以这个工作只能有exit去完成）

进程异常终止

用退出码可以告诉父进程自己的执行情况，那如果是异常中止了呢？？那就连运行完毕这个条件都完成不了，更别谈结果是否正确了，所以我们可以知道异常必然是最先需要被知道的！因为一旦异常了，一般代码都没跑完，即使跑完了，错误码也不能让人相信，此时退出码就没有意义了！

举个例子：就好比我们平时考试一样，你考不好的时候大家会关心你为啥考不好，但如果你作弊了，性质就变了，即考得再好都让人觉得不可相信。

所以进程结束后应该优先判断该进程是否异常了，然后才能确定退出码能不能用！！

// 当我们在运行这样的代码时

int a = 100;
a /= 0;
......
int *p = NULL;
*p = 100;
......

第一种情况： Floating point exception
第二种情况： Segmentation fault

当然不止这两个情况，但是它们都会让程序进程异常终止！

其实一旦程序出现了异常，操作系统就是通过信号的方式来杀掉这个进程！

而我们的前面两种情况正好对应了kill -8 和 kill -11

类似除0、野指针这样的错误，会触发一些硬件级别的错误，比如除0，cpu的状态寄存器会出现溢出的错误，而野指针，也就是们即将访问的虚拟地址在页表中找不到对应的映射，或者是建立的映射关系只有只读权限，反正最终会转化成一些硬件级别的信号来给操作系统。

所以，父进程需要关心子进程为什么异常，以及发生何种异常，系统会通过信号来告诉我们的进程发生了异常！！

while(1)
{
	printf("hello Linux, pid: %d\n", getpid());
	sleep(1);
}

所以我们最关键的是要看父进程是否收到了信号，如果没有收到就没有异常（具体如何收到，就涉及到进程等待的知识）

进程等待

进程等待是什么

首先在开始之前我们提个问题，到底什么是进程等待？ - 是什么

进程等待的概念：

我们通常说的进程等待其实是通过wait/waitpid的方式，让父进程(一般)对子进程进行资源回收的等待过程，父进程必须等待这个子进程结束后,处理它的代码和数据！

进程等待为什么要进行

在了解完进程等待的概念后，新的问题出现了，我们为什么要进行进程等待？-为什么

在前面的文章中讲过，子进程退出，父进程如果不管不顾，就可能造成“僵尸进程”的问题，进而会造成内存泄露。
另外，进程一旦变成僵尸状态，那就刀枪不入，“杀人不眨眼”的 kill -9 指令也无能为力，因为谁也没有办法杀死一个已经死去的进程。
最后，父进程派给子进程的任务完成的如何，我们需要知道。如：子进程运行完成，结果对还是不对，或者是否正常退出。
父进程通过进程等待的方式，回收子进程资源，获取子进程的退出信息。

进程等待怎么做

我们进行了进程等待分析，发现进程等待非常的有必要。那么进程等待具体是怎么做的？ - 如何做

父进程通过调用wait/waitpid方法来解决僵尸进程回收问题，以及获取子进程退出情况

wait方法

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

pid_t wait(int* status);

返回值：成功，返回被等待进程的 pid，失败返回-1。
参数：输出型参数，获取子进程的退出状态，不关心则可以设置成为 NULL。

waitpid方法

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

pid_t waitpid(pid_t pid, int* status, int options);

返回值：

当正常返回的时候 waitpid 返回等待到的子进程的进程 ID；
如果设置了选项 WNOHANG，而调用的过程中没有子进程退出，则返回0；
如果调用中出错，则返回-1，这时 errno 会被设置成相应的值以指示错误所在。

pid：

pid = -1 表示等待任意一个子进程。与 wait 等效；
pid > 0 表示等待进程 ID 与 pid 相等的子进程。

status：

WIFEXITED(status)：查看子进程是否正常退出。若为正常终止子进程返回的状态，则为真；WEXITSTATUS(status)：查看进程的退出码。若非零，提取子进程的退出码。

options：

0：表示父进程以阻塞的方式等待子进程，即子进程如果处在其它状态，不处在僵尸状态（Z状态），父进程会变成 S 状态，操作系统会把父进程放到子进程 PCB 对象中维护的等待队列中，以阻塞的方式等待子进程变成僵尸状态，当子进程运行结束，操作系统会检测到，把父进程重新唤醒，然后回收子进程；
WNOHANG：非阻塞轮询等待，若 pid 指定的子进程没有结束，处于其它状态，则 waitpid() 函数返回0，不予等待。若正常结束，则返回该子进程的 ID。

小Tips：wait 和 waitpid 都只能等待该进程的子进程，如果等待了其它的进程那么就会出错。

阻塞和非阻塞轮询

父进程只等待一个进程（阻塞式等待）

#include <stdio.h>    
#include <unistd.h>    
#include <stdlib.h>    
#include <sys/types.h>    
#include <sys/wait.h>    
    
int main()    
{    
    pid_t id = fork();    
    if(id < 0)    
    {    
        perror("fork");    
        return 1;    
    }    
    else if(id == 0)    
    {    
        // child    
        int cnt = 5;    
        while(cnt)    
        {    
            printf("I am child, pid：%d, ppid：%d, cnt：%d\n", getpid(), getppid(), cnt--);    
            sleep(1);    
        }    
        exit(0);    
    }    
    else    
    {    
        int cnt = 10;    
        // parent    
        while(cnt)    
        {    
            printf("I am parent, pid：%d, ppid：%d, cnt：%d\n", getpid(), getppid(), cnt--);    
            sleep(1);    
        }    
    
        int ret = wait(NULL);    
        if(ret == id)    
        {    
            printf("wait success!\n");    
        }    
        sleep(5);                                                                                                                                               
    }    
    
    return 0;    
}

前五秒父子进程同时运行，紧接着子进程退出变成僵尸状态，五秒钟后父进程对子进程进行了等待，成功将子进程释放掉，最后再五秒钟后父进程也退出，整个程序执行结束。

父进程等待多个子进程（阻塞式等待）

一个 wait 只能等待任意一个子进程，因此父进程如果要等待多个子进程可以通过循环来多次调用 wait 实现等待多个子进程。

#include <stdio.h>    
#include <unistd.h>    
#include <stdlib.h>    
#include <sys/types.h>    
#include <sys/wait.h>    
    
#define N 5    
// 父进程等待多个子进程    
void RunChild()    
{    
    int cnt = 5;    
    while(cnt--)    
    {    
        printf("I am child, pid：%d, ppid：%d\n", getpid(), getppid());    
        sleep(1);    
    }    
    return;    
}    
int main()    
{    
    for(int i = 0; i < N; i++)    
    {    
        pid_t id = fork();// 创建一批子进程    
        if(id == 0)    
        {    
            // 子进程    
            RunChild();    
            exit(0);    
        }    
        // 父进程    
        printf("Creat process sucess：%d\n", id);    
    }    
    
    sleep(10);    
    
    for(int i = 0; i < N; i++)    
    {    
        pid_t id = wait(NULL);                                                                                
        if(id > 0)    
        {    
            printf("Wait process：%d, success!\n", id);    
        }    
    }    
    
    sleep(5);    
    return 0;    
}