进程控制
进程创建
fork函数
在进行进程创建中通常有两种方式:
1️⃣:命令行启动命令(程序、指令等)
2️⃣:通过程序自身,fork出来子进程(所有fork出来的子进程,以父进程为模板,很多数据、代码继承子进程)
首先介绍fork函数,它从已存在进程中创建一个新进程。新进程为子进程,而原进程为父进程
#include <unistd.h>
pid_t fork(void);
返回值:子进程中返回0,父进程返回子进程的id,出错返回-1
进程调用fork,当控制转移到内核中的fork代码后,内核做:
1️⃣分配新的内存块和内核数据结构给子进程
2️⃣将父进程部分数据结构内容拷贝至子进程
3️⃣添加子进程到系统进程列表中
4️⃣fork返回后,开始调度器调度
当一个进程调用fork之后,就有两个二进制代码相同的进程。而且它们都运行到相同的地方。但每个进程都将可以开始它们自己的旅程,看如下程序:
int main( void )
{
pid_t pid;
printf("Before: pid is %d\n", getpid());
if ( (pid=fork()) == -1 )
perror("fork()"),exit(1);
printf("After:pid is %d, fork return %d\n", getpid(), pid);
sleep(1);
return 0;
}
运行结果:
[root@localhost linux]# ./a.out
Before: pid is 43676
After:pid is 43676, fork return 43677
After:pid is 43677, fork return 0
由上述运行结果可以看到了三行输出,一行before,两行after。进程43676先打印before消息,然后它又打印after。另一个after消息由43677打印的。注意到进程43677没有打印before,为什么呢?
由此可以得出结论:fork之前父进程独立执行,fork之后,父子两个执行流分别执行。注意,fork之后,谁先执行完全由调度器决定。
创建子进程,本质是系统多了一个进程,本质是多了一套进程相关的数据结构(以父进程为模板)。在不写入的情况下,用户的代码和数据是父子共享的。
fork函数返回值
👦:子进程返回0
👨:父进程返回的是子进程的pid
❓:fork函数为什么要给子进程返回0,给父进程返回子进程的PID?
🔈:一个父进程可以创建多个子进程,而一个子进程只能有一个父进程。因此,对于子进程来说,父进程是不需要被标识的;而对于父进程来说,子进程是需要被标识的,因为父进程创建子进程的目的是让其执行任务的,父进程只有知道了子进程的PID才能很好的对该子进程指派任务。
❓:为什么fork函数有两个返回值?
🔈:父进程调用fork函数后,为了创建子进程,fork函数内部将会进行一系列操作,包括创建子进程的进程控制块、创建子进程的进程地址空间、创建子进程对应的页表等等。子进程创建完毕后,操作系统还需要将子进程的进程控制块添加到系统进程列表当中,此时子进程便创建完毕了。也就是说,在fork函数内部执行return语句之前,子进程就已经创建完毕了,那么之后的return语句不仅父进程需要执行,子进程也同样需要执行,这就是fork函数有两个返回值的原因。
写时拷贝
👀:当子进程刚刚被创建时,子进程和父进程的数据和代码是共享的,即父子进程的代码和数据通过页表映射到物理内存的同一块空间。只有当父进程或子进程需要修改数据时,才将父进程的数据在内存当中拷贝一份,然后再进行修改。
🔥:通常,父子代码共享,父子再不写入时,数据也是共享的,当任意一方试图写入,便以写时拷贝的方式各自一份副本。
💥:这种在需要进行数据修改时再进行拷贝的技术,称为写时拷贝技术。
🔒:为什么数据要进行写时拷贝?
🔑:进程具有独立性。多进程运行,需要独享各种资源,多进程运行期间互不干扰,不能让子进程的修改影响到父进程。保证父子进程的独立性。
🔈:注意:
1️⃣:所有的数据,父进程和子进程是不会都进行写入的,不需要写入修改的数据拷贝是没有意义的,浪费内存和系统资源。
2️⃣:fork时,要创建数据结构,如果还要将数据拷贝一份,fork的效率是会降低的。
3️⃣:fork本身就是向系统要更多的资源,要更多的资源和要更少的资源,哪一个更容易导致fork失败呢?当然是要更多资源了。
fork常规用法
1️⃣:一个父进程希望复制自己,使父子进程同时执行不同的代码段。例如,父进程等待客户端请求,生成子进程来处理请求。
2️⃣:一个进程要执行一个不同的程序。例如子进程从fork返回后,调用exec函数。
fork调用失败原因
1️⃣:系统中有太多的进程
2️⃣:实际用户的进程数超过了限制
进程终止
进程退出场景
👉代码跑完,结果正确。退出码0
👉代码跑完,结果不正确。逻辑没问题,但是没有导致程序崩溃。退出码!0
👉代码没有运行完毕,程序崩溃了。
进程退出常见方法
正常终止(可以通过
echo $?
查看进程退出码):
1.从main返回
2. 调用exit
3. _exit
为何main中总是return 0 ?
代表进程退出,结果是否运行正确。0:成功。
_exit函数:
#include <unistd.h>
void _exit(int status);
参数:status 定义了进程的终止状态,父进程通过wait来获取该值
exit函数:
#include <unistd.h>
void exit(int status);
exit最后也会调用_exit, 但在调用_exit之前,还做了其他工作:
- 执行用户通过 atexit或on_exit定义的清理函数。
- 关闭所有打开的流,所有的缓存数据均被写入
- 调用_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]#
异常退出:
ctrl + c,信号终止
总结:
1️⃣main函数的return是终止进程,非main函数的return不是终止进程,而是结束函数。
2️⃣任何函数的exit都表示,直接终止进程。
3️⃣ exit:在退出的时候,会进行后续资源处理,包括刷新缓冲区。
4️⃣_exit:在退出的时候,不会进行后续资源处理,直接终止进程。
❓站在OS角度,如何理解进程终止?
核心思想:归还资源
1.“释放”曾经为何管理进程所维护的所有的数据结构对象
2.释放程序代码和数据占用的内存空间
3.取消曾经该进程的连接关系
“释放”:不是真的把数据结构对象销毁,而是设置为不用状态,然后保存起来,如果不用的对象多了,就有一个“数据结构的池”。
进程等待
进程等待必要性
👉回收僵尸进程,解决内存泄露。(子进程退出,父进程如果不读取子进程的退出信息,子进程就会变成僵尸进程,进而造成内存泄漏。)
👉需要获取子进程的运行结束状态。
👉尽量父进程要晚于子进程退出,可以规范化进行资源回收。
👉父进程通过进程等待的方式,回收子进程资源,获取子进程退出信息 。
进程等待的方法
wait方法
等待任意一个子进程,当子进程退出,wait就可以返回。
#include<sys/types.h>
#include<sys/wait.h>
pid_t wait(int*status);
🔴返回值:
成功返回被等待进程pid,失败返回-1。
🔵参数:
输出型参数,获取子进程退出状态,不关心则可以设置成为NULL
waitpid方法
🔸 pid_ t waitpid(pid_t pid, int *status, int options);
⭕️返回值:
1️⃣当正常返回的时候waitpid返回收集到的子进程的进程ID;
2️⃣如果设置了选项WNOHANG,而调用中waitpid发现没有已退出的子进程可收集,则返回0;
3️⃣如果调用中出错,则返回-1,这时errno会被设置成相应的值以指示错误所在;
⭕️参数:
🔴pid:
1️⃣Pid=-1,等待任一个子进程。与wait等效。
2️⃣Pid>0.等待其进程ID与pid相等的子进程。
🔴status:
1️⃣WIFEXITED(status): 若为正常终止子进程返回的状态,则为真。(查看进程是否是正常退出)
2️⃣WEXITSTATUS(status): 若WIFEXITED非零,提取子进程退出码。(查看进程的退出码)
🔴options:
1️⃣WNOHANG: 若pid指定的子进程没有结束,则waitpid()函数返回0,不予以等待。若正常结束,则返回该子进程的ID。
获取子进程status
👉上述进程等待的方法所使用的两个函数wait和waitpid,都有一个status参数,该参数是一个输出型参数,由操作系统进行填充。
👉如果对status参数传入NULL,表示不关心子进程的退出状态信息。
👉否则,操作系统会通过该参数,将子进程的退出信息反馈给父进程。
👉status不能简单的当作整形来看待,可以当作位图来看待,具体细节如下图(只研究status低16比特
位)
在status的低16比特位当中,高8位表示进程的退出状态,即退出码。进程若是被信号所杀,则低7位表示终止信号,而第8位比特位是core dump标志。
//根据status得到进程的退出码和退出信号:
exitCode = (status >> 8) & 0xFF; //退出码
exitSignal = status & 0x7F; //退出信号
系统当中提供了两个宏来获取退出码和退出信号。
exitNormal = WIFEXITED(status); //是否正常退出
exitCode = WEXITSTATUS(status); //获取退出码
🔗当一个进程非正常退出时,说明该进程是被信号所杀,那么该进程的退出码也就没有意义了。
wait方法代码示例
💬例如,创建子进程后,父进程可使用wait函数一直等待子进程,直到子进程退出后读取子进程的退出信息。
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
int main()
{
pid_t id = fork();
if(id == 0){
//child
int count = 10;
while(count--){
printf("I am child...PID:%d, PPID:%d\n", getpid(), getppid());
sleep(1);
}
exit(0);
}
//father
int status = 0;
pid_t ret = wait(&status);
if(ret > 0){
//wait success
printf("wait child success...\n");
if(WIFEXITED(status)){
//exit normal
printf("exit code:%d\n", WEXITSTATUS(status));
}
}
sleep(3);
return 0;
}
💬使用以下监控脚本对进程进行实时监控:
[sun@VM-0-3-centos lesson1]$ while :; do ps axj | head -1 && ps axj | grep proc | grep -v grep;echo "######################";sleep 1;done
💬这时我们可以看到,当子进程进行了10次打印退出后,父进程读取了子进程的退出信息,子进程也就不会变成僵尸进程了。父进程3秒之后也退出了。
waitpid方法代码示例
💬例如,创建子进程后,父进程可使用waitpid函数一直等待子进程(此时将waitpid的第三个参数设置为0),直到子进程退出后读取子进程的退出信息。
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
int main()
{
pid_t id = fork();
if (id == 0){
//child
int count = 10;
while (count--){
printf("I am child...PID:%d, PPID:%d\n", getpid(), getppid());
sleep(1);
}
exit(0);
}
//father
int status = 0;
pid_t ret = waitpid(id, &status, 0);
if (ret >= 0){
//wait success
printf("wait child success...\n");
if (WIFEXITED(status)){
//exit normal
printf("exit code:%d\n", WEXITSTATUS(status));
}
else{
//signal killed
printf("killed by siganl %d\n", status & 0x7F);
}
}
sleep(3);
return 0;
}
在父进程运行过程中,我们可以尝试使用kill -9命令将子进程杀死,这时父进程也能等待子进程成功。
多进程创建及等待
💬例如,以下代码中同时创建了10个子进程,同时将子进程的pid放入到ids数组当中,并将这10个子进程退出时的退出码设置为该子进程pid在数组ids中的下标,之后父进程再使用waitpid函数指定等待这10个子进程。
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()
{
pid_t ids[10];
for (int i = 0; i < 10; i++){
pid_t id = fork();
if (id == 0){
//child
printf("child process created successfully...PID:%d\n", getpid());
sleep(3);
exit(i); //将子进程的退出码设置为该子进程PID在数组ids中的下标
}
//father
ids[i] = id;
}
for (int i = 0; i < 10; i++){
int status = 0;
pid_t ret = waitpid(ids[i], &status, 0);
if (ret >= 0){
//wait child success
printf("wiat child success..PID:%d\n", ids[i]);
if (WIFEXITED(status)){
//exit normal
printf("exit code:%d\n", WEXITSTATUS(status));
}
else{
//signal killed
printf("killed by signal %d\n", status & 0x7F);
}
}
}
return 0;
}
非阻塞式等待
💬上述所给例子中,当子进程未退出时,父进程都在一直等待子进程退出,在等待期间,父进程不能做任何事情,这种等待叫做阻塞等待。
💬实际上我们可以让父进程不要一直等待子进程退出,而是当子进程未退出时父进程可以做一些自己的事情,当子进程退出时再读取子进程的退出信息,即非阻塞等待。
💬向waitpid函数的第三个参数potions传入WNOHANG,这样一来,等待的子进程若是没有结束,那么waitpid函数将直接返回0,不予以等待。而等待的子进程若是正常结束,则返回该子进程的pid。
💬例如,父进程可以隔一段时间调用一次waitpid函数,若是等待的子进程尚未退出,则父进程可以先去做一些其他事,过一段时间再调用waitpid函数读取子进程的退出信息。
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()
{
pid_t id = fork();
if (id == 0){
//child
int count = 3;
while (count--){
printf("child do something...PID:%d, PPID:%d\n", getpid(), getppid());
sleep(3);
}
exit(0);
}
//father
while (1){
int status = 0;
pid_t ret = waitpid(id, &status, WNOHANG);//非阻塞式等待
if (ret > 0){
printf("wait child success...\n");
printf("exit code:%d\n", WEXITSTATUS(status));
break;
}
else if (ret == 0){
printf("father do other things...\n");
sleep(1);
}
else{
printf("waitpid error...\n");
break;
}
}
return 0;
}
运行结果就是,父进程每隔一段时间就去查看子进程是否退出,若未退出,则父进程先去忙自己的事情,过一段时间再来查看,直到子进程退出后读取子进程的退出信息。
进程替换
替换原理
✌️用fork创建子进程后执行的是和父进程相同的程序(但有可能执行不同的代码分支),子进程往往要调用一种exec函数以执行另一个程序。当进程调用一种exec函数时,该进程的用户空间代码和数据完全被新程序替换,从新程序的启动例程开始执行。
❓当进行进程程序替换时,有没有创建新的进程?
⭐️进程程序替换之后,该进程对应的PCB、进程地址空间以及页表等数据结构都没有发生改变,只是进程在物理内存当中的数据和代码发生了改变,所以并没有创建新的进程,而且进程程序替换前后该进程的pid并没有改变。
❓子进程进行进程程序替换后,会影响父进程的代码和数据吗?
⭐️子进程刚被创建时,与父进程共享代码和数据,但当子进程需要进行进程程序替换时,也就意味着子进程需要对其数据和代码进行写入操作,这时便需要将父子进程共享的代码和数据进行写时拷贝,此后父子进程的代码和数据也就分离了,因此子进程进行程序替换后不会影响父进程的代码和数据。
替换函数
其实有六种以exec开头的函数,统称exec函数:
#include <unistd.h>`
int execl(const char *path, const char *arg, ...);
int execlp(const char *file, const char *arg, ...);
int execle(const char *path, const char *arg, ...,char *const envp[]);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execve(const char *path, char *const argv[], char *const envp[]);
命名理解
这些函数原型看起来很容易混,但只要掌握了规律就很好记。
👉l(list) : 表示参数采用列表
👉v(vector) : 参数用数组
👉p(path) : 有p自动搜索环境变量PATH
👉e(env) : 表示自己维护环境变量
exec调用举例
#include <unistd.h>
int main()
{
char *const argv[] = {"ps", "-ef", NULL};
char *const envp[] = {"PATH=/bin:/usr/bin", "TERM=console", NULL};
execl("/bin/ps", "ps", "-ef", NULL);
// 带p的,可以使用环境变量PATH,无需写全路径
execlp("ps", "ps", "-ef", NULL);
// 带e的,需要自己组装环境变量
execle("ps", "ps", "-ef", NULL, envp);
execv("/bin/ps", argv);
// 带p的,可以使用环境变量PATH,无需写全路径
execvp("ps", argv);
// 带e的,需要自己组装环境变量
execve("/bin/ps", argv, envp);
exit(0);
}
事实上,只有execve是真正的系统调用,其它五个函数最终都调用 execve,所以execve在man手册 第2节,其它函数在man手册第3节。这些函数之间的关系如下图所示。
函数解释
1️⃣这些函数如果调用成功则加载新的程序从启动代码开始执行,不再返回。
2️⃣如果调用出错则返回-1
3️⃣所以exec函数只有出错的返回值而没有成功的返回值。