5.进程控制

进程控制

fork函数

#include <unistd.h>
pid_t fork(void);
返回值：自进程中返回0，父进程返回子进程id，出错返回-1

一般面试题：fork创建子进程，操作系统做了什么？

进程调用fork，当控制转移到内核中的fork代码后，内核做：

分配新的内存块和内核数据结构给子进程

将父进程部分数据结构内容拷贝至子进程

添加子进程到系统进程列表当中

fork返回，开始调度器调度，fork之后哪个进程先执行由调度器决定
fork调用失败的原因：系统中有太多的进程、实际用户的进程数超过了限制

我们知道，进程=内核数据结构+进程代码和数据
代码和数据哪里来？从磁盘中来，也就是你C/C++程序加载之后的结果。

创建子进程，操作系统给子进程分配对应的内核结构，这个结构式子进程自己独有的，因为进程具有独立性。
理论上，子进程也要有自己的代码和数据，但是一般而言，我们调用fork时，没有加载的过程啊，也就是说子进程没有自己的代码和数据，所以子进程只能“使用”父进程的代码和数据！
代码都是不可被写的，只能读取，父子进程共享代码，这没问题，
但数据呢，子进程的数据可能被修改，而父进程的数据可能不会被修改，所以，两个进程的数据，必须分离

通过什么方式分离父子进程的数据？上一篇我们讲过，就是写实拷贝

写实拷贝

写实拷贝的原理图在linux系统进程已经讲过了，这里就不画了
对于数据而言，创建进程的时候难道不直接拷贝父进程的数据然后分离吗？
答：如果创建进程的时候就直接拷贝分离，那么拷贝的时候，子进程可能会拷贝了根本不需要的数据，即便用到了，也可能是只读的，这样也太浪费空间了。编译器编译程序的时候尚且知道节省空间

创建进程的时候，能不能将不需要、不会被访问、只读取的数据不拷贝？怎么提前知道哪些数据值得拷贝？
答：无法知道，即便是OS也无法提前知道哪些数据需要被写入更新，即便提前拷贝了，你立马会使用吗

什么样的数据值得拷贝？
答：将来会被父进程或子进程写入的数据

所以OS选择写实拷贝技术，来将父子进程的数据进行分离

用的时候，再给你分配，是高效使用内存的一种表现

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

当调用 fork() 函数创建子进程时，操作系统并不立即复制父进程的内存空间给子进程，而是采用写时复制的策略。这意味着父子进程会共享相同的物理内存，直到其中一个进程尝试修改内存中的内容时，才会触发复制操作，确保父子进程之间的独立性。

写实拷贝是父子进程保持独立性的关键策略，因为它避免了不必要的内存复制，提高了程序的运行效率，并确保了父子进程之间的数据隔离。这种延迟复制的方式，在大多数情况下，减少了额外的内存开销，使得父子进程能够共享相同的内存空间，同时又能保持各自的独立性。

EIP寄存器的作用

我们的代码汇编后，会有很多行代码，并且每行汇编代码加载到内存之后都有对应的地址

进程可能随时被终端，下次回来，必须从上一次中断的位置开始，这就要求cpu必须随时记录下当前进程中断之前执行的位置

所以，cpu内就有对应的寄存器数据，用来记录当前进程的执行位置，这个寄存器叫eip

eip寄存器在cpu内只有1份，这些寄存器数据就叫进程的上下文数据

进程终止

进程终止时，OS做了什么？
当然是释放进程申请相关的内核数据结构和对应的数据和代码，本质就是释放系统资源

进程终止的常见方式

a.代码跑完，结果正确
b.代码跑完，结果不正确
c.代码没跑完，程序崩溃了（信号部分内容，涉及到1点点）
a和b类情况，代码会跑完，main函数都会有1个返回值，就是return 0

return 0的含义是什么，为总是0
返回0代表成功，返回非0，表示运行结果不正确
这就是进程的退出码，根据退出码的不同可以定位错误的原因

可以通过echo $?命令来获取最近一个进程执行完毕的退出码
在main函数内，return语句就是终止进程的

_exit函数

#include <unistd.h>
void _exit(int status);
参数：status 定义了进程的终止状态，父进程通过wait来获取该值

说明：虽然status是int，但是仅有低8位可以被父进程所用。所以_exit(-1)时，在终端执行$?发现返回值是255

exit函数

#include <unistd.h>
void exit(int status);

#include<stdlib.h>
int main()
{
	exit(111);//正常进场终止,111是作者自己赋予的退出码
}

exit最后也会调用_exit, 但在调用exit之前，还做了其他工作：

1. 执行用户通过 atexit或on_exit定义的清理函数。

2. 关闭所有打开的流，所有的缓存数据均被写入

3. 调用_exit

库函数vs系统接口

我们使用printf的时候，数据保存在一个“缓冲区”内，请问这个“缓冲区”在哪里，属于用户空间还是内核空间？谁维护这个缓冲区？

答案是在用户空间，C标准库给我们维护的

如果是操作系统维护的缓冲区，_exit也能刷新出来

int main()
{
printf("hello");
exit(0);
}
运行结果:
[root@localhost linux]# ./a.out
hello[root@localhost linux]#

int main()
{
printf("hello");
_exit(0);
}
运行结果:
[root@localhost linux]# ./a.out
[root@localhost linux]#

进程等待

进程等待的必要性

之前讲过，子进程退出，父进程如果不管不顾，就可能造成‘僵尸进程’的问题，进而造成内存泄漏。

另外，进程一旦变成僵尸状态，那就刀枪不入，“杀人不眨眼”的kill -9 也无能为力，因为谁也没有办法杀死一个已经死去的进程。

最后，父进程派给子进程的任务完成的如何，我们需要知道。如，子进程运行完成，结果对还是不对，或者是否正常退出。

父进程通过进程等待的方式，回收子进程资源，获取子进程退出信息

wait函数

#include<sys/types.h>
#include<sys/wait.h>
pid_t wait(int*status);
/*返回值：
 成功返回被等待进程pid，失败返回-1。
参数：
 输出型参数，获取子进程退出状态,不关心则可以设置成为NULL*/

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<string.h>
int main()
{
        pid_t id=fork();
        if(id<0)
        {
			   perror("创建子进程失败");
                exit(1);//自定义退出码为1,标识进程运行完毕，结果不正确
        }
        else if(id == 0)
        {
                //子进程
                int cnt = 5;
                while(cnt)
                {
                        printf("cnt: %d,我是子进程,pid:%d,ppid:%d\n",cnt,getpid(),getppid());
                        sleep(1);
                        cnt--;
                }
                exit(0);//终止了子进程
        }
        else
        {
                printf("我是父进程，pid:%d,ppid:%d\n",getpid(),getppid());
                pid_t ret=wait(NULL);//等待子进程,阻塞式等待,子进程没走完，父进程会一直呆在这行代码，下面代码不会被执行
                if(ret>0)
                {
                        printf("等待子进程成功,ret%d\n",ret);
                }
                /*while(1)
                {
                        printf("我是父进程,pid:%d,%ppid:%d\n",getpid(),getppid());
                        sleep(1);
                }*/
        }
}

waitpid()函数

pid_ t waitpid(pid_t pid, int *status, int options);
//返回值：
 当正常返回的时候waitpid返回收集到的子进程的进程ID；
 如果设置了选项WNOHANG,而调用中waitpid发现没有已退出的子进程可收集,则返回0；
 如果调用中出错,则返回-1,这时errno会被设置成相应的值以指示错误所在；
//参数
 //pid：
 Pid=-1,等待任一个子进程。与wait等效。
 Pid>0.等待其进程ID与pid相等的子进程。
 //status（输出型参数）:
 WIFEXITED(status): 若为正常终止子进程返回的状态，则为真。（查看进程是否是正常退出）
 WEXITSTATUS(status): 若WIFEXITED非零，提取子进程退出码。（查看进程的退出码）
// options:
 0:表示阻塞等待
 WNOHANG: 非阻塞等待。若pid指定的子进程没有结束，则waitpid()函数返回0，不予以等待。若正常结束，则返回该子进程的ID。

如果子进程已经退出，调用wait/waitpid时，wait/waitpid会立即返回，并且释放资源，获得子进程退出信息。

如果在任意时刻调用wait/waitpid，子进程存在且正常运行，则进程可能阻塞。

如果不存在该子进程，则立即出错返回。

子进程完成后，父进程调用wait或者waitpid来防止或结束子进程的僵尸状态，并且可以获取到子进程的退出结果，包括信号编号和退出码

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<string.h>
int main()
{
        pid_t id=fork();
        if(id<0)
        {
			   perror("创建子进程失败");
                exit(1);//自定义退出码为1,标识进程运行完毕，结果不正确
        }
        else if(id == 0)
        {
                //子进程
                int cnt = 5;
                while(cnt)
                {
                        printf("cnt: %d,我是子进程,pid:%d,ppid:%d\n",cnt,getpid(),getppid());
                        sleep(1);
                        cnt--;
                }
                exit(105);//终止了子进程,并返回退出码105供status接收
        }
        else
        {
                printf("我是父进程，pid:%d,ppid:%d\n",getpid(),getppid());
            	int status=0;
                pid_t ret=waitpid(id,&status,0);//第三个参数设置为0，表示阻塞等待
                if(ret>0)
                {
                        printf("等待子进程成功,ret%d,status:%d\n",ret,(status>>8)&0xFF);//status次低八位才是子进程exit返回的退出码，所以status需要右移8位
                }
        }
}

status参数的理解

wait和waitpid，都有一个status参数，该参数是一个输出型参数，由操作系统填充。
如果传递NULL，表示不关心子进程的退出状态信息。
否则，操作系统会根据该参数，将子进程的退出信息反馈给父进程。
status不能简单的当作整形来看待，可以当作位图来看待，具体细节如下图（只研究status低16比特位）

status低7位是信号码

//打印信号编号
printf("等待子进程成功,ret%d,子进程收到的信号编号%d,status:%d\n",ret,(status&0x7F)，(status>>8)&0xFF);
//0x7F转换成二进制是0111 1111,与上这7位1，目的是保留低7位的值，其余位全部变为0

进程异常退出，或者崩溃，本质是OS杀掉了你的进程
OS如何杀掉进程？本质是通过发送信号方式（在信号文章讲）

程序异常，不光是内部代码有问题，也可能是外力直接杀掉(这时候子进程代码跑完了吗？不确定)

进程退出码也是子进程的数据，为什么父进程就能拿到？

我们接下来讨论一下以下情况
1.父进程通过wait/waitpid可以拿到子进程的退出结果，一定要用wait/waitpid函数吗？直接使用全局变量行不行？
答：不可以，进程具有独立性，数据修改就要发生写实拷贝，则父进程无法拿到子进程的退出结果

2.既然进程具有独立性，进程退出码不也是子进程的数据吗？父进程凭什么拿到？wait/waitpid究竟干了什么？

回答这个问题之前，先有一个理解：僵尸进程至少保留该进程的PCB信息，进程结构体里保留了进程退出时的退出结果信息，所以子进程退出时，它的结构体会保留退出信息

现在来说为什么在进程具有独立性的情况下，父进程能拿到子进程的退出码。
父进程调用wait/waitpid，本质是通过这个函数读取子进程task_struct结构体里的int exit_code, exit_signal成员变量。
wait/waitpid有这个权利读取子进程结构体里的成员变量吗？
有的，wait就是系统调用接口，就是操作系统来读取（进入内核态来读取）

也可以通过宏来获取指定进程的退出码和信号

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

if(WIFEXITED(status))
{
	//为真，子进程是正常退出的	
	//提取退出码
	printf("子进程执行完毕，退出码位：%d\n"，WEXITSTATUS(status));
}else{
	//不为真，子进程异常退出
	printf("子进程异常退出，退出码位：%d\n"，WEXITSTATUS(status));
}

阻塞等待，本质是把进程阻塞在wait/waitpid系统函数的内部

waitpid的第3个参数设置为0，就是阻塞等待；设置为WHOHANG，就是非阻塞等待。
WHOHANG其实是 wait no hang（夯住了，不要挂着等待）。
设置了WHOHANG后，父进程先设置waitpid等待子进程，如果检查到子进程的退出状态，发现子进程没有退出，父进程调用的waitpid会立马返回。
让我们来看看waitpid的部分源码是怎么实现让进程阻塞和非阻塞等待的

在waitpid函数内部（在内核）

如果status==退出（子进程推出了），则返回子进程ID给父进程；

如果status==没退出（子进程还在运行，没有退出），

且如果flag标志位为0（阻塞式等待），则把父进程PCB放进等待队列中，（所以阻塞本质，是把进程阻塞在系统调用函数的内部）

如果flag标志位为WHOHANG（非阻塞等待），则函数内部给父进程立马返回0，不把父进程放进等待队列

当条件满足时，父进程被唤醒，从哪里唤醒，从if(flag==0)这里唤醒，因为有EIP寄存器保存着下一行代码的地址，唤醒后waitpid函数立马返回

进程的程序替换

替换原理

用fork创建子进程后执行的是和父进程相同的程序(但有可能执行不同的代码分支),子进程往往要调用一种exec函数以执行另一个程序。当进程调用一种exec函数时,该进程的用户空间代码和数据完全被新程序替换,从新程序的启动例程开始执行。调用exec并不创建新进程,所以调用exec前后该进程的id并未改变

进程替换，没有创建新的子进程。
如何理解所谓的讲程序放入内存？
就是程序加载到内存中，而exec*系列函数，本质就是如何加载程序的函数。


程序替换函数，只是替换了进程地址空间的数据和代码，并和当前进程的页表建立新的映射，其它不发生变化

替换函数

execl函数

后面的…是指字符一个一个传入的意思

int execl( const char*path,const char*arg,...);//三个点是可变参数列表，即可以传入多个不定参数

execl参数中，第一个参数是路径+文件名，第二个到倒数第2个参数，是可以传入的多个不定参数，最后1个参数必须填nullptr

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/wait.h>
int main()
{
	printf("当前进程开始的代码！\n");
    execl("/usr/bin/ls","ls","-l","-a",NULL);//最后一个参数必须是NULL
    printf("当前进程的结束代码!\n");
}

执行execl函数成功后，printf(“当前进程的结束代码!\n”)这行代码就不会执行，因为程序替换会将已经执行和未执行的代码都替换了

所以一旦execl调用成功，原程序后续所有代码都不会再执行。
execl需要返回值吗？
不需要，execl不需要进行函数返回判定有没有替换成功

下面是更加系统的解释：
execl() 函数是一个执行新程序的系统调用，它会替换当前进程的映像为指定程序的映像，并开始执行新程序。在成功执行 execl() 函数后，当前进程的代码、数据和堆栈都会被新程序所取代，因此 execl() 函数本身并不返回到调用它的地方。

如果 execl() 函数成功执行，那么原来的进程映像已经被替换为新程序，并且新程序开始执行。因此，从 execl() 函数返回是不可能的，因为执行成功后进程就已经变成了新程序，原进程已经不存在。因此，即使 execl() 函数在执行成功后确实会返回，但这个返回值对调用者没有任何意义。

如果 execl() 函数返回到调用者，这通常表示执行失败。execl() 函数只有在发生错误时才会返回，返回值为 -1，并且设置全局变量 errno 表示错误的类型。因此，一般来说，如果 execl() 函数返回到调用者，这意味着它执行失败，调用者需要根据返回值进行错误处理。

Makefile规则

在 Makefile 文件中，gcc -o $@ $^ 是一行规则（rule），用于指示 make 工具如何生成目标文件。在这行代码中，$@ 和 $^ 是自动化变量，它们在 make 运行时会被替换为相应的数值。

• $@：表示规则中的目标文件名。
• $^：表示规则中的所有依赖文件名（即所有必须用来生成目标文件的文件）。

因此，gcc -o $@ $^ 的含义是使用 gcc 编译器将所有依赖文件（$^）链接在一起生成目标文件（$@）。

app: main.o func1.o func2.o
    gcc -o $@ $^

在这个例子中，app 是目标文件，main.o、func1.o、func2.o 是依赖文件。当运行 make app 命令时，make 工具会根据上述规则使用 gcc 编译器将 main.o、func1.o 和 func2.o 链接在一起生成 app 可执行文件。

一次形成多个可执行程序

makefile从上到下被扫描时，先扫描到all目标文件，all目标文件又依赖于exec、mycmd可执行程序，然后分别推导执行对应生成可执行程序的命令

如何执行自己写的二进制程序？